Adding ValueElement and refining type for thisV

Author: EnzeXing

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

@@ -69,6 +69,7 @@ object Objects:
   sealed abstract class Value:
     def show(using Context): String
 
+  sealed abstract class ValueElement extends Value
 
   /**
    * A reference caches the values for outers and immutable fields.
@@ -77,7 +78,7 @@ object Objects:
     valsMap: mutable.Map[Symbol, Value],
     varsMap: mutable.Map[Symbol, Heap.Addr],
     outersMap: mutable.Map[ClassSymbol, Value])
-  extends Value:
+  extends ValueElement:
     protected val vals: mutable.Map[Symbol, Value] = valsMap
     protected val vars: mutable.Map[Symbol, Heap.Addr] = varsMap
     protected val outers: mutable.Map[ClassSymbol, Value] = outersMap
@@ -170,7 +171,7 @@ object Objects:
   /**
    * Represents a lambda expression
    */
-  case class Fun(code: Tree, thisV: Value, klass: ClassSymbol, env: Env.Data) extends Value:
+  case class Fun(code: Tree, thisV: ValueElement, klass: ClassSymbol, env: Env.Data) extends Value:
     def show(using Context) = "Fun(" + code.show + ", " + thisV.show + ", " + klass.show + ")"
 
   /**
@@ -183,7 +184,7 @@ object Objects:
     def show(using Context) = refs.map(_.show).mkString("[", ",", "]")
 
   /** A cold alias which should not be used during initialization. */
-  case object Cold extends Value:
+  case object Cold extends ValueElement:
     def show(using Context) = "Cold"
 
   val Bottom = RefSet(ListSet.empty)
@@ -240,7 +241,7 @@ object Objects:
       obj
     end doCheckObject
 
-    def checkObjectAccess(clazz: ClassSymbol)(using data: Data, ctx: Context, pendingTrace: Trace): Value =
+    def checkObjectAccess(clazz: ClassSymbol)(using data: Data, ctx: Context, pendingTrace: Trace): ObjectRef =
       val index = data.checkingObjects.indexOf(ObjectRef(clazz))
 
       if index != -1 then
@@ -466,7 +467,7 @@ object Objects:
         val config = Config(thisV, summon[Env.Data], Heap.getHeapData())
         super.get(config, expr).map(_.value)
 
-      def cachedEval(thisV: Value, expr: Tree, cacheResult: Boolean)(fun: Tree => Value)(using Heap.MutableData, Env.Data): Value =
+      def cachedEval(thisV: ValueElement, expr: Tree, cacheResult: Boolean)(fun: Tree => Value)(using Heap.MutableData, Env.Data): Value =
         val config = Config(thisV, summon[Env.Data], Heap.getHeapData())
         val result = super.cachedEval(config, expr, cacheResult, default = Res(Bottom, Heap.getHeapData())) { expr =>
           Res(fun(expr), Heap.getHeapData())
@@ -542,7 +543,7 @@ object Objects:
           refs.map(ref => ref.widen(height)).join
 
         case Fun(code, thisV, klass, env) =>
-          Fun(code, thisV.widen(height), klass, env.widen(height))
+          Fun(code, thisV.widen(height).asInstanceOf[ValueElement], klass, env.widen(height))
 
         case ref @ OfClass(klass, outer, _, args, env) =>
           val outer2 = outer.widen(height - 1)
@@ -619,13 +620,14 @@ object Objects:
             else
               Env.resolveEnv(meth.owner.enclosingMethod, ref, summon[Env.Data]).getOrElse(Cold -> Env.NoEnv)
 
+          assert(thisV.isInstanceOf[ValueElement], "thisV = " + thisV)
           val env2 = Env.of(ddef, args.map(_.value), outerEnv)
           extendTrace(ddef) {
             given Env.Data = env2
             // eval(ddef.rhs, ref, cls, cacheResult = true)
             cache.cachedEval(ref, ddef.rhs, cacheResult = true) { expr =>
               Returns.installHandler(meth)
-              val res = cases(expr, thisV, cls)
+              val res = cases(expr, thisV.asInstanceOf[ValueElement], cls)
               val returns = Returns.popHandler(meth)
               res.join(returns)
             }
@@ -699,8 +701,8 @@ object Objects:
    * @param receiver     The type of the receiver.
    * @param needResolve  Whether the target of the selection needs resolution?
    */
-  def select(thisV: Value, field: Symbol, receiver: Type, needResolve: Boolean = true): Contextual[Value] = log("select " + field.show + ", this = " + thisV.show, printer, (_: Value).show) {
-    thisV match
+  def select(value: Value, field: Symbol, receiver: Type, needResolve: Boolean = true): Contextual[Value] = log("select " + field.show + ", this = " + value.show, printer, (_: Value).show) {
+    value match
     case Cold =>
       report.warning("Using cold alias", Trace.position)
       Bottom
@@ -814,11 +816,11 @@ object Objects:
       else
         // Widen the outer to finitize the domain. Arguments already widened in `evalArgs`.
         val (outerWidened, envWidened) =
-          if klass.owner.isClass then
+          if klass.owner.isClass then // For top-level classes, klass.owner is the enclosing package, which is a class
             (outer.widen(1), Env.NoEnv)
           else
             // klass.enclosingMethod returns its primary constructor
-            Env.resolveEnv(klass.owner.enclosingMethod, outer, summon[Env.Data]).getOrElse(Cold -> Env.NoEnv)
+            Env.resolveEnv(klass.owner.enclosingMethod, outer.asInstanceOf[ValueElement], summon[Env.Data]).getOrElse(Cold -> Env.NoEnv)
 
         val instance = OfClass(klass, outerWidened, ctor, args.map(_.value), envWidened)
         callConstructor(instance, ctor, args)
@@ -848,7 +850,7 @@ object Objects:
    * @param thisV        The value for `this` where the variable is used.
    * @param sym          The symbol of the variable.
    */
-  def readLocal(thisV: Value, sym: Symbol): Contextual[Value] = log("reading local " + sym.show, printer, (_: Value).show) {
+  def readLocal(thisV: ValueElement, sym: Symbol): Contextual[Value] = log("reading local " + sym.show, printer, (_: Value).show) {
     def isByNameParam(sym: Symbol) = sym.is(Flags.Param) && sym.info.isInstanceOf[ExprType]
     Env.resolveEnv(sym.enclosingMethod, thisV, summon[Env.Data]) match
     case Some(thisV -> env) =>
@@ -902,7 +904,7 @@ object Objects:
    * @param sym          The symbol of the variable.
    * @param value        The value of the rhs of the assignment.
    */
-  def writeLocal(thisV: Value, sym: Symbol, value: Value): Contextual[Value] = log("write local " + sym.show + " with " + value.show, printer, (_: Value).show) {
+  def writeLocal(thisV: ValueElement, sym: Symbol, value: Value): Contextual[Value] = log("write local " + sym.show + " with " + value.show, printer, (_: Value).show) {
 
     assert(sym.is(Flags.Mutable), "Writing to immutable variable " + sym.show)
     Env.resolveEnv(sym.enclosingMethod, thisV, summon[Env.Data]) match
@@ -960,13 +962,14 @@ object Objects:
    * @param klass       The enclosing class where the expression is located.
    * @param cacheResult It is used to reduce the size of the cache.
    */
-  def eval(expr: Tree, thisV: Value, klass: ClassSymbol, cacheResult: Boolean = false): Contextual[Value] = log("evaluating " + expr.show + ", this = " + thisV.show + ", regions = " + Regions.show + " in " + klass.show, printer, (_: Value).show) {
+  def eval(expr: Tree, thisV: ValueElement, klass: ClassSymbol, cacheResult: Boolean = false): Contextual[Value] = log("evaluating " + expr.show + ", this = " + thisV.show + ", regions = " + Regions.show + " in " + klass.show, printer, (_: Value).show) {
+    // assert(thisV.isInstanceOf[ValueElement], "thisV is not ValueElement, " + "evaluating " + expr.show + ", this = " + thisV.show)
     cache.cachedEval(thisV, expr, cacheResult) { expr => cases(expr, thisV, klass) }
   }
 
 
   /** Evaluate a list of expressions */
-  def evalExprs(exprs: List[Tree], thisV: Value, klass: ClassSymbol): Contextual[List[Value]] =
+  def evalExprs(exprs: List[Tree], thisV: ValueElement, klass: ClassSymbol): Contextual[List[Value]] =
     exprs.map { expr => eval(expr, thisV, klass) }
 
   /** Handles the evaluation of different expressions
@@ -977,7 +980,7 @@ object Objects:
    * @param thisV  The value for `C.this` where `C` is represented by the parameter `klass`.
    * @param klass  The enclosing class where the expression `expr` is located.
    */
-  def cases(expr: Tree, thisV: Value, klass: ClassSymbol): Contextual[Value] = log("evaluating " + expr.show + ", this = " + thisV.show + " in " + klass.show, printer, (_: Value).show) {
+  def cases(expr: Tree, thisV: ValueElement, klass: ClassSymbol): Contextual[Value] = log("evaluating " + expr.show + ", this = " + thisV.show + " in " + klass.show, printer, (_: Value).show) {
     val trace2 = trace.add(expr)
 
     expr match
@@ -1179,7 +1182,7 @@ object Objects:
    * Object access elission happens when the object access is used as a prefix
    * in `new o.C` and `C` does not need an outer.
    */
-  def evalType(tp: Type, thisV: Value, klass: ClassSymbol, elideObjectAccess: Boolean = false): Contextual[Value] = log("evaluating " + tp.show, printer, (_: Value).show) {
+  def evalType(tp: Type, thisV: ValueElement, klass: ClassSymbol, elideObjectAccess: Boolean = false): Contextual[Value] = log("evaluating " + tp.show, printer, (_: Value).show) {
     tp match
       case _: ConstantType =>
         Bottom
@@ -1229,7 +1232,7 @@ object Objects:
   }
 
   /** Evaluate arguments of methods and constructors */
-  def evalArgs(args: List[Arg], thisV: Value, klass: ClassSymbol): Contextual[List[ArgInfo]] =
+  def evalArgs(args: List[Arg], thisV: ValueElement, klass: ClassSymbol): Contextual[List[ArgInfo]] =
     val argInfos = new mutable.ArrayBuffer[ArgInfo]
     args.foreach { arg =>
       val res =
@@ -1429,7 +1432,7 @@ object Objects:
    * @param thisV   The value for `C.this` where `C` is represented by the parameter `klass`.
    * @param klass   The enclosing class where the type `tref` is located.
    */
-  def outerValue(tref: TypeRef, thisV: Value, klass: ClassSymbol): Contextual[Value] =
+  def outerValue(tref: TypeRef, thisV: ValueElement, klass: ClassSymbol): Contextual[Value] =
     val cls = tref.classSymbol.asClass
     if tref.prefix == NoPrefix then
       val enclosing = cls.owner.lexicallyEnclosingClass.asClass