Use notInitialized for wildcard initializers

Fixes scala#11225

Author: odersky

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -225,12 +225,13 @@ class Definitions {
 
   @tu lazy val CompiletimePackageObject: Symbol = requiredModule("scala.compiletime.package")
     @tu lazy val Compiletime_codeOf: Symbol = CompiletimePackageObject.requiredMethod("codeOf")
-    @tu lazy val Compiletime_erasedValue  : Symbol = CompiletimePackageObject.requiredMethod("erasedValue")
-    @tu lazy val Compiletime_error        : Symbol = CompiletimePackageObject.requiredMethod(nme.error)
-    @tu lazy val Compiletime_requireConst: Symbol = CompiletimePackageObject.requiredMethod("requireConst")
-    @tu lazy val Compiletime_constValue   : Symbol = CompiletimePackageObject.requiredMethod("constValue")
-    @tu lazy val Compiletime_constValueOpt: Symbol = CompiletimePackageObject.requiredMethod("constValueOpt")
-    @tu lazy val Compiletime_summonFrom   : Symbol = CompiletimePackageObject.requiredMethod("summonFrom")
+    @tu lazy val Compiletime_erasedValue   : Symbol = CompiletimePackageObject.requiredMethod("erasedValue")
+    @tu lazy val Compiletime_notInitialized: Symbol = CompiletimePackageObject.requiredMethod("notInitialized")
+    @tu lazy val Compiletime_error         : Symbol = CompiletimePackageObject.requiredMethod(nme.error)
+    @tu lazy val Compiletime_requireConst  : Symbol = CompiletimePackageObject.requiredMethod("requireConst")
+    @tu lazy val Compiletime_constValue    : Symbol = CompiletimePackageObject.requiredMethod("constValue")
+    @tu lazy val Compiletime_constValueOpt : Symbol = CompiletimePackageObject.requiredMethod("constValueOpt")
+    @tu lazy val Compiletime_summonFrom    : Symbol = CompiletimePackageObject.requiredMethod("summonFrom")
   @tu lazy val CompiletimeTestingPackage: Symbol = requiredPackage("scala.compiletime.testing")
     @tu lazy val CompiletimeTesting_typeChecks: Symbol = CompiletimeTestingPackage.requiredMethod("typeChecks")
     @tu lazy val CompiletimeTesting_typeCheckErrors: Symbol = CompiletimeTestingPackage.requiredMethod("typeCheckErrors")

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

@@ -10,6 +10,7 @@ import Symbols._
 import Types._
 import typer.RefChecks
 import MegaPhase.MiniPhase
+import StdNames.nme
 import ast.tpd
 
 /** This phase makes all erased term members of classes private so that they cannot
@@ -18,6 +19,10 @@ import ast.tpd
  *  The phase also replaces all expressions that appear in an erased context by
  *  default values. This is necessary so that subsequent checking phases such
  *  as IsInstanceOfChecker don't give false negatives.
+ *  Finally, the phase replaces `compiletime.notInitialized` on the right hand side
+ *  of a mutable field definition by `_`. This avoids a "is declared erased, but is
+ *  in fact used" error in Erasure and communicates to Constructors that the
+ *  variable does not have an initializer.
  */
 class PruneErasedDefs extends MiniPhase with SymTransformer { thisTransform =>
   import tpd._
@@ -39,9 +44,16 @@ class PruneErasedDefs extends MiniPhase with SymTransformer { thisTransform =>
     else tree
 
   override def transformValDef(tree: ValDef)(using Context): Tree =
-    if (tree.symbol.isEffectivelyErased && !tree.rhs.isEmpty)
+    val sym = tree.symbol
+    if sym.isEffectivelyErased && !tree.rhs.isEmpty then
       cpy.ValDef(tree)(rhs = trivialErasedTree(tree))
-    else tree
+    else tree.rhs match
+      case rhs: TypeApply
+      if rhs.symbol == defn.Compiletime_notInitialized
+         && sym.is(Mutable) && sym.owner.isClass =>
+        cpy.ValDef(tree)(rhs = cpy.Ident(rhs)(nme.WILDCARD))
+      case _ =>
+        tree
 
   override def transformDefDef(tree: DefDef)(using Context): Tree =
     if (tree.symbol.isEffectivelyErased && !tree.rhs.isEmpty)

docs/docs/reference/dropped-features/wildcard-init.md

@@ -0,0 +1,18 @@
+---
+layout: doc-page
+title: "Dropped: wildcard initializer"
+---
+
+The syntax
+```scala
+  var x: A = _
+```
+that was used to indicate an uninitialized field has been dropped.
+At its place there is a special value `notInitialized` in the `scala.compiletime` package. To get an uninitialized field, you now write
+```scala
+import scala.compiletime.notInitialized
+
+var x: A = notInitialized
+```
+To enable cross-compilation, `_` is still supported, but it will be dropped in a future 3.x version.
+

docs/sidebar.yml

@@ -189,6 +189,8 @@ sidebar:
               url: docs/reference/dropped-features/nonlocal-returns.html
             - title: "[this] Qualifier"
               url: docs/reference/dropped-features/this-qualifier.html
+            - title: Wildcard initializers
+              url: docs/reference/dropped-features/wildcard-init.html
         - title: Syntax Summary
           url: docs/reference/syntax.html
     - title: Contributing

library/src/scala/compiletime/package.scala

@@ -1,6 +1,6 @@
 package scala
 
-import scala.quoted._
+import scala.quoted
 
 package object compiletime {
 
@@ -18,6 +18,15 @@ package object compiletime {
    */
   erased def erasedValue[T]: T = ???
 
+  /** Used as the initializer of a class or object field, like this:
+   *
+   *    val x: T = notInitialized
+   *
+   *  This signifies that the field is not initialized by its own (On the JVM
+   *  it is still bulk-initialized to a zero bitfield).
+   */
+  erased def notInitialized[T]: T = ???
+
   /** The error method is used to produce user-defined compile errors during inline expansion.
    *  If an inline expansion results in a call error(msgStr) the compiler produces an error message containing the given msgStr.
    *

tests/neg/i11225.scala

@@ -0,0 +1,5 @@
+import compiletime.notInitialized
+
+@main def Test(x: Boolean) =
+  var cached: Int = notInitialized   // error
+  cached = if x then 1 else notInitialized  // error

tests/pos/i11225.scala

@@ -0,0 +1,12 @@
+import compiletime.notInitialized
+
+class Memo[A](x: => A):
+  private var cached1: A = notInitialized
+  private var cached: A = notInitialized
+  private var known: Boolean = false
+  def force =
+    if !known then
+      known = true
+      cached = x
+      val y = cached1
+    cached