Update Desugar.scala

Update InteractiveDriver.scala

Update closureLeak.scala

Update default-this.scala

Update enum.scala

Update leak-this-inner.scala

Update leak-this.scala

Update leak-warm.scala

Update local-warm.scala

updated test cases

updated-default-this

updated tests

Author: EnzeXing

tests/init/neg/Desugar.check

@@ -0,0 +1,5 @@
+-- Error: tests/init/neg/Desugar.scala:12:61 ---------------------------------------------------------------------------
+12 |    val f: PartialFunction[A, Int] = {case C(_, rhs) => rhs.x} // error
+   |                                                             ^
+   |                   Calling the external method constructor $anon may cause initialization errors. Calling trace:
+   |                    -> val f: PartialFunction[A, Int] = {case C(_, rhs) => rhs.x} // error	[ Desugar.scala:12 ]

tests/init/neg/Desugar.scala

@@ -9,7 +9,7 @@ case class C[-T >: Int] (lhs: Int, rhs: Tree[T]) extends A {
 }
 
 object DesugarError {
-    val f: PartialFunction[A, Int] = {case C(_, rhs) => rhs.x}
+    val f: PartialFunction[A, Int] = {case C(_, rhs) => rhs.x} // error
 }
 
 

tests/init/neg/InteractiveDriver.check

@@ -0,0 +1,5 @@
+-- Error: tests/init/neg/InteractiveDriver.scala:22:71 -----------------------------------------------------------------
+22 |    val l2: Seq[C[?]] = l.collect{ case x: InteractiveDriver[?] => h(x) } // error
+   |                                                                       ^
+   |Calling the external method constructor $anon may cause initialization errors. Calling trace:
+   | -> val l2: Seq[C[?]] = l.collect{ case x: InteractiveDriver[?] => h(x) } // error	[ InteractiveDriver.scala:22 ]

tests/init/neg/InteractiveDriver.scala

@@ -19,5 +19,5 @@ object InteractiveDriver {
         case _ => new C[Int]
     }
     val l: Seq[Any] = Seq(1, 2, new C[Double], new D[Int])
-    val l2: Seq[C[?]] = l.collect{ case x: InteractiveDriver[?] => h(x) }
+    val l2: Seq[C[?]] = l.collect{ case x: InteractiveDriver[?] => h(x) } // error
 }

tests/init/neg/closureLeak.check

@@ -0,0 +1,8 @@
+-- Error: tests/init/neg/closureLeak.scala:11:14 -----------------------------------------------------------------------
+11 |    l.foreach(a => a.addX(this)) // error
+   |              ^^^^^^^^^^^^^^^^^
+   |     Promoting the value to fully-initialized is unsafe. May only use initialized value as arguments
+   |
+   |     The unsafe promotion may cause the following problem(s):
+   |
+   |     1. Promote the value under initialization to fully-initialized. May only use initialized value as arguments

tests/init/neg/closureLeak.scala

@@ -8,5 +8,6 @@ class Outer {
     }
 
     val l: List[A] = List(new A(5), new A(10))
-    l.foreach(a => a.addX(this))
+    l.foreach(a => a.addX(this)) // error
+    val y = 10
 }

tests/init/neg/default-this.check

@@ -0,0 +1,5 @@
+-- Error: tests/init/neg/default-this.scala:9:8 ------------------------------------------------------------------------
+9 |        compare() // error
+  |        ^^^^^^^
+  |Promote the value under initialization to fully-initialized. May only use initialized value as arguments Calling trace:
+  | -> val result = updateThenCompare(5)	[ default-this.scala:11 ]

tests/init/neg/default-this.scala

@@ -6,7 +6,7 @@ class A {
 class B extends A {
     def updateThenCompare(c: Int): Boolean = {
         x = c
-        compare()
+        compare() // error
     }
     val result = updateThenCompare(5)
 }

tests/init/neg/enum.check

@@ -0,0 +1,9 @@
+-- Error: tests/init/neg/enum.scala:4:8 --------------------------------------------------------------------------------
+4 |        NoExplanationID // error
+  |        ^
+  |        Promoting the value to fully-initialized is unsafe. May only use initialized value as method arguments
+  |
+  |        The unsafe promotion may cause the following problem(s):
+  |
+  |        1. Calling the external method method name may cause initialization errors. Calling trace:
+  |         -> NoExplanationID // error	[ enum.scala:4 ]

tests/init/neg/enum.scala

@@ -1,6 +1,6 @@
 enum ErrorMessageID extends java.lang.Enum[ErrorMessageID] {
     case
-        LazyErrorId, // // errorNumber: -2
-        NoExplanationID
+        LazyErrorId,
+        NoExplanationID // error
     def errorNumber = ordinal - 2
 }

tests/init/neg/leak-this-inner.check

@@ -0,0 +1,4 @@
+-- Error: tests/init/neg/leak-this-inner.scala:6:14 --------------------------------------------------------------------
+6 |    val b = B(this) // error
+  |              ^^^^
+  |          Promote the value under initialization to fully-initialized. May only use initialized value as arguments

tests/init/neg/leak-this-inner.scala

@@ -3,6 +3,6 @@ class A {
     class B(a: A) {
         val anotherX = A.this.x
     }
-    val b = B(this)
+    val b = B(this) // error
     val xAgain = b.anotherX
 }

tests/init/neg/leak-this.check

@@ -0,0 +1,4 @@
+-- Error: tests/init/neg/leak-this.scala:2:33 --------------------------------------------------------------------------
+2 |    val child: Child = new Child(this) // error
+  |                                 ^^^^
+  |          Promote the value under initialization to fully-initialized. May only use initialized value as arguments

tests/init/neg/leak-this.scala

@@ -1,5 +1,5 @@
 class Parent {
-    val child: Child = new Child(this)
+    val child: Child = new Child(this) // error
 }
 
 class Child(parent: Parent) {

tests/init/neg/leak-warm.check

@@ -0,0 +1,8 @@
+-- Error: tests/init/neg/leak-warm.scala:18:26 -------------------------------------------------------------------------
+18 |    val l: List[A] = List(c, d) // error // error
+   |                          ^
+   | Promote the value under initialization to fully-initialized. May only use initialized value as method arguments
+-- Error: tests/init/neg/leak-warm.scala:18:29 -------------------------------------------------------------------------
+18 |    val l: List[A] = List(c, d) // error // error
+   |                             ^
+   | Promote the value under initialization to fully-initialized. May only use initialized value as method arguments

tests/init/neg/leak-warm.scala

@@ -15,6 +15,6 @@ object leakWarm {
     }
     val c = new C(1, 2)
     val d = new D(3, 4)
-    val l: List[A] = List(c, d)
+    val l: List[A] = List(c, d) // error // error
     val l2 = l.map(_.m())
 }

tests/init/neg/local-warm.check

@@ -0,0 +1,5 @@
+-- Error: tests/init/neg/local-warm.scala:12:12 ------------------------------------------------------------------------
+12 |        val t = m1() // error
+   |        ^^^^^^^^^^^^
+   |Promote the value under initialization to fully-initialized. Local definitions may only hold initialized values Calling trace:
+   | -> val x = g()	[ local-warm.scala:15 ]

tests/init/neg/local-warm.scala

@@ -9,7 +9,7 @@ abstract class A {
 
 class C extends A {
     def g() = {
-        val t = m1()
+        val t = m1() // error
         t.x
     }
     val x = g()