Refactor type hierarchy for abstract value

EnzeXing · EnzeXing · commit 3ae39e35e8db · 2023-06-25T17:42:44.000+08:00
diff --git a/compiler/src/dotty/tools/dotc/transform/init/Objects.scala b/compiler/src/dotty/tools/dotc/transform/init/Objects.scala
@@ -69,10 +69,10 @@ object Objects:
   /** Syntax for the data structure abstraction used in abstract domain:
    *
    * ve ::= ObjectRef(class)
-   * | OfClass(class, vs[outer], ctor, args, env)
-   * | OfArray(object[owner], regions)
-   * | Fun(..., env)
-   * | Cold // abstract values in domain
+   *      | OfClass(class, vs[outer], ctor, args, env)
+   *      | OfArray(object[owner], regions)
+   *      | Fun(..., env)
+   *      | Cold                                                         // abstract values in domain
    * vs ::= Set(ve)                                                      // set of abstract values
    *
    * refMap = ( ObjectRef | OfClass ) -> ( valsMap, varsMap, outersMap ) // refMap stores field informations of an object or instance
@@ -87,25 +87,29 @@ object Objects:
    * env = (valsMap, Option[env])                                        // stores local variables in the residing method, and possibly outer environments
    *
    * addr ::= localVarAddr(regions, valsym, owner)
-   * | fieldVarAddr(regions, valsym, owner)                              // independent of OfClass/ObjectRef
-   * | arrayAddr(regions, owner)                                         // independent of array element type
+   *        | fieldVarAddr(regions, valsym, owner)                       // independent of OfClass/ObjectRef
+   *        | arrayAddr(regions, owner)                                  // independent of array element type
    *
    * regions ::= List(sourcePosition)
    */
 
   sealed abstract class Value:
     def show(using Context): String
 
+  /** ValueElement are elements that can be contained in a RefSet */
   sealed abstract class ValueElement extends Value
 
+  sealed trait ThisValue extends Value:
+    def widenThisV(height : Int)(using Context) : ThisValue = this
+
   /**
    * A reference caches the values for outers and immutable fields.
    */
   sealed abstract class Ref(
     valsMap: mutable.Map[Symbol, Value],
     varsMap: mutable.Map[Symbol, Heap.Addr],
     outersMap: mutable.Map[ClassSymbol, Value])
-  extends ValueElement:
+  extends ValueElement with ThisValue:
     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
@@ -162,6 +166,12 @@ object Objects:
     def widenedCopy(outer: Value, args: List[Value], env: Env.Data): OfClass =
       new OfClass(klass, outer, ctor, args, env)(this.valsMap, this.varsMap, this.outersMap)
 
+    override def widenThisV(height: Int)(using Context): ThisValue =
+      val outer2 = outer.widen(height - 1)
+      val args2 = args.map(_.widen(height - 1))
+      val env2 = env.widen(height - 1)
+      widenedCopy(outer2, args2, env2)
+
     def show(using Context) =
       val valFields = vals.map(_.show +  " -> " +  _.show)
       "OfClass(" + klass.show + ", outer = " + outer + ", args = " + args.map(_.show) + ", vals = " + valFields + ")"
@@ -198,24 +208,29 @@ object Objects:
   /**
    * Represents a lambda expression
    */
-  case class Fun(code: Tree, thisV: ValueElement, klass: ClassSymbol, env: Env.Data) extends Value:
+  case class Fun(code: Tree, thisV: ThisValue, klass: ClassSymbol, env: Env.Data) extends ValueElement:
     def show(using Context) = "Fun(" + code.show + ", " + thisV.show + ", " + klass.show + ")"
 
   /**
    * Represents a set of values
    *
    * It comes from `if` expressions.
    */
-  case class RefSet(refs: ListSet[Value]) extends Value:
-    assert(refs.forall(!_.isInstanceOf[RefSet]))
+  case class RefSet(refs: ListSet[ValueElement]) extends Value:
     def show(using Context) = refs.map(_.show).mkString("[", ",", "]")
 
-  /** A cold alias which should not be used during initialization. */
-  case object Cold extends ValueElement:
+  /** A cold alias which should not be used during initialization.
+   *
+   *  Cold is not ValueElement since RefSet containing Cold is equivalent to Cold
+   */
+  case object Cold extends Value with ThisValue:
     def show(using Context) = "Cold"
 
   val Bottom = RefSet(ListSet.empty)
 
+  // type ThisValue = Ref | Cold // used for typing thisV, whose value can only be Ref or Cold
+  // type VEOrCold = ValueElement | Cold
+
   /** Checking state  */
   object State:
     class Data:
@@ -411,7 +426,7 @@ object Objects:
      *
      * @return the environment and value for `this` owned by the given method.
      */
-    def resolveEnv(meth: Symbol, thisV: Value, env: Data)(using Context): Option[(Value, Data)] = log("Resolving env for " + meth.show + ", this = " + thisV.show + ", env = " + env.show, printer) {
+    def resolveEnv(meth: Symbol, thisV: ThisValue, env: Data)(using Context): Option[(ThisValue, Data)] = log("Resolving env for " + meth.show + ", this = " + thisV.show + ", env = " + env.show, printer) {
       env match
       case localEnv: LocalEnv =>
         if localEnv.meth == meth then Some(thisV -> env)
@@ -420,7 +435,11 @@ object Objects:
         // TODO: handle RefSet
         thisV match
         case ref: OfClass =>
-          resolveEnv(meth, ref.outer, ref.env)
+          ref.outer match
+          case outer : ThisValue =>
+            resolveEnv(meth, outer, ref.env)
+          case _ => // This is the case for top-level classes and local classes
+            None
         case _ =>
           None
     }
@@ -494,7 +513,7 @@ object Objects:
         val config = Config(thisV, summon[Env.Data], Heap.getHeapData())
         super.get(config, expr).map(_.value)
 
-      def cachedEval(thisV: ValueElement, expr: Tree, cacheResult: Boolean)(fun: Tree => Value)(using Heap.MutableData, Env.Data): Value =
+      def cachedEval(thisV: ThisValue, 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())
@@ -551,14 +570,14 @@ object Objects:
   extension (a: Value)
     def join(b: Value): Value =
       (a, b) match
-      case (Cold, b)                          => Cold
-      case (a, Cold)                          => Cold
-      case (Bottom, b)                        => b
-      case (a, Bottom)                        => a
-      case (RefSet(refs1), RefSet(refs2))     => RefSet(refs1 ++ refs2)
-      case (a, RefSet(refs))                  => RefSet(refs + a)
-      case (RefSet(refs), b)                  => RefSet(refs + b)
-      case (a, b)                             => RefSet(ListSet(a, b))
+      case (Cold, b)                            => Cold
+      case (a, Cold)                            => Cold
+      case (Bottom, b)                          => b
+      case (a, Bottom)                          => a
+      case (RefSet(refs1), RefSet(refs2))       => RefSet(refs1 ++ refs2)
+      case (a : ValueElement, RefSet(refs))     => RefSet(refs + a)
+      case (RefSet(refs), b : ValueElement)     => RefSet(refs + b)
+      case (a : ValueElement, b : ValueElement) => RefSet(ListSet(a, b))
 
     def widen(height: Int)(using Context): Value =
       if height == 0 then Cold
@@ -570,13 +589,10 @@ object Objects:
           refs.map(ref => ref.widen(height)).join
 
         case Fun(code, thisV, klass, env) =>
-          Fun(code, thisV.widen(height).asInstanceOf[ValueElement], klass, env.widen(height))
+          Fun(code, thisV.widenThisV(height), klass, env.widen(height))
 
-        case ref @ OfClass(klass, outer, _, args, env) =>
-          val outer2 = outer.widen(height - 1)
-          val args2 = args.map(_.widen(height - 1))
-          val env2 = env.widen(height - 1)
-          ref.widenedCopy(outer2, args2, env2)
+        case ref : Ref =>
+          ref.widenThisV(height)
 
         case _ => a
 
@@ -641,7 +657,7 @@ object Objects:
           val ddef = target.defTree.asInstanceOf[DefDef]
           val meth = ddef.symbol
 
-          val (thisV, outerEnv) =
+          val (thisV : ThisValue, outerEnv) =
             if meth.owner.isClass then
               (ref, Env.NoEnv)
             else
@@ -653,7 +669,7 @@ object Objects:
             // eval(ddef.rhs, ref, cls, cacheResult = true)
             cache.cachedEval(ref, ddef.rhs, cacheResult = true) { expr =>
               Returns.installHandler(meth)
-              val res = cases(expr, thisV.asInstanceOf[ValueElement], cls)
+              val res = cases(expr, thisV, cls)
               val returns = Returns.popHandler(meth)
               res.join(returns)
             }
@@ -692,13 +708,13 @@ object Objects:
 
   /** Handle constructor calls `<init>(args)`.
    *
-   * @param thisV        The value for the receiver.
+   * @param value        The value for the receiver.
    * @param ctor         The symbol of the target method.
    * @param args         Arguments of the constructor call (all parameter blocks flatten to a list).
    */
-  def callConstructor(thisV: Value, ctor: Symbol, args: List[ArgInfo]): Contextual[Value] = log("call " + ctor.show + ", args = " + args.map(_.value.show), printer, (_: Value).show) {
+  def callConstructor(value: Value, ctor: Symbol, args: List[ArgInfo]): Contextual[Value] = log("call " + ctor.show + ", args = " + args.map(_.value.show), printer, (_: Value).show) {
 
-    thisV match
+    value match
     case ref: Ref =>
       if ctor.hasSource then
         val cls = ctor.owner.enclosingClass.asClass
@@ -720,7 +736,7 @@ object Objects:
         Bottom
 
     case _ =>
-      report.warning("[Internal error] unexpected constructor call, meth = " + ctor + ", this = " + thisV + Trace.show, Trace.position)
+      report.warning("[Internal error] unexpected constructor call, meth = " + ctor + ", this = " + value + Trace.show, Trace.position)
       Bottom
   }
 
@@ -850,7 +866,7 @@ object Objects:
             (outer.widen(1), Env.NoEnv)
           else
             // klass.enclosingMethod returns its primary constructor
-            Env.resolveEnv(klass.owner.enclosingMethod, outer.asInstanceOf[ValueElement], summon[Env.Data]).getOrElse(Cold -> Env.NoEnv)
+            Env.resolveEnv(klass.owner.enclosingMethod, outer.asInstanceOf[ThisValue], summon[Env.Data]).getOrElse(Cold -> Env.NoEnv)
 
         val instance = OfClass(klass, outerWidened, ctor, args.map(_.value), envWidened)
         callConstructor(instance, ctor, args)
@@ -880,7 +896,7 @@ object Objects:
    * @param thisV        The value for `this` where the variable is used.
    * @param sym          The symbol of the variable.
    */
-  def readLocal(thisV: ValueElement, sym: Symbol): Contextual[Value] = log("reading local " + sym.show, printer, (_: Value).show) {
+  def readLocal(thisV: ThisValue, 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) =>
@@ -934,7 +950,7 @@ object Objects:
    * @param sym          The symbol of the variable.
    * @param value        The value of the rhs of the assignment.
    */
-  def writeLocal(thisV: ValueElement, sym: Symbol, value: Value): Contextual[Value] = log("write local " + sym.show + " with " + value.show, printer, (_: Value).show) {
+  def writeLocal(thisV: ThisValue, 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
@@ -955,7 +971,7 @@ object Objects:
   // -------------------------------- algorithm --------------------------------
 
   /** Check an individual object */
-  private def accessObject(classSym: ClassSymbol)(using Context, State.Data, Trace): Value = log("accessing " + classSym.show, printer, (_: Value).show) {
+  private def accessObject(classSym: ClassSymbol)(using Context, State.Data, Trace): ObjectRef = log("accessing " + classSym.show, printer, (_: Value).show) {
     if classSym.hasSource then
       State.checkObjectAccess(classSym)
     else
@@ -992,13 +1008,13 @@ 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: ValueElement, 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: ThisValue, klass: ClassSymbol, cacheResult: Boolean = false): Contextual[Value] = log("evaluating " + expr.show + ", this = " + thisV.show + ", regions = " + Regions.show + " in " + klass.show, printer, (_: Value).show) {
     cache.cachedEval(thisV, expr, cacheResult) { expr => cases(expr, thisV, klass) }
   }
 
 
   /** Evaluate a list of expressions */
-  def evalExprs(exprs: List[Tree], thisV: ValueElement, klass: ClassSymbol): Contextual[List[Value]] =
+  def evalExprs(exprs: List[Tree], thisV: ThisValue, klass: ClassSymbol): Contextual[List[Value]] =
     exprs.map { expr => eval(expr, thisV, klass) }
 
   /** Handles the evaluation of different expressions
@@ -1009,7 +1025,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: ValueElement, klass: ClassSymbol): Contextual[Value] = log("evaluating " + expr.show + ", this = " + thisV.show + " in " + klass.show, printer, (_: Value).show) {
+  def cases(expr: Tree, thisV: ThisValue, klass: ClassSymbol): Contextual[Value] = log("evaluating " + expr.show + ", this = " + thisV.show + " in " + klass.show, printer, (_: Value).show) {
     val trace2 = trace.add(expr)
 
     expr match
@@ -1211,7 +1227,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: ValueElement, klass: ClassSymbol, elideObjectAccess: Boolean = false): Contextual[Value] = log("evaluating " + tp.show, printer, (_: Value).show) {
+  def evalType(tp: Type, thisV: ThisValue, klass: ClassSymbol, elideObjectAccess: Boolean = false): Contextual[Value] = log("evaluating " + tp.show, printer, (_: Value).show) {
     tp match
       case _: ConstantType =>
         Bottom
@@ -1261,7 +1277,7 @@ object Objects:
   }
 
   /** Evaluate arguments of methods and constructors */
-  def evalArgs(args: List[Arg], thisV: ValueElement, klass: ClassSymbol): Contextual[List[ArgInfo]] =
+  def evalArgs(args: List[Arg], thisV: ThisValue, klass: ClassSymbol): Contextual[List[ArgInfo]] =
     val argInfos = new mutable.ArrayBuffer[ArgInfo]
     args.foreach { arg =>
       val res =
@@ -1297,7 +1313,7 @@ object Objects:
    * @param thisV     The value of the current object to be initialized.
    * @param klass     The class to which the template belongs.
    */
-  def init(tpl: Template, thisV: Ref, klass: ClassSymbol): Contextual[Value] = log("init " + klass.show, printer, (_: Value).show) {
+  def init(tpl: Template, thisV: Ref, klass: ClassSymbol): Contextual[Ref] = log("init " + klass.show, printer, (_: Value).show) {
     val paramsMap = tpl.constr.termParamss.flatten.map { vdef =>
       vdef.name -> Env.valValue(vdef.symbol)
     }.toMap
@@ -1461,7 +1477,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: ValueElement, klass: ClassSymbol): Contextual[Value] =
+  def outerValue(tref: TypeRef, thisV: ThisValue, klass: ClassSymbol): Contextual[Value] =
     val cls = tref.classSymbol.asClass
     if tref.prefix == NoPrefix then
       val enclosing = cls.owner.lexicallyEnclosingClass.asClass
