Refine outer cache

Author: liufengyun

compiler/src/dotty/tools/dotc/transform/init/Checker.scala

@@ -23,7 +23,7 @@ class Checker extends MiniPhase {
   val phaseName = "initChecker"
 
   // cache of class summary
-  private val baseEnv = Env(null, mutable.Map.empty)
+  private val baseEnv = Env(null)
 
   override val runsAfter = Set(Pickler.name)
 

compiler/src/dotty/tools/dotc/transform/init/Env.scala

@@ -20,7 +20,7 @@ import Effects._, Potentials._, Summary._
 
 implicit def theCtx(implicit env: Env): Context = env.ctx
 
-case class Env(ctx: Context, summaryCache: mutable.Map[ClassSymbol, ClassSummary]) {
+case class Env(ctx: Context) {
   private implicit def self: Env = this
 
   // Methods that should be ignored in the checking
@@ -46,12 +46,25 @@ case class Env(ctx: Context, summaryCache: mutable.Map[ClassSymbol, ClassSummary
     sym.isPrimitiveValueClass || sym == defn.StringClass
   }
 
-  /** Summary of a method or field */
+  /** Summary of a class */
+  private val summaryCache = mutable.Map.empty[ClassSymbol, ClassSummary]
   def summaryOf(cls: ClassSymbol): ClassSummary =
     if (summaryCache.contains(cls)) summaryCache(cls)
     else trace("summary for " + cls.show, init, s => s.asInstanceOf[ClassSummary].show) {
       val summary = Summarization.classSummary(cls)
       summaryCache(cls) = summary
       summary
     }
+
+  /** Cache for outer this */
+  private case class OuterKey(warm: Warm, cls: ClassSymbol)
+  private val outerCache: mutable.Map[OuterKey, Potentials] = mutable.Map.empty
+  def resolveOuter(warm: Warm, cls: ClassSymbol)(implicit env: Env): Potentials =
+    val key = OuterKey(warm, cls)
+    if (outerCache.contains(key)) outerCache(key)
+    else {
+      val pots = Potentials.resolveOuter(warm.classSymbol, warm.outer.toPots, cls)
+      outerCache(key) = pots
+      pots
+    }
 }

compiler/src/dotty/tools/dotc/transform/init/Potentials.scala

@@ -70,7 +70,6 @@ object Potentials {
     def effectsOf(sym: Symbol)(implicit env: Env): Effects = trace("effects of " + sym.show, init, r => Effects.show(r.asInstanceOf)) {
       val cls = sym.owner.asClass
       val effs = env.summaryOf(cls).effectsOf(sym)
-      val outer = Outer(this, cls)(this.source)
       Effects.asSeenFrom(effs, this)
     }
 
@@ -81,22 +80,14 @@ object Potentials {
     def potentialsOf(sym: Symbol)(implicit env: Env): Potentials = trace("potentials of " + sym.show, init, r => Potentials.show(r.asInstanceOf)) {
       val cls = sym.owner.asClass
       val pots = env.summaryOf(cls).potentialsOf(sym)
-      val outer = Outer(this, cls)(this.source)
       Potentials.asSeenFrom(pots, this)
     }
 
-    private val outerCache: mutable.Map[ClassSymbol, Potentials] = mutable.Map.empty
     def resolveOuter(cls: ClassSymbol)(implicit env: Env): Potentials =
-      if (outerCache.contains(cls)) outerCache(cls)
-      else if (cls `eq` classSymbol) outer.toPots
-      else {
-        val pots = Potentials.resolveOuter(classSymbol, outer.toPots, cls)
-        outerCache(cls) = pots
-        pots
-      }
+      env.resolveOuter(this, cls)
   }
 
-  private def resolveOuter(cur: ClassSymbol, outerPots: Potentials, cls: ClassSymbol)(implicit env: Env): Potentials =
+  def resolveOuter(cur: ClassSymbol, outerPots: Potentials, cls: ClassSymbol)(implicit env: Env): Potentials =
     if (cur == cls) outerPots
     else {
       val bottomClsSummary = env.summaryOf(cur)