Add object TreeCache to Contextual.

Author: lidaisy

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

@@ -378,7 +378,7 @@ object Semantic:
 // ----- Checker State -----------------------------------
 
   /** The state that threads through the interpreter */
-  type Contextual[T] = (Context, Trace, Promoted, Cache.Data, Reporter) ?=> T
+  type Contextual[T] = (Context, Trace, Promoted, Cache.Data, Reporter, TreeCache.CacheData) ?=> T
 
 // ----- Error Handling -----------------------------------
 
@@ -443,23 +443,29 @@ object Semantic:
 
   inline def reporter(using r: Reporter): Reporter = r
 
-// ----- Operations on trees -----------------------------
-  val valOrDefDefRhs = mutable.Map[ValOrDefDef, Tree]()
-
-  extension (tree: ValOrDefDef)
-    def getRhs(using Context): Tree =
-      def getTree: Tree =
-        val errorCount = ctx.reporter.errorCount
-        val rhs = tree.rhs
-
-        if (ctx.reporter.errorCount > errorCount)
-          report.warning("[Internal error] Ignoring analyses of " + tree.name + " due to error in reading TASTy. ")
-          EmptyTree
-        else
-          rhs
-
-      valOrDefDefRhs.getOrElseUpdate(tree, getTree)
-
+// ----- Cache for Trees -----------------------------
+
+  object TreeCache:
+    class CacheData:
+      private val emptyTrees = mutable.Set[ValOrDefDef]()
+
+      extension (tree: ValOrDefDef)
+        def getRhs(using Context): Tree =
+          def getTree: Tree =
+            val errorCount = ctx.reporter.errorCount
+            val rhs = tree.rhs
+  
+            if (ctx.reporter.errorCount > errorCount)
+              emptyTrees.add(tree)
+              report.warning("Ignoring analyses of " + tree.name + " due to error in reading TASTy.")
+              EmptyTree
+            else
+              rhs
+  
+          if (emptyTrees.contains(tree)) EmptyTree
+          else getTree
+  end TreeCache
+  
 // ----- Operations on domains -----------------------------
   extension (a: Value)
     def join(b: Value): Value =
@@ -594,8 +600,7 @@ object Semantic:
           val target = if needResolve then resolve(ref.klass, field) else field
           if target.is(Flags.Lazy) then
             val rhs = target.defTree.asInstanceOf[ValDef].getRhs
-            if rhs.isEmpty then Hot
-            else eval(rhs, ref, target.owner.asClass, cacheResult = true)
+            eval(rhs, ref, target.owner.asClass, cacheResult = true)
           else if target.exists then
             val obj = ref.objekt
             if obj.hasField(target) then
@@ -610,8 +615,7 @@ object Semantic:
                 Hot
               else if target.hasSource then
                 val rhs = target.defTree.asInstanceOf[ValOrDefDef].getRhs
-                if rhs.isEmpty then Hot
-                else eval(rhs, ref, target.owner.asClass, cacheResult = true)
+                eval(rhs, ref, target.owner.asClass, cacheResult = true)
               else
                 val error = CallUnknown(field)(trace)
                 reporter.report(error)
@@ -735,8 +739,7 @@ object Semantic:
                 reporter.reportAll(tryReporter.errors)
                 extendTrace(ddef) {
                   val rhs = ddef.getRhs
-                  if rhs.isEmpty then Hot
-                  else eval(rhs, ref, cls, cacheResult = true)
+                  eval(rhs, ref, cls, cacheResult = true)
                 }
             else if ref.canIgnoreMethodCall(target) then
               Hot
@@ -822,8 +825,7 @@ object Semantic:
             else
               extendTrace(ddef) {
                 val rhs = ddef.getRhs
-                if rhs.isEmpty then Hot
-                else eval(rhs, ref, cls, cacheResult = true)
+                eval(rhs, ref, cls, cacheResult = true)
               }
           else if ref.canIgnoreMethodCall(ctor) then
             Hot
@@ -936,8 +938,7 @@ object Semantic:
 
               case ref: Ref =>
                 val rhs = vdef.getRhs
-                if rhs.isEmpty then Hot
-                else eval(rhs, ref, enclosingClass, cacheResult = sym.is(Flags.Lazy))
+                eval(rhs, ref, enclosingClass, cacheResult = sym.is(Flags.Lazy))
               case _ =>
                  report.warning("[Internal error] unexpected this value when accessing local variable, sym = " + sym.show + ", thisValue = " + thisValue2.show + Trace.show, Trace.position)
                  Hot
@@ -1144,7 +1145,7 @@ object Semantic:
    *
    *  The class to be checked must be an instantiable concrete class.
    */
-  private def checkClass(classSym: ClassSymbol)(using Cache.Data, Context): Unit =
+  private def checkClass(classSym: ClassSymbol)(using Cache.Data, Context, TreeCache.CacheData): Unit =
     val thisRef = ThisRef(classSym)
     val tpl = classSym.defTree.asInstanceOf[TypeDef].rhs.asInstanceOf[Template]
 
@@ -1179,6 +1180,7 @@ object Semantic:
    */
   def checkClasses(classes: List[ClassSymbol])(using Context): Unit =
     given Cache.Data()
+    given TreeCache.CacheData()
     for classSym <- classes if isConcreteClass(classSym) && !classSym.isStaticObject do
       checkClass(classSym)
 
@@ -1410,8 +1412,7 @@ object Semantic:
       case vdef : ValDef =>
         // local val definition
         val rhs = vdef.getRhs
-        if rhs.isEmpty then Hot
-        else eval(rhs, thisV, klass)
+        eval(rhs, thisV, klass)
 
 
       case ddef : DefDef =>
@@ -1631,7 +1632,7 @@ object Semantic:
     // class body
     if thisV.isThisRef || !thisV.asInstanceOf[Warm].isPopulatingParams then tpl.body.foreach {
       case vdef : ValDef if !vdef.symbol.is(Flags.Lazy) && !vdef.getRhs.isEmpty =>
-        val res = eval(vdef.rhs, thisV, klass)
+        val res = eval(vdef.getRhs, thisV, klass)
         // TODO: Improve promotion to avoid handling enum initialization specially
         //
         // The failing case is tests/init/pos/i12544.scala due to promotion failure.