Code refactor of initialization check

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

@@ -0,0 +1,43 @@
+package dotty.tools.dotc
+package transform
+package init
+
+import core._
+import Contexts._
+import Types._
+import Symbols._
+import Decorators._
+
+import ast.Trees._
+import ast.tpd
+
+import reporting.trace
+import config.Printers.init
+
+import scala.collection.mutable
+
+import Effects._, Potentials._, Summary._
+
+class Cache {
+  /** Summary of a class */
+  private val summaryCache = mutable.Map.empty[ClassSymbol, ClassSummary]
+  def summaryOf(cls: ClassSymbol)(using Env): 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)(using 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/Checker.scala

@@ -24,7 +24,7 @@ class Checker extends MiniPhase {
   val phaseName = "initChecker"
 
   // cache of class summary
-  private val baseEnv = Env(null)
+  private val cache = new Cache
 
   override val runsAfter = Set(Pickler.name)
 
@@ -54,7 +54,7 @@ class Checker extends MiniPhase {
         fieldsInited = mutable.Set.empty,
         parentsInited = mutable.Set.empty,
         safePromoted = mutable.Set.empty,
-        env = baseEnv.withCtx(ctx.withOwner(cls))
+        env = Env(ctx.withOwner(cls), cache)
       )
 
       Checking.checkClassBody(tree)

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

@@ -8,19 +8,11 @@ import Types._
 import Symbols._
 import Decorators._
 
-import ast.Trees._
-import ast.tpd
-
-import reporting.trace
-import config.Printers.init
-
-import scala.collection.mutable
-
 import Effects._, Potentials._, Summary._
 
 given theCtx(using Env): Context = summon[Env].ctx
 
-case class Env(ctx: Context) {
+case class Env(ctx: Context, cache: Cache) {
   private implicit def self: Env = this
 
   /** Can the method call be ignored? */
@@ -46,25 +38,7 @@ case class Env(ctx: Context) {
     sym.isPrimitiveValueClass || sym == defn.StringClass
   }
 
-  /** 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
-    }
+  def summaryOf(cls: ClassSymbol): ClassSummary = cache.summaryOf(cls)
 
-  /** 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
-    }
+  def resolveOuter(warm: Warm, cls: ClassSymbol): Potentials = cache.resolveOuter(warm, cls)
 }