Implement promotion

Author: liufengyun

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

@@ -342,7 +342,7 @@ object Checking {
     for (eff <- buffer.toList) {
       val errs = check(eff)
       if !errs.isEmpty then
-        return UnsafePromotion(warm, eff.source, state.path, errs.toList).toErrors
+        return UnsafePromotion(eff.source, state.path, errs.toList).toErrors
     }
     Errors.empty
 
@@ -355,7 +355,7 @@ object Checking {
           Errors.empty
         else pot match {
           case pot: ThisRef =>
-              PromoteThis(pot, eff.source, state.path).toErrors
+              PromoteThis(eff.source, state.path).toErrors
 
           case _: Cold =>
             PromoteCold(eff.source, state.path).toErrors
@@ -374,7 +374,7 @@ object Checking {
             }
 
             if (errs1.nonEmpty || errs2.nonEmpty)
-              UnsafePromotion(pot, eff.source, state.path, errs1 ++ errs2).toErrors
+              UnsafePromotion(eff.source, state.path, errs1 ++ errs2).toErrors
             else
               Errors.empty
 

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

@@ -12,7 +12,7 @@ import Types._, Symbols._, Contexts._
 import Effects._, Potentials._
 
 object Errors {
-  type Errors = List[Error]
+  type Errors = Seq[Error]
   val empty: Errors = Nil
 
   def show(errs: Errors)(using Context): String =
@@ -70,12 +70,12 @@ object Errors {
   }
 
   /** Promote `this` under initialization to fully-initialized */
-  case class PromoteThis(pot: ThisRef, source: Tree, trace: Vector[Tree]) extends Error {
+  case class PromoteThis(source: Tree, trace: Vector[Tree]) extends Error {
     def show(using Context): String = "Promote the value under initialization to fully-initialized."
   }
 
   /** Promote `this` under initialization to fully-initialized */
-  case class PromoteWarm(pot: Warm, source: Tree, trace: Vector[Tree]) extends Error {
+  case class PromoteWarm(source: Tree, trace: Vector[Tree]) extends Error {
     def show(using Context): String =
       "Promoting the value under initialization to fully-initialized."
   }
@@ -102,7 +102,7 @@ object Errors {
   }
 
   /** Promote a value under initialization to fully-initialized */
-  case class UnsafePromotion(pot: Potential, source: Tree, trace: Vector[Tree], errors: Errors) extends Error {
+  case class UnsafePromotion(source: Tree, trace: Vector[Tree], errors: Errors) extends Error {
     assert(errors.nonEmpty)
 
     override def issue(using Context): Unit =

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

@@ -45,8 +45,7 @@ class Semantic {
    *  of the heap, we may handle it in a simple way.
    */
   case class ThisRef(klass: ClassSymbol)(val fields: mutable.Map[Symbol, Value]) extends Value {
-    def updateField(field: Symbol, value: Value): Unit =
-      fields(field) = value
+    var allFieldsInitialized: Boolean = false
   }
 
   /** An object with all fields initialized but reaches objects under initialization
@@ -99,11 +98,8 @@ class Semantic {
 
     def +(error: Error): Result = this.copy(errors = this.errors :+ error)
 
-    def ensureHot(msg: String, source: Tree)(using Trace): Result =
-      if value == Hot then this
-      else
-        // TODO: define a new error
-        this + PromoteCold(source, trace)
+    def ensureHot(msg: String, source: Tree)(using Context, Trace): Result =
+      this ++ value.promote(msg, source)
 
     def select(f: Symbol, source: Tree)(using Context, Trace): Result =
       value.select(f, source) ++ errors
@@ -270,6 +266,67 @@ class Semantic {
       }
   end extension
 
+  extension (value: Value)
+    def canDirectlyPromote(using Context): Boolean =
+      value match
+      case Hot   =>  true
+      case Cold  =>  false
+
+      case warm: Warm  =>
+        warm.outer.canDirectlyPromote
+
+      case thisRef: ThisRef =>
+        thisRef.allFieldsInitialized || {
+          // If we have all fields initialized, then we can promote This to hot.
+          thisRef.allFieldsInitialized = thisRef.klass.appliedRef.fields.forall { denot =>
+            val sym = denot.symbol
+            sym.isOneOf(Flags.Lazy | Flags.Deferred) || thisRef.fields.contains(sym)
+          }
+          thisRef.allFieldsInitialized
+        }
+
+      case fun: Fun => false
+
+      case RefSet(refs) =>
+        refs.forall(_.canDirectlyPromote)
+
+    end canDirectlyPromote
+
+    /** Promotion of values to hot */
+    def promote(msg: String, source: Tree)(using Context, Trace): List[Error] =
+      value match
+      case Hot   =>  Nil
+
+      case Cold  =>  PromoteCold(source, trace) :: Nil
+
+      case thisRef: ThisRef =>
+        if thisRef.canDirectlyPromote then Nil
+        else PromoteThis(source, trace) :: Nil
+
+      case warm: Warm =>
+        if warm.outer.canDirectlyPromote then Nil
+        else PromoteWarm(source, trace) :: Nil
+
+      case Fun(body, thisV, klass) =>
+        val res = eval(body, thisV, klass)
+        val errors2 = res.value.promote(msg, source)
+        if (res.errors.nonEmpty || errors2.nonEmpty)
+          UnsafePromotion(source, trace, res.errors ++ errors2) :: Nil
+        else
+          Nil
+
+      case RefSet(refs) =>
+        refs.flatMap(_.promote(msg, source))
+  end extension
+
+  extension (ref: ThisRef | Warm)
+    def updateField(field: Symbol, value: Value): Unit =
+      ref match
+      case thisRef: ThisRef => thisRef.fields(field) = value
+      case warm: Warm => // ignore
+  end extension
+
+
 // ----- Semantic definition --------------------------------
 
   /** Evaluate an expression with the given value for `this` in a given class `klass`

tests/init/neg/function1.scala

@@ -4,7 +4,7 @@ class Foo {
   val fun2: Int => Int = n => 1 + n + list.size
   fun2(5)
 
-  List(5, 9).map(n => 2 + n + list.size)
+  List(5, 9).map(n => 2 + n + list.size)         // error
 
   final val list = List(1, 2, 3)                 // error