Fix #480 in LambdaLift

Fix two errors, where the first masked the second:

1) Variables defined in a method are not free variables of that method. This was mispredicated before
and caused liftedOwner to be updated to the class enclosing the method, thereby preventing any method
that refers to a local parameter or symbol to be hoisted.

Once this was fixed, methods were hoisted too far out. Test case in #480a, which takes code from Definitions.
This was fixed by

2) markFree is updated to do an additional narrowLiftedOwner so that, if a free variable gets a proxy
in an enclosing class, any inner classes and methods are kept within that class.

Author: odersky

src/dotty/tools/dotc/transform/LambdaLift.scala

@@ -102,9 +102,10 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisTransform
 
     /** Mark symbol `sym` as being free in `enclosure`, unless `sym`
      *  is defined in `enclosure` or there is a class between `enclosure`s owner
-     *  and the owner of `sym`.
-     *  Return `true` if there is no class between `enclosure` and
-     *  the owner of sym.
+     *  and the owner of `sym`. Also, update lifted owner of `enclosure` so
+     *  that `enclosure` can access `sym`, or its proxy in an intermediate class.
+     *  Return the closest enclosing intermediate class between `enclosure` and
+     *  the owner of sym, or NoSymbol is none exists.
      *  pre: sym.owner.isTerm, (enclosure.isMethod || enclosure.isClass)
      *
      *  The idea of `markFree` is illustrated with an example:
@@ -130,22 +131,28 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisTransform
      *    }
      *  }
      */
-    private def markFree(sym: Symbol, enclosure: Symbol)(implicit ctx: Context): Boolean = try {
+    private def markFree(sym: Symbol, enclosure: Symbol)(implicit ctx: Context): Symbol = try {
       if (!enclosure.exists) throw new NoPath
-      ctx.log(i"mark free: ${sym.showLocated} with owner ${sym.maybeOwner} marked free in $enclosure")
-      narrowLiftedOwner(enclosure, sym.enclosingClass)
-      (enclosure == sym.enclosure) || {
+      if (enclosure == sym.enclosure) NoSymbol
+      else {
+        ctx.log(i"mark free: ${sym.showLocated} with owner ${sym.maybeOwner} marked free in $enclosure")
         ctx.debuglog(i"$enclosure != ${sym.enclosure}")
-        if (enclosure.is(PackageClass) ||
-          !markFree(sym, enclosure.skipConstructor.enclosure)) false
+        val intermediate = 
+          if (enclosure.is(PackageClass)) enclosure
+          else markFree(sym, enclosure.skipConstructor.enclosure)
+        if (intermediate.exists) {
+          narrowLiftedOwner(enclosure, intermediate)
+          intermediate
+        }
         else {
+          narrowLiftedOwner(enclosure, sym.enclosingClass)
           val ss = symSet(free, enclosure)
           if (!ss(sym)) {
             ss += sym
             changedFreeVars = true
             ctx.debuglog(i"$sym is free in $enclosure")
           }
-          !enclosure.isClass
+          if (enclosure.isClass) enclosure else NoSymbol
         }
       }
     } catch {