Treat `Function` literals uniformly, expecting SAM or FunctionN.

They both compile to INDY/MetaLambdaFactory, except when they
occur in a constructor call. (TODO: can we lift the ctor arg
expression to a method and avoid statically synthesizing
anonymous subclass altogether?)

Typers:
  - no longer synthesize SAMs -- *adapt* a Function literal
    to the expected (SAM/FunctionN) type
  - Deal with polymorphic/existential sams (relevant tests:
    pos/t8310, pos/t5099.scala, pos/t4869.scala) We know where
    to find the result type, as all Function nodes have a
    FunctionN-shaped type during erasure. (Including function
    literals targeting a SAM type -- the sam type is tracked as
    the *expected* type.)

    Lift restriction on sam types being class types. It's enough
    that they dealias to one, like regular instance creation
    expressions.

Contexts:
  - No longer need encl method hack for return in sam.

Erasure:
  - erasure preserves SAM type for function nodes
  - Normalize sam to erased function type during erasure,
    otherwise we may box the function body from `$anonfun(args)`
    to `{$anonfun(args); ()}` because the expected type for the
    body is now `Object`, and thus `Unit` does not conform.

Delambdafy:
  - must set static flag before calling createBoxingBridgeMethod
  - Refactored `createBoxingBridgeMethod` to wrap my head around
    boxing, reworked it to generalize from FunctionN's boxing
    needs to arbitrary LMF targets.

Other refactorings: ThisReferringMethodsTraverser, TreeGen.

1 files changed, 1 insertions, 2 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
index bdcf90681d..c5a3d605b1 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
@@ -478,8 +478,7 @@ trait Contexts { self: Analyzer =>
       c(ConstructorSuffix) = !isTemplateOrPackage && c(ConstructorSuffix)
 
       // SI-8245 `isLazy` need to skip lazy getters to ensure `return` binds to the right place
-      // similarly for the synthetic method that holds as a SAM's body (as synthesized by `synthesizeSAMFunction`)
-      c.enclMethod         = if (isDefDef && !(owner.isLazy || owner.name.endsWith(nme.SAM_BODY_SUFFIX))) c else enclMethod
+      c.enclMethod         = if (isDefDef && !owner.isLazy) c else enclMethod
 
       if (tree != outer.tree)
         c(TypeConstructorAllowed) = false