Use ? for wildcards

Still missing: Use `*` as a placeholder parameter under -Ykind-projector

Author: odersky

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -125,6 +125,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val YshowSuppressedErrors: Setting[Boolean] = BooleanSetting("-Yshow-suppressed-errors", "Also show follow-on errors and warnings that are normally suppressed.")
   val YdetailedStats: Setting[Boolean] = BooleanSetting("-Ydetailed-stats", "show detailed internal compiler stats (needs Stats.enabled to be set to true).")
   val Yheartbeat: Setting[Boolean] = BooleanSetting("-Yheartbeat", "show heartbeat stack trace of compiler operations (needs Stats.enabled to be set to true).")
+  val YkindProjector: Setting[Boolean] = BooleanSetting("-Ykind-projector", "allow `*` as wildcard to be compatible with kind projector")
   val YprintPos: Setting[Boolean] = BooleanSetting("-Yprint-pos", "show tree positions.")
   val YprintPosSyms: Setting[Boolean] = BooleanSetting("-Yprint-pos-syms", "show symbol definitions positions.")
   val YnoDeepSubtypes: Setting[Boolean] = BooleanSetting("-Yno-deep-subtypes", "throw an exception on deep subtyping call stacks.")

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

@@ -315,6 +315,8 @@ object StdNames {
     val _21 : N = "_21"
     val _22 : N = "_22"
 
+    val * : N   = "*"
+    val ? : N   = "?"
     val ??? : N = "???"
 
     val genericWrapArray: N     = "genericWrapArray"

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

@@ -1069,9 +1069,21 @@ object Parsers {
         SingletonTypeTree(literal(negOffset = start))
       }
       else if (in.token == USCORE) {
+        if (ctx.settings.strict.value) {
+          deprecationWarning(em"`_` is deprecated for wildcard arguments of types: use `?` instead")
+          patch(source, Span(in.offset, in.offset + 1), "?")
+        }
         val start = in.skipToken()
         typeBounds().withSpan(Span(start, in.lastOffset, start))
       }
+      else if (isIdent(nme.?)) {
+        val start = in.skipToken()
+        typeBounds().withSpan(Span(start, in.lastOffset, start))
+      }
+      else if (isIdent(nme.*) && ctx.settings.YkindProjector.value) {
+      	syntaxError("`*` placeholders are not implemented yet")
+        typeIdent()
+      }
       else if (isSplice)
         splice(isType = true)
       else path(thisOK = false, handleSingletonType) match {

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

@@ -181,7 +181,8 @@ class CompilationTests extends ParallelTesting {
         defaultOptions),
       compileFile("tests/neg-custom-args/i6300.scala", allowDeepSubtypes),
       compileFile("tests/neg-custom-args/infix.scala", defaultOptions.and("-strict", "-deprecation", "-Xfatal-warnings")),
-      compileFile("tests/neg-custom-args/missing-alpha.scala", defaultOptions.and("-strict", "-deprecation", "-Xfatal-warnings"))
+      compileFile("tests/neg-custom-args/missing-alpha.scala", defaultOptions.and("-strict", "-deprecation", "-Xfatal-warnings")),
+      compileFile("tests/neg-custom-args/wildcards.scala", defaultOptions.and("-strict", "-deprecation", "-Xfatal-warnings"))
     ).checkExpectedErrors()
   }
 

docs/docs/reference/changed-features/wildcards.md

@@ -0,0 +1,43 @@
+---
+layout: doc-page
+title: Wildcard Arguments in Types
+---
+
+The syntax of wildcard arguments in types has changed from `_` to `?`. Example:
+```scala
+List[?]
+Map[? <: AnyRef, ? >: Null]
+```
+
+### Motivation
+
+We would like to use the underscore syntax `_` to stand for an anonymous type parameter, aligning it with its meaning in
+value parameter lists. So, just as `f(_)` is a shorthand for the lambda `x => f(x)`, in the future `C[_]` will be a shorthand
+for the type lambda `[X] =>> C[X]`. This makes higher-kinded types easier to use. It also removes the wart that, used as a type
+parameter, `F[_]` means `F` is a type constructor whereas used as a type, `F[_]` means it is a wildcard (i.e. existential) type.
+In the future, `F[_]` will mean the same thing, no matter where it is used.
+
+We pick `?` as a replacement syntax for wildcard types, since it aligns with Java's syntax.
+
+### Migration Strategy
+
+The migration to the new scheme is complicated, in particular since the [kind projector](https://github.com/typelevel/kind-projector])
+compiler plugin still uses the reverse convention, with `?` meaning parameter placeholder instead of wildcard. Fortunately, kind projector has added `*` as an alternative syntax for `?`.
+
+A step-by-step migration is made possible with the following measures:
+
+ 1. In Scala 3.0, both `_` and `?` are legal names for wildcards.
+ 2. In Scala 3.1, `_` is deprecated in favor of `?` as a name for a wildcard. A `-rewrite` option is
+    available to rewrite one to the other.
+ 3. In Scala 3.2, the meaning of `_` changes from wildcard to placeholder for type parameter.
+ 4. The Scala 3.1 behavior is already available today under the `-strict` setting.
+
+To smooth the transition for codebases that use kind-projector, we adopt the following measures under the command line
+option `-Ykind-projector`:
+
+ 1. In Scala 3.0, `*` is available as a type parameter placeholder.
+ 2. In Scala 3.2, `*` is deprecated in favor of `_`. A `-rewrite` option is
+    available to rewrite one to the other.
+ 3. In Scala 3.3, `*` is removed again, and all type parameter placeholders will be expressed with `_`.
+
+These rules make it possible to cross build between Scala 2 using the kind projector plugin and Scala 3.0 - 3.2 using option `-Ykind-projector`.

tests/neg-custom-args/wildcards.scala

@@ -0,0 +1,4 @@
+object Test {
+  val xs: List[_] = List(1, 2, 3)  // error
+  val ys: Map[_ <: AnyRef, _ >: Null] = Map() // error // error
+}

tests/pos/wildcards.scala

@@ -0,0 +1,4 @@
+object Test {
+  val xs: List[?] = List(1, 2, 3)
+  val ys: Map[? <: AnyRef, ? >: Null] = Map()
+}