Allowing non-hot assignment to local val and updating tests

Author: EnzeXing

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -192,7 +192,7 @@ object Config {
   inline val flattenContextFunctionResults = true
 
   /** If set, enables tracing */
-  inline val tracingEnabled = false
+  inline val tracingEnabled = true
 
   /** Initial capacity of the uniques HashMap.
    *  Note: This should be a power of two to work with util.HashSet

compiler/src/dotty/tools/dotc/config/Printers.scala

@@ -28,7 +28,7 @@ object Printers {
   val implicits = noPrinter
   val implicitsDetailed = noPrinter
   val lexical = noPrinter
-  val init = noPrinter
+  val init = new Printer
   val inlining = noPrinter
   val interactiv = noPrinter
   val matchTypes = noPrinter

compiler/src/dotty/tools/dotc/reporting/trace.scala

@@ -90,7 +90,7 @@ trait TraceSyntax:
           finalize(trailing(ex.value))
           throw ex
         case ex: Throwable =>
-          val msg = s"<== $q = <missing> (with exception $ex)"
-          finalize(msg)
+          // val msg = s"<== $q = <missing> (with exception $ex)"
+          // finalize(msg)
           throw ex
 end TraceSyntax

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

@@ -194,6 +194,7 @@ class Semantic {
     class PromotionInfo {
       var isCurrentObjectPromoted: Boolean = false
       val values = mutable.Set.empty[Value]
+      override def toString(): String = values.toString()
     }
     /** Values that have been safely promoted */
     opaque type Promoted = PromotionInfo
@@ -405,6 +406,7 @@ class Semantic {
               given Trace = trace1
               val cls = target.owner.enclosingClass.asClass
               val ddef = target.defTree.asInstanceOf[DefDef]
+              // try early promotion here; if returns error, returns cold
               val env2 = Env(ddef, args.map(_.value).widenArgs)
               if target.isPrimaryConstructor then
                 given Env = env2
@@ -683,8 +685,26 @@ class Semantic {
   }
 
   /** Evaluate a list of expressions */
-  def eval(exprs: List[Tree], thisV: Addr, klass: ClassSymbol): Contextual[List[Result]] =
-    exprs.map { expr => eval(expr, thisV, klass) }
+  def eval(exprs: List[Tree], thisV: Addr, klass: ClassSymbol): Contextual[(List[Result], Env)] = exprs match {
+    case Nil => (Nil, env)
+    case h :: t => h match {
+      case v: ValDef => {
+        val res = eval(h, thisV, klass)
+        val newEnv = Env(Map(v.symbol -> res.value))
+        withEnv(env.union(newEnv)) {
+          val (res2, env2) = eval(t, thisV, klass)
+          (res :: res2, env2)
+        }
+      }
+      case _ => {
+        val res = eval(h, thisV, klass)
+        withEnv(env) {
+          val (res2, env2) = eval(t, thisV, klass)
+          (res :: res2, env2)
+        }
+      }
+    }
+  }
 
   /** Evaluate arguments of methods */
   def evalArgs(args: List[Arg], thisV: Addr, klass: ClassSymbol): Contextual[(List[Error], List[ArgInfo])] =
@@ -788,11 +808,13 @@ class Semantic {
         Result(value, Nil)
 
       case Block(stats, expr) =>
-        val ress = eval(stats, thisV, klass)
-        eval(expr, thisV, klass) ++ ress.flatMap(_.errors)
+        val (ress, env2) = eval(stats, thisV, klass)
+        withEnv(env2) {
+          eval(expr, thisV, klass) ++ ress.flatMap(_.errors)
+        }
 
       case If(cond, thenp, elsep) =>
-        val ress = eval(cond :: thenp :: elsep :: Nil, thisV, klass)
+        val (ress, env2) = eval(cond :: thenp :: elsep :: Nil, thisV, klass)
         val value = ress.map(_.value).join
         val errors = ress.flatMap(_.errors)
         Result(value, errors)
@@ -803,7 +825,7 @@ class Semantic {
 
       case Match(selector, cases) =>
         val res1 = eval(selector, thisV, klass).ensureHot("The value to be matched needs to be fully initialized", selector)
-        val ress = eval(cases.map(_.body), thisV, klass)
+        val (ress, env) = eval(cases.map(_.body), thisV, klass)
         val value = ress.map(_.value).join
         val errors = res1.errors ++ ress.flatMap(_.errors)
         Result(value, errors)
@@ -812,15 +834,15 @@ class Semantic {
         eval(expr, thisV, klass).ensureHot("return expression may only be initialized value", expr)
 
       case WhileDo(cond, body) =>
-        val ress = eval(cond :: body :: Nil, thisV, klass)
+        val (ress, env2) = eval(cond :: body :: Nil, thisV, klass)
         Result(Hot, ress.flatMap(_.errors))
 
       case Labeled(_, expr) =>
         eval(expr, thisV, klass)
 
       case Try(block, cases, finalizer) =>
         val res1 = eval(block, thisV, klass)
-        val ress = eval(cases.map(_.body), thisV, klass)
+        val (ress, env2) = eval(cases.map(_.body), thisV, klass)
         val errors = ress.flatMap(_.errors)
         val resValue = ress.map(_.value).join
         if finalizer.isEmpty then
@@ -836,7 +858,7 @@ class Semantic {
         Result(Hot, ress.flatMap(_.errors))
 
       case Inlined(call, bindings, expansion) =>
-        val ress = eval(bindings, thisV, klass)
+        val (ress, env2) = eval(bindings, thisV, klass)
         eval(expansion, thisV, klass) ++ ress.flatMap(_.errors)
 
       case Thicket(List()) =>
@@ -846,7 +868,8 @@ class Semantic {
       case vdef : ValDef =>
         // local val definition
         // TODO: support explicit @cold annotation for local definitions
-        eval(vdef.rhs, thisV, klass).ensureHot("Local definitions may only hold initialized values", vdef)
+        eval(vdef.rhs, thisV, klass)
+        // .ensureHot("Local definitions may only hold initialized values", vdef)
 
       case ddef : DefDef =>
         // local method
@@ -891,7 +914,7 @@ class Semantic {
             // It's always safe to approximate them with `Cold`.
             Result(Cold, Nil)
         else
-          default()
+          Result(env.getOrElse(sym, Hot), Nil)
 
       case tmref: TermRef =>
         cases(tmref.prefix, thisV, klass, source).select(tmref.symbol, source)
@@ -987,7 +1010,7 @@ class Semantic {
     // parents
     def initParent(parent: Tree, tasks: Tasks)(using Env) = parent match {
       case tree @ Block(stats, NewExpr(tref, New(tpt), ctor, argss)) =>  // can happen
-        eval(stats, thisV, klass).foreach { res => errorBuffer ++= res.errors }
+        eval(stats, thisV, klass)._1.foreach { res => errorBuffer ++= res.errors }
         val (errors, args) = evalArgs(argss.flatten, thisV, klass)
         errorBuffer ++= errors
         superCall(tref, ctor, args, tree, tasks)

tests/init/neg/local-warm.check

@@ -0,0 +1,11 @@
+-- Error: tests/init/neg/local-warm4.scala:18:20 -----------------------------------------------------------------------
+18 |                a = newA // error
+   |                    ^^^^
+   |Promote the value under initialization to fully-initialized. May only assign fully initialized value. Calling trace:
+   | -> val a = new A(5)	[ local-warm4.scala:26 ]
+   |    -> class A(x: Int) extends Foo(x) {	[ local-warm4.scala:6 ]
+   |     -> val b = new B(y)	[ local-warm4.scala:10 ]
+   |        -> class B(x: Int) extends A(x) {	[ local-warm4.scala:13 ]
+   |          -> class A(x: Int) extends Foo(x) {	[ local-warm4.scala:6 ]
+   |           -> increment()	[ local-warm4.scala:9 ]
+   |            -> updateA()	[ local-warm4.scala:21 ]

tests/init/neg/local-warm4.check

@@ -0,0 +1,31 @@
+object localWarm {
+    abstract class Foo(x: Int) {
+        def increment(): Unit
+    }
+
+    class A(x: Int) extends Foo(x) {
+        var y = x
+        override def increment(): Unit = y = y + 1
+        increment()
+        val b = new B(y)
+    }
+
+    class B(x: Int) extends A(x) {
+        var a: A = this
+        override def increment(): Unit = {
+            def updateA(): Unit = {
+                val newA = new A(y)
+                a = newA // error
+            }
+            y = y + 1
+            updateA()
+        }
+        if y < 10 then increment()
+        val z = b.y
+    }
+    val a = new A(5)
+}
+
+
+
+

tests/init/neg/local-warm4.scala

@@ -0,0 +1,14 @@
+class A {
+    var v = 5
+    val x = {
+        class B {
+            def doubleAndReturnV(): Int = {
+                v = v * 2
+                v
+            }
+        }
+        val b = new B
+        b.doubleAndReturnV()
+    }
+    val y = v
+}

tests/init/neg/local-warm.scala renamed to tests/init/pos/local-warm.scala

@@ -0,0 +1,10 @@
+class A() {
+    var x = 5
+    def decreaseX(): Unit = {
+        val self = this
+        self.x -= 1
+    }
+    def decreaseXToZero(): Unit = if x > 0 then decreaseX()
+    decreaseXToZero()
+    val y = x
+}

tests/init/pos/local-warm2.scala

@@ -0,0 +1,12 @@
+object leakWarm5 {
+    case class A(x: Int) {
+        def double(): A = {
+            class C {
+                def double(): A = if x < 10 then A(x * 2).double() else A.this
+            }
+            val c = new C
+            c.double()
+        }
+    }
+    val a = A(2).double()
+}