Merge pull request #11231 from dotty-staging/fix-11225

Use `unitialized` for wildcard initializers

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/core/Definitions.scala

@@ -226,8 +226,9 @@ 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_uninitialized: Symbol = CompiletimePackageObject.requiredMethod("uninitialized")
     @tu lazy val Compiletime_error        : Symbol = CompiletimePackageObject.requiredMethod(nme.error)
-    @tu lazy val Compiletime_requireConst: Symbol = CompiletimePackageObject.requiredMethod("requireConst")
+    @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")

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3201,7 +3201,8 @@ object Parsers {
 
     /** PatDef  ::=  ids [‘:’ Type] ‘=’ Expr
      *            |  Pattern2 [‘:’ Type] ‘=’ Expr
-     *  VarDef  ::=  PatDef | id {`,' id} `:' Type `=' `_'
+     *  VarDef  ::=  PatDef
+     *            | id {`,' id} `:' Type `=' `_' (deprecated in 3.1)
      *  ValDcl  ::=  id {`,' id} `:' Type
      *  VarDcl  ::=  id {`,' id} `:' Type
      */
@@ -3224,9 +3225,14 @@ object Parsers {
       val rhs =
         if tpt.isEmpty || in.token == EQUALS then
           accept(EQUALS)
+          val rhsOffset = in.offset
           subExpr() match
             case rhs0 @ Ident(name) if placeholderParams.nonEmpty && name == placeholderParams.head.name
                 && !tpt.isEmpty && mods.is(Mutable) && lhs.forall(_.isInstanceOf[Ident]) =>
+              if sourceVersion.isAtLeast(`3.1`) then
+                deprecationWarning(
+                  em"""`= _` has been deprecated; use `= uninitialized` instead.
+                      |`uninitialized` can be imported with `scala.compiletime.uninitialized`.""", rhsOffset)
               placeholderParams = placeholderParams.tail
               atSpan(rhs0.span) { Ident(nme.WILDCARD) }
             case rhs0 => rhs0

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.uninitialized` 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._
@@ -38,10 +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 =
-    if (tree.symbol.isEffectivelyErased && !tree.rhs.isEmpty)
+    val sym = tree.symbol
+    if tree.symbol.isEffectivelyErased && !tree.rhs.isEmpty then
       cpy.ValDef(tree)(rhs = trivialErasedTree(tree))
-    else 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)

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -119,7 +119,7 @@ class CompilationTests {
     aggregateTests(
       compileFilesInDir("tests/neg", defaultOptions),
       compileFilesInDir("tests/neg-tailcall", defaultOptions),
-      compileFilesInDir("tests/neg-strict", defaultOptions.and("-source", "3.1", "-Xfatal-warnings")),
+      compileFilesInDir("tests/neg-strict", defaultOptions.and("-source", "3.1", "-deprecation", "-Xfatal-warnings")),
       compileFilesInDir("tests/neg-no-kind-polymorphism", defaultOptions and "-Yno-kind-polymorphism"),
       compileFilesInDir("tests/neg-custom-args/deprecation", defaultOptions.and("-Xfatal-warnings", "-deprecation")),
       compileFilesInDir("tests/neg-custom-args/fatal-warnings", defaultOptions.and("-Xfatal-warnings")),

docs/docs/internals/syntax.md

@@ -384,14 +384,12 @@ TypeDcl           ::=  id [TypeParamClause] {FunParamClause} TypeBounds
                        [‘=’ Type]
 
 Def               ::=  ‘val’ PatDef
-                    |  ‘var’ VarDef
+                    |  ‘var’ PatDef
                     |  ‘def’ DefDef
                     |  ‘type’ {nl} TypeDcl
                     |  TmplDef
 PatDef            ::=  ids [‘:’ Type] ‘=’ Expr
-                    |  Pattern2 [‘:’ Type] ‘=’ Expr                            PatDef(_, pats, tpe?, expr)
-VarDef            ::=  PatDef
-                    |  ids ‘:’ Type ‘=’ ‘_’
+                    |  Pattern2 [‘:’ Type] ‘=’ Expr                             PatDef(_, pats, tpe?, expr)
 DefDef            ::=  DefSig [‘:’ Type] ‘=’ Expr                               DefDef(_, name, tparams, vparamss, tpe, expr)
                     |  ‘this’ DefParamClause DefParamClauses ‘=’ ConstrExpr     DefDef(_, <init>, Nil, vparamss, EmptyTree, expr | Block)
 

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 `uninitialized` in the `scala.compiletime` package. To get an uninitialized field, you now write
+```scala
+import scala.compiletime.uninitialized
+
+var x: A = uninitialized
+```
+To enable cross-compilation, `_` is still supported, but it will be dropped in a future 3.x version.
+

docs/docs/reference/syntax.md

@@ -374,14 +374,12 @@ DefSig            ::=  id [DefTypeParamClause] DefParamClauses
 TypeDcl           ::=  id [TypeParamClause] {FunParamClause} TypeBounds [‘=’ Type]
 
 Def               ::=  ‘val’ PatDef
-                    |  ‘var’ VarDef
+                    |  ‘var’ PatDef
                     |  ‘def’ DefDef
                     |  ‘type’ {nl} TypeDcl
                     |  TmplDef
 PatDef            ::=  ids [‘:’ Type] ‘=’ Expr
                     |  Pattern2 [‘:’ Type] ‘=’ Expr
-VarDef            ::=  PatDef
-                    |  ids ‘:’ Type ‘=’ ‘_’
 DefDef            ::=  DefSig [‘:’ Type] ‘=’ Expr
                     |  ‘this’ DefParamClause DefParamClauses ‘=’ ConstrExpr
 

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,5 @@
 package scala
-
-import scala.quoted._
+import annotation.compileTimeOnly
 
 package object compiletime {
 
@@ -18,6 +17,17 @@ package object compiletime {
    */
   erased def erasedValue[T]: T = ???
 
+  /** Used as the initializer of a mutable class or object field, like this:
+   *
+   *    var x: T = uninitialized
+   *
+   *  This signifies that the field is not initialized on its own. It is still initialized
+   *  as part of the bulk initialization of the object it belongs to, which assigns zero
+   *  values such as `null`, `0`, `0.0`, `false` to all object fields.
+   */
+  @compileTimeOnly("`uninitialized` can only be used as the right hand side of a mutable field definition")
+  def uninitialized: Nothing = ???
+
   /** 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.
    *