1 files changed, 74 insertions, 36 deletions
diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
index 332acf4a26..0786ceb7c2 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeGen.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
@@ -145,6 +145,7 @@ abstract class TreeGen extends scala.reflect.internal.TreeGen with TreeDSL {
   override def mkCast(tree: Tree, pt: Type): Tree = {
     debuglog("casting " + tree + ":" + tree.tpe + " to " + pt + " at phase: " + phase)
     assert(!tree.tpe.isInstanceOf[MethodType], tree)
+    assert(!pt.isInstanceOf[MethodType], tree)
     assert(pt eq pt.normalize, tree +" : "+ debugString(pt) +" ~>"+ debugString(pt.normalize))
     atPos(tree.pos) {
       mkAsInstanceOf(tree, pt, any = !phase.next.erasedTypes, wrapInApply = isAtPhaseAfter(currentRun.uncurryPhase))
@@ -242,11 +243,14 @@ abstract class TreeGen extends scala.reflect.internal.TreeGen with TreeDSL {
   def mkSynchronizedCheck(clazz: Symbol, cond: Tree, syncBody: List[Tree], stats: List[Tree]): Tree =
     mkSynchronizedCheck(mkAttributedThis(clazz), cond, syncBody, stats)
 
-  def mkSynchronizedCheck(attrThis: Tree, cond: Tree, syncBody: List[Tree], stats: List[Tree]): Tree =
-    Block(mkSynchronized(
-      attrThis,
-      If(cond, Block(syncBody: _*), EmptyTree)) ::
-      stats: _*)
+  def mkSynchronizedCheck(attrThis: Tree, cond: Tree, syncBody: List[Tree], stats: List[Tree]): Tree = {
+    def blockOrStat(stats: List[Tree]): Tree = stats match {
+      case head :: Nil => head
+      case _ => Block(stats : _*)
+    }
+    val sync = mkSynchronized(attrThis, If(cond, blockOrStat(syncBody), EmptyTree))
+    blockOrStat(sync :: stats)
+  }
 
   /** Creates a tree representing new Object { stats }.
    *  To make sure an anonymous subclass of Object is created,
@@ -257,43 +261,77 @@ abstract class TreeGen extends scala.reflect.internal.TreeGen with TreeDSL {
     mkNew(Nil, noSelfType, stats1, NoPosition, NoPosition)
   }
 
-  /**
-   * Create a method based on a Function
-   *
-   * Used both to under `-Ydelambdafy:method` create a lifted function and
-   * under `-Ydelambdafy:inline` to create the apply method on the anonymous
-   * class.
-   *
-   * It creates a method definition with value params cloned from the
-   * original lambda. Then it calls a supplied function to create
-   * the body and types the result. Finally
-   * everything is wrapped up in a DefDef
-   *
-   * @param owner The owner for the new method
-   * @param name name for the new method
-   * @param additionalFlags flags to be put on the method in addition to FINAL
-   */
-  def mkMethodFromFunction(localTyper: analyzer.Typer)
-                          (fun: Function, owner: Symbol, name: TermName, additionalFlags: FlagSet = NoFlags) = {
-    val funParams = fun.vparams map (_.symbol)
-    val formals :+ restpe = fun.tpe.typeArgs
 
+  // Construct a method to implement `fun`'s single abstract method (`apply`, when `fun.tpe` is a built-in function type)
+  def mkMethodFromFunction(localTyper: analyzer.Typer)(owner: Symbol, fun: Function) = {
+    // TODO: treat FunctionN like any other SAM -- drop `&& !isFunctionType(fun.tpe)`
+    val sam = if (!isFunctionType(fun.tpe)) samOf(fun.tpe) else NoSymbol
+    if (!sam.exists) mkMethodForFunctionBody(localTyper)(owner, fun, nme.apply)()
+    else {
+      val samMethType = fun.tpe memberInfo sam
+      mkMethodForFunctionBody(localTyper)(owner, fun, sam.name.toTermName)(methParamProtos = samMethType.params, resTp = samMethType.resultType)
+    }
+  }
+
+  // used to create the lifted method that holds a function's body
+  def mkLiftedFunctionBodyMethod(localTyper: analyzer.Typer)(owner: Symbol, fun: Function) =
+    mkMethodForFunctionBody(localTyper)(owner, fun, nme.ANON_FUN_NAME)(additionalFlags = ARTIFACT)
+
+
+  /**
+    * Lift a Function's body to a method. For use during Uncurry, where Function nodes have type FunctionN[T1, ..., Tn, R]
+    *
+    * It creates a method definition with value params derived from the original lambda
+    * or `methParamProtos` (used to create the correct override for sam methods).
+    *
+    * Replace the `fun.vparams` symbols by the newly created method params,
+    * changes owner of `fun.body` from `fun.symbol` to resulting method's symbol.
+    *
+    * @param owner The owner for the new method
+    * @param fun  the function to take the body from
+    * @param name name for the new method
+    * @param additionalFlags flags to be put on the method in addition to FINAL
+    */
+  private def mkMethodForFunctionBody(localTyper: analyzer.Typer)
+                                     (owner: Symbol, fun: Function, name: TermName)
+                                     (methParamProtos: List[Symbol] = fun.vparams.map(_.symbol),
+                                      resTp: Type = functionResultType(fun.tpe),
+                                      additionalFlags: FlagSet = NoFlags): DefDef = {
     val methSym = owner.newMethod(name, fun.pos, FINAL | additionalFlags)
+    // for sams, methParamProtos is the parameter symbols for the sam's method, so that we generate the correct override (based on parmeter types)
+    val methParamSyms = methParamProtos.map { param => methSym.newSyntheticValueParam(param.tpe, param.name.toTermName) }
+    methSym setInfo MethodType(methParamSyms, resTp)
 
-    val paramSyms = map2(formals, fun.vparams) {
-      (tp, vparam) => methSym.newSyntheticValueParam(tp, vparam.name)
-    }
+    // we must rewire reference to the function's param symbols -- and not methParamProtos -- to methParamSyms
+    val useMethodParams = new TreeSymSubstituter(fun.vparams.map(_.symbol), methParamSyms)
+    // we're now owned by the method that holds the body, and not the function
+    val moveToMethod = new ChangeOwnerTraverser(fun.symbol, methSym)
+
+    newDefDef(methSym, moveToMethod(useMethodParams(fun.body)))(tpt = TypeTree(resTp))
+  }
 
-    methSym setInfo MethodType(paramSyms, restpe.deconst)
+  // TODO: the rewrite to AbstractFunction is superfluous once we compile FunctionN to a SAM type (aka functional interface)
+  def functionClassType(fun: Function): Type =
+    if (isFunctionType(fun.tpe)) abstractFunctionType(fun.vparams.map(_.symbol.tpe), fun.body.tpe.deconst)
+    else fun.tpe
 
-    fun.body.substituteSymbols(funParams, paramSyms)
-    fun.body changeOwner (fun.symbol -> methSym)
+  def expandFunction(localTyper: analyzer.Typer)(fun: Function, inConstructorFlag: Long): Tree = {
+    val parents = addSerializable(functionClassType(fun))
+    val anonClass = fun.symbol.owner newAnonymousFunctionClass(fun.pos, inConstructorFlag) addAnnotation SerialVersionUIDAnnotation
 
-    val methDef = DefDef(methSym, fun.body)
+    // The original owner is used in the backend for the EnclosingMethod attribute. If fun is
+    // nested in a value-class method, its owner was already changed to the extension method.
+    // Saving the original owner allows getting the source structure from the class symbol.
+    defineOriginalOwner(anonClass, fun.symbol.originalOwner)
+    anonClass setInfo ClassInfoType(parents, newScope, anonClass)
 
-    // Have to repack the type to avoid mismatches when existentials
-    // appear in the result - see SI-4869.
-    methDef.tpt setType localTyper.packedType(fun.body, methSym).deconst
-    methDef
+    val samDef = mkMethodFromFunction(localTyper)(anonClass, fun)
+    anonClass.info.decls enter samDef.symbol
+
+    localTyper.typedPos(fun.pos) {
+      Block(
+        ClassDef(anonClass, NoMods, ListOfNil, List(samDef), fun.pos),
+        Typed(New(anonClass.tpe), TypeTree(fun.tpe)))
+    }
   }
 }