Update tests

Fixing inherit-non-hot.check

Author: EnzeXing

tests/init/neg/Desugar.check

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

tests/init/neg/InteractiveDriver.check

@@ -1,8 +1,8 @@
 -- Error: tests/init/neg/cycle-structure.scala:3:14 --------------------------------------------------------------------
 3 |    val x = B(this) // error
   |              ^^^^
-  |         Promote the value under initialization to fully-initialized. May only use initialized value as arguments.
+  |              Cannot prove that the value is fully initialized. May only use initialized value as arguments.
 -- Error: tests/init/neg/cycle-structure.scala:9:14 --------------------------------------------------------------------
 9 |    val x = A(this) // error
   |              ^^^^
-  |         Promote the value under initialization to fully-initialized. May only use initialized value as arguments.
+  |              Cannot prove that the value is fully initialized. May only use initialized value as arguments.

tests/init/neg/closureLeak.check

@@ -1,5 +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 ]
+  |     Cannot prove that the value is fully initialized. May only use initialized value as arguments. Calling trace:
+  |      -> val result = updateThenCompare(5)	[ default-this.scala:11 ]

tests/init/neg/cycle-structure.check

@@ -0,0 +1,16 @@
+-- Error: tests/init/neg/inherit-non-hot.scala:6:34 --------------------------------------------------------------------
+6 |            if b == null then b = new B(this) // error
+  |                                  ^^^^^^^^^^^
+  |                        Cannot prove that the value is fully-initialized. May only assign fully initialized value.
+  |                         Calling trace:
+  |                         -> val c = new C	[ inherit-non-hot.scala:19 ]
+  |                            -> class C extends A {	[ inherit-non-hot.scala:15 ]
+  |                             -> val bAgain = toB.getBAgain	[ inherit-non-hot.scala:16 ]
+  |
+  |                        The unsafe promotion may cause the following problem:
+  |                        Call method Foo.B.this.aCopy.toB on a value with an unknown initialization. Calling trace:
+  |                         -> val c = new C	[ inherit-non-hot.scala:19 ]
+  |                            -> class C extends A {	[ inherit-non-hot.scala:15 ]
+  |                             -> val bAgain = toB.getBAgain	[ inherit-non-hot.scala:16 ]
+  |                              -> if b == null then b = new B(this) // error	[ inherit-non-hot.scala:6 ]
+  |                               -> def getBAgain: B = aCopy.toB	[ inherit-non-hot.scala:12 ]

tests/init/neg/default-this.check

@@ -0,0 +1,21 @@
+// This is a minimized test for the warning in Names.scala:174
+object Foo {
+    abstract class A {
+        var b: B = null
+        def toB: B =
+            if b == null then b = new B(this) // error
+            b
+    }
+
+    class B(a: A) {
+        var aCopy: A = a
+        def getBAgain: B = aCopy.toB
+    }
+
+    class C extends A {
+        val bAgain = toB.getBAgain
+    }
+
+    val c = new C
+    assert(c.b == c.bAgain)
+}

tests/init/neg/inherit-non-hot.check

@@ -1,8 +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.
+   |           Cannot prove that the value is 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.
+   |           Cannot prove that the value is fully initialized. May only use initialized value as method arguments.

tests/init/neg/inherit-non-hot.scala

@@ -1,11 +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 ]
+   |       Cannot prove that the value is 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/leak-warm.check

@@ -25,7 +25,3 @@ object localWarm {
     }
     val a = new A(5)
 }
-
-
-
-

tests/init/neg/local-warm4.check

@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/promotion-loop.scala:16:10 --------------------------------------------------------------------
 16 |  println(b)      // error
    |          ^
-   |       Cannot prove that the value is fully-initialized. May only use initialized value as arguments.
+   |          Cannot prove that the value is fully-initialized. May only use initialized value as arguments.
    |
-   |       The unsafe promotion may cause the following problem:
-   |       Promote the value under initialization to fully-initialized. May only use initialized value as arguments.
+   |          The unsafe promotion may cause the following problem:
+   |          Cannot prove that the value is fully initialized. May only use initialized value as arguments.

tests/init/neg/local-warm4.scala

@@ -6,8 +6,8 @@ class A(b: B, x: Int) {
     }
     Inner().foo()
 
-    val f = () => new A(b, 3) // error: Cannot promote
-    f() // ok
+    val f = () => new A(b, 3)
+    f()
   }
 }
 

tests/init/neg/promotion-loop.check

@@ -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} // error
+    val f: PartialFunction[A, Int] = {case C(_, rhs) => rhs.x}
 }
 
 

tests/init/neg/secondary-ctor2.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) } // error
+    val l2: Seq[C[?]] = l.collect{ case x: InteractiveDriver[?] => h(x) }
 }