Rewriting widen as abstract method

Author: EnzeXing

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

@@ -95,12 +95,15 @@ object Objects:
 
   sealed abstract class Value:
     def show(using Context): String
+    def widen(height : Int)(using Context): Value =
+      if height == 0 then Cold else this
 
   /** 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
+    override def widen(height : Int)(using Context) : ThisValue =
+      if height == 0 then Cold else this
 
   /**
    * A reference caches the values for outers and immutable fields.
@@ -166,11 +169,14 @@ 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)
+    override def widen(height: Int)(using Context): ThisValue =
+      if height == 0 then
+        Cold
+      else
+        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)
@@ -211,6 +217,9 @@ object Objects:
   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 + ")"
 
+    override def widen(height: Int)(using Context): Value =
+      Fun(code, thisV.widen(height), klass, env.widen(height))
+
   /**
    * Represents a set of values
    *
@@ -219,11 +228,17 @@ object Objects:
   case class RefSet(refs: ListSet[ValueElement]) extends Value:
     def show(using Context) = refs.map(_.show).mkString("[", ",", "]")
 
+    override def widen(height: Int)(using Context): Value =
+      if height == 0 then
+        Cold
+      else
+        refs.map(ref => ref.widen(height)).join
+
   /** 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:
+  case object Cold extends ThisValue:
     def show(using Context) = "Cold"
 
   val Bottom = RefSet(ListSet.empty)
@@ -435,7 +450,7 @@ object Objects:
           ref.outer match
           case outer : ThisValue =>
             resolveEnv(meth, outer, ref.env)
-          case _ => // This is the case for top-level classes and local classes
+          case _ => // This is the case for top-level
             None
         case _ =>
           None
@@ -576,7 +591,7 @@ object Objects:
       case (RefSet(refs), b : ValueElement)     => RefSet(refs + b)
       case (a : ValueElement, b : ValueElement) => RefSet(ListSet(a, b))
 
-    def widen(height: Int)(using Context): Value =
+    /* def widen(height: Int)(using Context): Value =
       if height == 0 then Cold
       else
         a match
@@ -591,7 +606,7 @@ object Objects:
         case ref : Ref =>
           ref.widenThisV(height)
 
-        case _ => a
+        case _ => a */
 
   extension (values: Iterable[Value])
     def join: Value = if values.isEmpty then Bottom else values.reduce { (v1, v2) => v1.join(v2) }
@@ -859,11 +874,15 @@ object Objects:
       else
         // Widen the outer to finitize the domain. Arguments already widened in `evalArgs`.
         val (outerWidened, envWidened) =
-          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.asInstanceOf[ThisValue], summon[Env.Data]).getOrElse(Cold -> Env.NoEnv)
+          value match
+            case _ : Bottom.type => // For top-level classes
+              (Bottom, Env.NoEnv)
+            case thisV : ThisValue =>
+              if klass.owner.isClass then // For top-level classes, klass.owner is the enclosing package, which is a class
+                (thisV.widen(1), Env.NoEnv)
+              else
+                // klass.enclosingMethod returns its primary constructor
+                Env.resolveEnv(klass.owner.enclosingMethod, thisV, summon[Env.Data]).getOrElse(Cold -> Env.NoEnv)
 
         val instance = OfClass(klass, outerWidened, ctor, args.map(_.value), envWidened)
         callConstructor(instance, ctor, args)