refactor

Author: adriaanm

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

@@ -308,11 +308,14 @@ abstract class LambdaLift extends InfoTransform {
 
       afterOwnPhase {
         for ((owner, freeValues) <- free.toList) {
-          val newFlags = SYNTHETIC | ( if (owner.isClass) PARAMACCESSOR | PrivateLocal else PARAM )
-          debuglog("free var proxy: %s, %s".format(owner.fullLocationString, freeValues.toList.mkString(", ")))
+          val newFlags = SYNTHETIC | (
+            if (owner.isClass) PARAMACCESSOR | PrivateLocal
+            else PARAM)
+
           proxies(owner) =
             for (fv <- freeValues.toList) yield {
               val proxyName = proxyNames.getOrElse(fv, fv.name)
+              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
@@ -342,73 +345,77 @@ abstract class LambdaLift extends InfoTransform {
 
     private def memberRef(sym: Symbol): Tree = {
       val clazz = sym.owner.enclClass
-      //Console.println("memberRef from "+currentClass+" to "+sym+" in "+clazz)
-      def prematureSelfReference() {
+      // println(s"memberRef from $currentClass to $sym in $clazz (currentClass=$currentClass)")
+      def prematureSelfReference(): Tree = {
         val what =
           if (clazz.isStaticOwner) clazz.fullLocationString
           else s"the unconstructed `this` of ${clazz.fullLocationString}"
         val msg = s"Implementation restriction: access of ${sym.fullLocationString} from ${currentClass.fullLocationString}, would require illegal premature access to $what"
         reporter.error(curTree.pos, msg)
+        EmptyTree
       }
-      val qual =
+      def qual =
         if (clazz == currentClass) gen.mkAttributedThis(clazz)
         else {
           sym resetFlag (LOCAL | PRIVATE)
-          if (isUnderConstruction(clazz)) {
-            prematureSelfReference()
-            EmptyTree
-          }
+          if (isUnderConstruction(clazz)) prematureSelfReference()
           else if (clazz.isStaticOwner) gen.mkAttributedQualifier(clazz.thisType)
-          else {
-            outerValue match {
-              case EmptyTree => prematureSelfReference(); return EmptyTree
-              case o         => outerPath(o, currentClass.outerClass, clazz)
-            }
+          else outerValue match {
+            case EmptyTree => prematureSelfReference()
+            case o         => outerPath(o, currentClass.outerClass, clazz)
           }
         }
-      Select(qual, sym) setType sym.tpe
+
+      qual match {
+        case EmptyTree => EmptyTree
+        case qual      => Select(qual, sym) setType sym.tpe
+      }
     }
 
     private def proxyRef(sym: Symbol) = {
       val psym = proxy(sym)
       if (psym.isLocalToBlock) gen.mkAttributedIdent(psym) else memberRef(psym)
     }
 
-    private def addFreeArgs(pos: Position, sym: Symbol, args: List[Tree]) = {
-      free get sym match {
-        case Some(fvs) => addFree(sym, free = fvs.toList map (fv => atPos(pos)(proxyRef(fv))), original = args)
-        case _         => args
+    def freeArgsOrNil(sym: Symbol) = free.getOrElse(sym, Nil).toList
+
+    private def freeArgs(sym: Symbol): List[Symbol] =
+      freeArgsOrNil(sym)
+
+    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)
       }
-    }
 
-    private def addFreeParams(tree: Tree, sym: Symbol): Tree = proxies.get(sym) match {
-      case Some(ps) =>
-        val freeParams = ps map (p => ValDef(p) setPos tree.pos setType NoType)
-        tree match {
-          case DefDef(_, _, _, vparams :: _, _, _) =>
-            val addParams = cloneSymbols(ps).map(_.setFlag(PARAM))
-            sym.updateInfo(
-              lifted(MethodType(addFree(sym, free = addParams, original = sym.info.params), sym.info.resultType)))
+    def proxiesOrNil(sym: Symbol) = proxies.getOrElse(sym, Nil)
+
+    private def freeParams(sym: Symbol): List[Symbol] =
+      proxiesOrNil(sym)
+
+    private def addFreeParams(tree: Tree, sym: Symbol): Tree =
+      tree match {
+        case DefDef(_, _, _, vparams :: _, _, _) =>
+          val ps = freeParams(sym)
+
+          if (ps isEmpty) tree
+          else {
+            val paramSyms = cloneSymbols(ps).map(_.setFlag(PARAM))
+            val paramDefs = ps map (p => ValDef(p) setPos tree.pos setType NoType)
+
+            sym.updateInfo(lifted(MethodType(addFree(sym, free = paramSyms, original = sym.info.params), sym.info.resultType)))
+            copyDefDef(tree)(vparamss = List(addFree(sym, free = paramDefs, original = vparams)))
+          }
+
+        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 _ => tree
+      }
 
-            copyDefDef(tree)(vparamss = List(addFree(sym, free = freeParams, original = vparams)))
-          case ClassDef(_, _, _, _) =>
-            // 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 newDefs = if (sym.isTrait) freeParams ::: (ps map paramGetter) else freeParams
-            deriveClassDef(tree)(impl => deriveTemplate(impl)(_ ::: freeParams))
-        }
-      case None =>
-        tree
-    }
 
 /*  SI-6231: Something like this will be necessary to eliminate the implementation
  *  restriction from paramGetter above: