Revert "SI-2897, SI-6231 method-local traits capturing variables"

This reverts commit 9b4da70562ef49c02d3227906a062113056d8424.

Author: adriaanm

src/compiler/scala/tools/nsc/transform/LambdaLift.scala

@@ -309,22 +309,17 @@ abstract class LambdaLift extends InfoTransform {
       afterOwnPhase {
         for ((owner, freeValues) <- free.toList) {
           val newFlags = SYNTHETIC | (
-            if (owner.isTrait) PARAMACCESSOR | TRANS_FLAG // will need an impl in subclass that mixes in the trait
-            else if (owner.isClass) PARAMACCESSOR | PrivateLocal
+            if (owner.isClass) PARAMACCESSOR | PrivateLocal
             else PARAM)
 
           proxies(owner) =
             for (fv <- freeValues.toList) yield {
               val proxyName = proxyNames.getOrElse(fv, fv.name)
-              println(s"new proxy ${proxyName} in ${owner.fullLocationString}")
-              val proxy =
-                if (owner.isTrait) owner.newMethod(proxyName.toTermName, owner.pos, newFlags.toLong) setInfo MethodType(Nil, fv.info)
-                else owner.newValue(proxyName.toTermName, owner.pos, newFlags.toLong) setInfo fv.info
+              debuglog(s"new proxy ${proxyName} in ${owner.fullLocationString}")
+              val proxy = owner.newValue(proxyName.toTermName, owner.pos, newFlags.toLong) setInfo fv.info
               if (owner.isClass) owner.info.decls enter proxy
               proxy
             }
-
-          proxies(owner.toInterface) = proxies(owner)
         }
       }
     }
@@ -373,11 +368,7 @@ abstract class LambdaLift extends InfoTransform {
 
       qual match {
         case EmptyTree => EmptyTree
-        case qual      =>
-          val sel = Select(qual, sym) setType sym.tpe
-
-          if (sym.isParamAccessor && (sym hasFlag TRANS_FLAG)) Apply(sel, Nil) setType sym.tpe.finalResultType
-          else sel
+        case qual      => Select(qual, sym) setType sym.tpe
       }
     }
 
@@ -388,43 +379,19 @@ abstract class LambdaLift extends InfoTransform {
 
     def freeArgsOrNil(sym: Symbol) = free.getOrElse(sym, Nil).toList
 
-    private def transformApply(tree: Apply) = {
-      val Apply(fn, args) = tree
-      val sym = tree.symbol
-      val pos = tree.pos
+    private def freeArgs(sym: Symbol): List[Symbol] =
+      freeArgsOrNil(sym)
 
-      if (sym.isMethod && sym.isConstructor && sym.owner.isTrait) {
-        // TODO: add types / symbols
-        val inits = freeParams(currentOwner).map { ctorParam =>
-           ugh, since we just mutate trees without first transforming infos, we can't get to the symbol
-          val proxyFieldSym = currentClass.info.decl(ctorParam.name)
-          val proxyField = gen.mkAttributedSelect(gen.mkAttributedThis(currentClass), proxyFieldSym)
-
-          atPos(currentOwner.pos)(Assign(proxyField, Ident(ctorParam))) setType BoxedUnitTpe
-        }
-        Block(inits, tree) setType tree.tpe setPos tree.pos
-      } else {
-        val newArgs =
-          freeArgsOrNil(sym) match {
-            case Nil => args
-            case fvs => addFree (sym, free = fvs map (fv => atPos (pos) (proxyRef (fv) ) ), original = args)
-          }
-
-        treeCopy.Apply(tree, fn, newArgs)
+    private def addFreeArgs(pos: Position, sym: Symbol, args: List[Tree]) =
+      freeArgs(sym) match {
+        case Nil => args
+        case fvs => addFree(sym, free = fvs map (fv => atPos(pos)(proxyRef(fv))), original = args)
       }
-    }
 
     def proxiesOrNil(sym: Symbol) = proxies.getOrElse(sym, Nil)
 
-    private def mixinProxies(mixin: Symbol): List[Symbol] = {
-      proxiesOrNil(mixin) map (mixedin => mixedin.cloneSymbol setFlag TRANS_FLAG)
-    }
-
     private def freeParams(sym: Symbol): List[Symbol] =
-      if (sym.isMethod && sym.isConstructor && sym.owner.isTrait) Nil
-      else if (sym.isClass && !sym.isTrait)
-        proxiesOrNil(sym) ++ (sym.mixinClasses flatMap mixinProxies)
-      else proxiesOrNil(sym)
+      proxiesOrNil(sym)
 
     private def addFreeParams(tree: Tree, sym: Symbol): Tree =
       tree match {
@@ -440,31 +407,12 @@ abstract class LambdaLift extends InfoTransform {
             copyDefDef(tree)(vparamss = List(addFree(sym, free = paramDefs, original = vparams)))
           }
 
-        case ClassDef(_, _, _, _) if !sym.isTrait =>
+        case ClassDef(_, _, _, _) =>
           val freeParamDefs = freeParams(sym) map (p => ValDef(p) setPos tree.pos setType NoType)
 
           if (freeParamDefs isEmpty) tree
           else deriveClassDef(tree)(impl => deriveTemplate(impl)(_ ::: freeParamDefs))
 
-        case ClassDef(_, _, _, _) =>
-          // SI-2897, SI-6231
-          // Disabled attempt to to add getters to freeParams
-          // this does not work yet. Problem is that local symbols need local names
-          // and references to local symbols need to be transformed into
-          // method calls to setters.
-          // def paramGetter(param: Symbol): Tree = {
-          //   val getter = param.newGetter setFlag TRANS_FLAG resetFlag PARAMACCESSOR // mark because we have to add them to interface
-          //   sym.info.decls.enter(getter)
-          //   val rhs = Select(gen.mkAttributedThis(sym), param) setType param.tpe
-          //   DefDef(getter, rhs) setPos tree.pos setType NoType
-          // }
-          val ps = freeParams(sym)
-          if (ps isEmpty) tree
-          else {
-            val freeParams = ps map (p => DefDef(p, EmptyTree) setPos tree.pos setType NoType)
-            deriveClassDef(tree)(impl => deriveTemplate(impl)(_ ::: freeParams))
-          }
-
         case _ => tree
       }
 
@@ -556,7 +504,8 @@ abstract class LambdaLift extends InfoTransform {
         case Return(expr) =>
           assert(sym == currentMethod, sym)
           tree
-        case tree: Apply => transformApply(tree)
+        case Apply(fn, args) =>
+          treeCopy.Apply(tree, fn, addFreeArgs(tree.pos, sym, args))
         case Assign(Apply(TypeApply(sel @ Select(qual, _), _), List()), rhs) =>
           // eliminate casts introduced by selecting a captured variable field
           // on the lhs of an assignment.