Change tests to new syntax

Fix recognition of uniniialized if type of var is a context function.
This required a special case in typedValDef for `var x: A ?=> B = _`.
Now it requires a special case in `PruneErasedDefs` in `var x: A ?=> B = undefined`.

Author: odersky

bench/tests/Vector.scala

@@ -14,6 +14,7 @@ import scala.annotation.unchecked.uncheckedVariance
 import scala.compat.Platform
 import scala.collection.generic._
 import scala.collection.mutable.Builder
+import compiletime.uninitialized
 
 /** Companion object to the Vector class
  */
@@ -741,13 +742,13 @@ final class VectorBuilder[A]() extends Builder[A,Vector[A]] with VectorPointer[A
 
 
 private[immutable] trait VectorPointer[T] {
-  private[immutable] var depth: Int = _
-  private[immutable] var display0: Array[AnyRef] = _
-  private[immutable] var display1: Array[AnyRef] = _
-  private[immutable] var display2: Array[AnyRef] = _
-  private[immutable] var display3: Array[AnyRef] = _
-  private[immutable] var display4: Array[AnyRef] = _
-  private[immutable] var display5: Array[AnyRef] = _
+  private[immutable] var depth: Int = uninitialized
+  private[immutable] var display0: Array[AnyRef] = uninitialized
+  private[immutable] var display1: Array[AnyRef] = uninitialized
+  private[immutable] var display2: Array[AnyRef] = uninitialized
+  private[immutable] var display3: Array[AnyRef] = uninitialized
+  private[immutable] var display4: Array[AnyRef] = uninitialized
+  private[immutable] var display5: Array[AnyRef] = uninitialized
 
   // used
   private[immutable] final def initFrom[U](that: VectorPointer[U]): Unit = initFrom(that, that.depth)

compiler/src/dotty/tools/dotc/transform/PruneErasedDefs.scala

@@ -43,17 +43,25 @@ class PruneErasedDefs extends MiniPhase with SymTransformer { thisTransform =>
       cpy.Apply(tree)(tree.fun, tree.args.map(trivialErasedTree))
     else tree
 
+  private def hasUninitializedRHS(tree: ValOrDefDef)(using Context): Boolean =
+    def recur(rhs: Tree): Boolean = rhs match
+      case rhs: RefTree =>
+        rhs.symbol == defn.Compiletime_uninitialized
+        && tree.symbol.is(Mutable) && tree.symbol.owner.isClass
+      case closureDef(ddef) if defn.isContextFunctionType(tree.tpt.tpe.dealias) =>
+        recur(ddef.rhs)
+      case _ =>
+        false
+    recur(tree.rhs)
+
   override def transformValDef(tree: ValDef)(using Context): Tree =
     val sym = tree.symbol
-    if sym.isEffectivelyErased && !tree.rhs.isEmpty then
+    if tree.symbol.isEffectivelyErased && !tree.rhs.isEmpty then
       cpy.ValDef(tree)(rhs = trivialErasedTree(tree))
-    else tree.rhs match
-      case rhs: RefTree
-      if rhs.symbol == defn.Compiletime_uninitialized
-         && sym.is(Mutable) && sym.owner.isClass =>
-        cpy.ValDef(tree)(rhs = cpy.Ident(rhs)(nme.WILDCARD))
-      case _ =>
-        tree
+    else if hasUninitializedRHS(tree) then
+      cpy.ValDef(tree)(rhs = cpy.Ident(tree.rhs)(nme.WILDCARD).withType(tree.tpt.tpe))
+    else
+      tree
 
   override def transformDefDef(tree: DefDef)(using Context): Tree =
     if (tree.symbol.isEffectivelyErased && !tree.rhs.isEmpty)

tests/fuzzy/471d33abf565d5dd3691679237f148638f4ff115.scala

@@ -24,7 +24,7 @@ def i10(i2: i4): i3 = new i4(i5)
 object i10 {
 def main(i12: Array[String]): Unit = {
 val i10: Array[String] = null
-var i2 = _
+var i2 = compiletime.uninitialized
 def i3(i2: Int) = i2
 }
 object i0 {

tests/init/crash/i2468.scala

@@ -1,8 +1,9 @@
 
+import compiletime.uninitialized
 object Test {
 
   class A {
-    private[this] var x: String = _
+    private[this] var x: String = uninitialized
   }
 
   class B {
@@ -11,16 +12,16 @@ object Test {
   }
 
   class C {
-    private[this] var x1: Int = _
-    private[this] var x2: Unit = _
-    private[this] var x3: Char = _
-    private[this] var x4: Boolean = _
-    private[this] var x5: Float = _
-    private[this] var x6: Double = _
-    private[this] var x7: Char = _
-    private[this] var x8: Byte = _
-    private[this] var x9: AnyVal = _
-    private[this] var x10: D = _
+    private[this] var x1: Int = uninitialized
+    private[this] var x2: Unit = uninitialized
+    private[this] var x3: Char = uninitialized
+    private[this] var x4: Boolean = uninitialized
+    private[this] var x5: Float = uninitialized
+    private[this] var x6: Double = uninitialized
+    private[this] var x7: Char = uninitialized
+    private[this] var x8: Byte = uninitialized
+    private[this] var x9: AnyVal = uninitialized
+    private[this] var x10: D = uninitialized
   }
 
   class D(x: Int) extends AnyVal

tests/init/crash/opassign.scala

@@ -12,7 +12,7 @@ object opassign {
   }
 
   class Ref {
-    var x: Int = _
+    var x: Int = compiletime.uninitialized
   }
   val r = new Ref
   r.x += 1

tests/neg/i11225.check

@@ -10,10 +10,6 @@
 6 |  var x2: Int = if ??? then uninitialized else uninitialized // error // error
   |                                               ^^^^^^^^^^^^^
   |                             `uninitialized` can only be used as the right hand side of a mutable field definition
--- Error: tests/neg/i11225.scala:7:29 ----------------------------------------------------------------------------------
-7 |  var x3: Int = if true then uninitialized else 1 // error
-  |                             ^^^^^^^^^^^^^
-  |                             `uninitialized` can only be used as the right hand side of a mutable field definition
 -- Error: tests/neg/i11225.scala:9:28 ----------------------------------------------------------------------------------
 9 |  var x5: () => Int = () => uninitialized // error
   |                            ^^^^^^^^^^^^^

tests/neg/i11225.scala

@@ -4,8 +4,8 @@ class Test:
 
   val x1: Int = uninitialized // error
   var x2: Int = if ??? then uninitialized else uninitialized // error // error
-  var x3: Int = if true then uninitialized else 1 // error
-  var x4: Int = if false then uninitialized else 1 // ok, since inlined away
+  var x3: Int = if true then uninitialized else 1 // ok
+  var x4: Int = if false then uninitialized else 1 // ok
   var x5: () => Int = () => uninitialized // error
   var x6: Int = { uninitialized } // error
 

tests/neg/i8427.scala

@@ -2,6 +2,6 @@
 trait T
 
 object Test {
-  var t: T = _
+  var t: T = compiletime.uninitialized
   def main(args: Array[String]) = println("hi")
 }

tests/neg/refinedSubtyping.scala

@@ -13,7 +13,7 @@ class Test3 {
   type U1 = C { type T <: B }
   type U2 = C { type T <: A }
 
-  var x: T2 = _
+  var x: T2 = compiletime.uninitialized
   val y1: U1 = ???
   val y2: U2 = ???
 

tests/neg/t11437.scala

@@ -1,6 +1,6 @@
 
 class Regress {
-  var v: Int = _
+  var v: Int = compiletime.uninitialized
   def f = 42
   var w: Int = (_)    // error: not default value syntax
 }