retronym
diff --git a/‎src/compiler/scala/tools/nsc/transform/Delambdafy.scala
Lines changed: 31 additions & 11 deletions b/‎src/compiler/scala/tools/nsc/transform/Delambdafy.scala
Lines changed: 31 additions & 11 deletions
@@ -61,14 +61,16 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre
 
     private def mkLambdaMetaFactoryCall(fun: Function, target: Symbol, functionalInterface: Symbol, samUserDefined: Symbol, isSpecialized: Boolean): Tree = {
       val pos = fun.pos
+      val hasSelfParam = target.firstParam.isSynthetic && target.firstParam.name == nme.SELF
+
       val allCapturedArgRefs = {
         // find which variables are free in the lambda because those are captures that need to be
         // passed into the constructor of the anonymous function class
         val captureArgs = FreeVarTraverser.freeVarsOf(fun).iterator.map(capture =>
           gen.mkAttributedRef(capture) setPos pos
         ).toList
 
-        if (target hasFlag STATIC) captureArgs  // no `this` reference needed
+        if (!hasSelfParam) captureArgs  // no `this` reference needed
         else (gen.mkAttributedThis(fun.symbol.enclClass) setPos pos) :: captureArgs
       }
 
@@ -90,7 +92,7 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre
       }
 
       // no need for adaptation when the implemented sam is of a specialized built-in function type
-      val lambdaTarget = if (isSpecialized) target else createBoxingBridgeMethodIfNeeded(fun, target, functionalInterface, sam)
+      val lambdaTarget = if (isSpecialized) target else createBoxingBridgeMethodIfNeeded(fun, target, hasSelfParam, functionalInterface, sam)
 
       // The backend needs to know the target of the lambda and the functional interface in order
       // to emit the invokedynamic instruction. We pass this information as tree attachment.
@@ -118,12 +120,12 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre
     }
 
     // determine which lambda target to use with java's LMF -- create a new one if scala-specific boxing is required
-    def createBoxingBridgeMethodIfNeeded(fun: Function, target: Symbol, functionalInterface: Symbol, sam: Symbol): Symbol = {
+    def createBoxingBridgeMethodIfNeeded(fun: Function, target: Symbol, hasSelfParam: Boolean, functionalInterface: Symbol, sam: Symbol): Symbol = {
       val oldClass = fun.symbol.enclClass
       val pos = fun.pos
 
       // At erasure, there won't be any captured arguments (they are added in constructors)
-      val functionParamTypes = exitingErasure(target.info.paramTypes)
+      val functionParamTypes = exitingErasure(target.info.paramTypes).drop(if (hasSelfParam) 1 else 0)
       val functionResultType = exitingErasure(target.info.resultType)
 
       val samParamTypes = exitingErasure(sam.info.paramTypes)
@@ -210,7 +212,8 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre
               adaptToType(unboxed, targetParamTp)
             }
 
-          gen.mkMethodCall(Select(gen.mkAttributedThis(oldClass), target), capturedArgRefs ::: functionArgRefs)
+          val selfArg = if (hasSelfParam) gen.mkAttributedThis(oldClass) :: Nil else Nil
+          gen.mkMethodCall(Select(gen.mkAttributedThis(oldClass), target), selfArg ::: capturedArgRefs ::: functionArgRefs)
         }
 
         val bridge = postErasure.newTransformer(unit).transform(DefDef(methSym, List(bridgeParams.map(ValDef(_))),
@@ -223,10 +226,8 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre
 
     private def transformFunction(originalFunction: Function): Tree = {
       val target = targetMethod(originalFunction)
-      target.makeNotPrivate(target.owner)
-
-      // must be done before calling createBoxingBridgeMethod and mkLambdaMetaFactoryCall
-      if (!(target hasFlag STATIC) && !methodReferencesThis(target)) target setFlag STATIC
+      assert(target.hasFlag(Flags.STATIC))
+      target.setFlag(notPRIVATE)
 
       val funSym = originalFunction.tpe.typeSymbolDirect
       // The functional interface that can be used to adapt the lambda target method `target` to the given function type.
@@ -252,11 +253,30 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre
     // here's the main entry point of the transform
     override def transform(tree: Tree): Tree = tree match {
       // the main thing we care about is lambdas
-      case fun: Function => super.transform(transformFunction(fun))
+      case fun: Function =>
+        super.transform(transformFunction(fun))
       case Template(_, _, _) =>
+        def pretransform(tree: Tree): Tree = tree match {
+          case dd: DefDef if dd.symbol.isDelambdafyTarget =>
+            if (!dd.symbol.hasFlag(Flags.STATIC) && methodReferencesThis(dd.symbol)) {
+                dd.symbol.setFlag(Flags.STATIC)
+                val selfParamSym = dd.symbol.newSyntheticValueParam(dd.symbol.owner.typeConstructor, nme.SELF)
+                dd.symbol.modifyInfo {
+                  case mt @ MethodType(params, res) => copyMethodType(mt, selfParamSym :: params, res)
+                }
+                val selfParam = ValDef(selfParamSym)
+                val rhs = dd.rhs.substituteThis(dd.symbol.owner, atPos(dd.symbol.pos)(gen.mkAttributedIdent(selfParamSym)))
+                val result = treeCopy.DefDef(dd, dd.mods, dd.name, dd.tparams, (selfParam :: dd.vparamss.head) :: Nil, dd.tpt, rhs)
+                result
+            } else {
+              dd.symbol setFlag STATIC
+              dd
+            }
+          case t => t
+        }
         try {
           // during this call boxingBridgeMethods will be populated from the Function case
-          val Template(parents, self, body) = super.transform(tree)
+          val Template(parents, self, body) = super.transform(deriveTemplate(tree)(_.mapConserve(pretransform)))
           Template(parents, self, body ++ boxingBridgeMethods)
         } finally boxingBridgeMethods.clear()
       case _ => super.transform(tree)