Hide liftedOwner

Author: odersky

compiler/src/dotty/tools/dotc/transform/DependencyCollector.scala

@@ -27,8 +27,8 @@ import annotation.constructorOnly
 abstract class Dependencies(@constructorOnly rootContext: Context):
   import ast.tpd._
 
-  def enclosure(using Context): Symbol
-  def isExpr(sym: Symbol)(using Context): Boolean
+  protected def enclosure(using Context): Symbol
+  protected def isExpr(sym: Symbol)(using Context): Boolean
 
   type SymSet = TreeSet[Symbol]
 
@@ -45,7 +45,7 @@ abstract class Dependencies(@constructorOnly rootContext: Context):
    *  Note: During tree transform (which runs at phase LambdaLift + 1), liftedOwner
    *  is also used to decide whether a method had a term owner before.
    */
-  val liftedOwner = new LinkedHashMap[Symbol, Symbol]
+  private val depOwner = new LinkedHashMap[Symbol, Symbol]
 
   /** A flag to indicate whether new free variables have been found */
   private var changedFreeVars: Boolean = _
@@ -63,6 +63,8 @@ abstract class Dependencies(@constructorOnly rootContext: Context):
 
   def tracked: Iterable[Symbol] = free.keys
 
+  def dependentOwner: collection.Map[Symbol, Symbol] = depOwner
+
   /** A symbol is local if it is owned by a term or a local trait,
    *  or if it is a constructor of a local symbol.
    *  Note: we count members of local traits as local since their free variables
@@ -80,12 +82,12 @@ abstract class Dependencies(@constructorOnly rootContext: Context):
    */
   private def narrowLiftedOwner(sym: Symbol, owner: Symbol)(using Context): Unit =
     if sym.maybeOwner.isTerm
-        && owner.isProperlyContainedIn(liftedOwner(sym))
+        && owner.isProperlyContainedIn(depOwner(sym))
         && owner != sym
     then
       report.log(i"narrow lifted $sym to $owner")
       changedLiftedOwner = true
-      liftedOwner(sym) = owner
+      depOwner(sym) = owner
 
   private class NoPath extends Exception
 
@@ -202,7 +204,7 @@ abstract class Dependencies(@constructorOnly rootContext: Context):
         narrowTo(tree.symbol.asClass)
       case tree: DefDef =>
         if sym.owner.isTerm then
-          liftedOwner(sym) = sym.enclosingPackageClass
+          depOwner(sym) = sym.enclosingPackageClass
             // this will make methods in supercall constructors of top-level classes owned
             // by the enclosing package, which means they will be static.
             // On the other hand, all other methods will be indirectly owned by their
@@ -215,7 +217,7 @@ abstract class Dependencies(@constructorOnly rootContext: Context):
             // the free variables of the class.
             symSet(called, sym) += sym.owner
       case tree: TypeDef =>
-        if sym.owner.isTerm then liftedOwner(sym) = sym.topLevelClass.owner
+        if sym.owner.isTerm then depOwner(sym) = sym.topLevelClass.owner
       case _ =>
   end process
 
@@ -252,7 +254,7 @@ abstract class Dependencies(@constructorOnly rootContext: Context):
       do
         val normalizedCallee = callee.skipConstructor
         val calleeOwner = normalizedCallee.owner
-        if calleeOwner.isTerm then narrowLiftedOwner(caller, liftedOwner(normalizedCallee))
+        if calleeOwner.isTerm then narrowLiftedOwner(caller, depOwner(normalizedCallee))
         else
           assert(calleeOwner.is(Trait))
           // methods nested inside local trait methods cannot be lifted out

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

@@ -50,7 +50,6 @@ object LambdaLift {
             liftedDefs(tree.symbol.owner) = new mutable.ListBuffer
           case _ =>
     end deps
-    export deps.{liftedOwner}
 
     /** A map storing the free variable proxies of functions and classes.
      *  For every function and class, this is a map from the free variables
@@ -95,7 +94,7 @@ object LambdaLift {
     }
 
     private def liftLocals()(using Context): Unit = {
-      for ((local, lOwner) <- liftedOwner) {
+      for ((local, lOwner) <- deps.dependentOwner) {
         val (newOwner, maybeStatic) =
           if (lOwner is Package) {
             val encClass = local.enclosingClass
@@ -131,7 +130,7 @@ object LambdaLift {
           info = liftedInfo(local)).installAfter(thisPhase)
       }
       for (local <- deps.tracked)
-        if (!liftedOwner.contains(local))
+        if (!deps.dependentOwner.contains(local))
           local.copySymDenotation(info = liftedInfo(local)).installAfter(thisPhase)
     }
 
@@ -148,7 +147,8 @@ object LambdaLift {
       sym.enclosure == currentEnclosure
 
     private def proxy(sym: Symbol)(using Context): Symbol = {
-      def liftedEnclosure(sym: Symbol) = liftedOwner.getOrElse(sym, sym.enclosure)
+      def liftedEnclosure(sym: Symbol) =
+        deps.dependentOwner.getOrElse(sym, sym.enclosure)
       def searchIn(enclosure: Symbol): Symbol = {
         if (!enclosure.exists) {
           def enclosures(encl: Symbol): List[Symbol] =
@@ -228,7 +228,7 @@ object LambdaLift {
       EmptyTree
     }
 
-    def needsLifting(sym: Symbol): Boolean = liftedOwner contains sym
+    def needsLifting(sym: Symbol): Boolean = deps.dependentOwner.contains(sym)
   end Lifter
 }