Improve documentation and minimze test

Documentation around markFree and narrowLiftedOwner was added.
i480 was minimzed and dependencies on dotc were removed.

Author: odersky

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

@@ -90,6 +90,9 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisTransform
       free.getOrElse(sym, Nil).toList.map(pm)
     }
 
+    /** Set `liftedOwner(sym)` to `owner` if `owner` is more deeply nested
+     *  than the previous value of `liftedowner(sym)`.
+     */
     def narrowLiftedOwner(sym: Symbol, owner: Symbol)(implicit ctx: Context) = {
       if (sym.owner.isTerm &&
         owner.isProperlyContainedIn(liftedOwner(sym)) &&
@@ -100,12 +103,22 @@ 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`. Also, update lifted owner of `enclosure` so
+    /** Mark symbol `sym` as being free in `enclosure`, unless `sym` is defined
+     *  in `enclosure` or there is an intermediate class properly containing `enclosure`
+     *  in which `sym` is also free. Also, update `liftedOwner` of `enclosure` so
      *  that `enclosure` can access `sym`, or its proxy in an intermediate class.
+     *  This means: 
+     *  
+     *    1. If there is an intermediate class in which `sym` is free, `enclosure`
+     *       must be contained in that class (in order to access the `sym proxy stored 
+     *       in the class).
+     *       
+     *    2. If there is no intermediate class, `enclosure` must be contained
+     *       in the class enclosing `sym`.
+     *       
      *  Return the closest enclosing intermediate class between `enclosure` and
-     *  the owner of sym, or NoSymbol is none exists.
+     *  the owner of sym, or NoSymbol if none exists.
+     *  
      *  pre: sym.owner.isTerm, (enclosure.isMethod || enclosure.isClass)
      *
      *  The idea of `markFree` is illustrated with an example:
@@ -139,7 +152,9 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisTransform
         ctx.debuglog(i"$enclosure != ${sym.enclosure}")
         val intermediate = 
           if (enclosure.is(PackageClass)) enclosure
-          else markFree(sym, enclosure.skipConstructor.enclosure)
+          else markFree(sym, enclosure.skipConstructor.enclosure) 
+            // `enclosure` might be a constructor, in which case we want the enclosure 
+            // of the enclosing class, so skipConstructor is needed here.
         if (intermediate.exists) {
           narrowLiftedOwner(enclosure, intermediate)
           intermediate

tests/pos/i480a.scala

@@ -1,62 +1,15 @@
-package dotty.tools
-package dotc
-package core
-
-import Types._, Contexts._, Symbols._, Denotations._, SymDenotations._, StdNames._, Names._
-import Flags._, Scopes._, Decorators._, NameOps._, util.Positions._
-import pickling.UnPickler.ensureConstructor
-import scala.annotation.{ switch, meta }
-import scala.collection.{ mutable, immutable }
-import PartialFunction._
-import collection.mutable
-import scala.reflect.api.{ Universe => ApiUniverse }
-
-object Definitions {
-  val MaxFunctionArity, MaxTupleArity = 22
-}
+package test
 
 /** A class defining symbols and types of standard definitions */
 class Definitions {
 
-  /** The HigherKinded trait corresponding to symbols `boundSyms` (which are assumed
-   *  to be the type parameters of a higher-kided type). This is a class symbol that
-   *  would be generated by the following schema.
-   *
-   *      class LambdaXYZ extends Object with P1 with ... with Pn {
-   *        type v_1 $hk$Arg0; ...; type v_N $hk$ArgN;
-   *        type Apply
-   *      }
-   *
-   *  Here:
-   *
-   *   - v_i are the variances of the bound symbols (i.e. +, -, or empty).
-   *   - XYZ is a string of length N with one letter for each variant of a bound symbol,
-   *     using `P` (positive variance), `N` (negative variance), `I` (invariant).
-   *   - for each positive or negative variance v_i there is a parent trait Pj which
-   *     is the same as LambdaXYZ except that it has `I` in i-th position.
-   */
-  def lambdaTrait(vcs: List[Int]): ClassSymbol = {
+  trait LazyType { def complete(): Unit }
 
+  def f(vcs: List[Int]): Unit = {
     val completer = new LazyType  {
-      def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
-//        val cls = denot.asClass.classSymbol
-//        val paramDecls = newScope
-//        for (i <- 0 until vcs.length)
-//          newTypeParam(cls, tpnme.lambdaArgName(i), varianceFlags(vcs(i)), paramDecls)
-//        newTypeField(cls, tpnme.Apply, Covariant, paramDecls)
-        val parentTraitRefs =
-          for (i <- 0 until vcs.length if vcs(i) != 0)
-          yield lambdaTrait(vcs.updated(i, 0)).typeRef
-//        denot.info = ClassInfo(
-//            ScalaPackageClass.thisType, cls, ObjectClass.typeRef :: parentTraitRefs.toList, paramDecls)
-      }
+      def complete(): Unit =
+        for (i <- 0 until vcs.length if vcs(i) != 0)
+          f(vcs.updated(i, 0))
     }
-
-//    val traitName = tpnme.lambdaTraitName(vcs)
-
-//    def createTrait = ???
-
-    ???
-
   }
 }