Disable named type arguments by default

Named type arguments are now available only under language import

    import scala.language.experimental.namedTypeArguments

Author: odersky

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

@@ -60,6 +60,9 @@ object Feature:
   def dependentEnabled(using Context) =
     enabled(nme.dependent, defn.LanguageExperimentalModule.moduleClass)
 
+  def namedTypeArgsEnabled(using Context) =
+    enabled(nme.namedTypeArguments, defn.LanguageExperimentalModule.moduleClass)
+
   def scala2ExperimentalMacroEnabled(using Context) =
     enabled("macros".toTermName, defn.LanguageExperimentalModule.moduleClass)
 

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

@@ -528,6 +528,7 @@ object StdNames {
     val moduleClass : N         = "moduleClass"
     val name: N                 = "name"
     val nameDollar: N           = "$name"
+    val namedTypeArguments: N   = "namedTypeArguments"
     val ne: N                   = "ne"
     val newFreeTerm: N          = "newFreeTerm"
     val newFreeType: N          = "newFreeType"

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -1057,6 +1057,11 @@ trait Applications extends Compatibility {
 
   def typedNamedArgs(args: List[untpd.Tree])(using Context): List[NamedArg] =
     for (arg @ NamedArg(id, argtpt) <- args) yield {
+      if !Feature.namedTypeArgsEnabled then
+        report.error(
+          i"""Named type arguments are experimental,
+             |they must be enabled with a `experimental.namedTypeArguments` language import or setting""",
+          arg.srcPos)
       val argtpt1 = typedType(argtpt)
       cpy.NamedArg(arg)(id, argtpt1).withType(argtpt1.tpe)
     }

docs/docs/internals/syntax.md

@@ -161,7 +161,7 @@ SimpleType        ::=  SimpleLiteral
 SimpleType1       ::=  id                                                       Ident(name)
                     |  Singleton ‘.’ id                                         Select(t, name)
                     |  Singleton ‘.’ ‘type’                                     SingletonTypeTree(p)
-                    |  ‘(’ ArgTypes ‘)’                                         Tuple(ts)
+                    |  ‘(’ Types ‘)’                                         Tuple(ts)
                     |  Refinement                                               RefinedTypeTree(EmptyTree, refinement)
                     |  ‘$’ ‘{’ Block ‘}’
                     |  SimpleType1 TypeArgs                                     AppliedTypeTree(t, args)
@@ -170,16 +170,13 @@ Singleton         ::=  SimpleRef
                     |  SimpleLiteral
                     |  Singleton ‘.’ id
 -- not yet          |  Singleton ‘(’ Singletons ‘)’
--- not yet          |  Singleton ‘[’ ArgTypes ‘]’
+-- not yet          |  Singleton ‘[’ Types ‘]’
 Singletons        ::=  Singleton { ‘,’ Singleton }
-ArgTypes          ::=  Types
 FunArgType        ::=  Type
                     |  ‘=>’ Type                                                PrefixOp(=>, t)
 ParamType         ::=  [‘=>’] ParamValueType
 ParamValueType    ::=  Type [‘*’]                                               PostfixOp(t, "*")
-TypeArgs          ::=  ‘[’ ArgTypes ‘]’                                         ts
-NamedTypeArg      ::=  id ‘=’ Type                                              NamedArg(id, t)
-NamedTypeArgs     ::=  ‘[’ NamedTypeArg {‘,’ NamedTypeArg} ‘]’                  nts
+TypeArgs          ::=  ‘[’ Types ‘]’                                         ts
 Refinement        ::=  ‘{’ [RefineDcl] {semi [RefineDcl]} ‘}’                   ds
 TypeBounds        ::=  [‘>:’ Type] [‘<:’ Type]                                  TypeBoundsTree(lo, hi)
 TypeParamBounds   ::=  TypeBounds {‘:’ Type}                                    ContextBounds(typeBounds, tps)

library/src/scalaShadowing/language.scala

@@ -213,6 +213,9 @@ object language {
 
     /** Experimental support for richer dependent types */
     object dependent
+
+    /** Experimental support for named type arguments */
+    object namedTypeArguments
   }
 
   /** Where imported, a backwards compatibility mode for Scala2 is enabled */
@@ -242,9 +245,6 @@ object language {
    */
   object adhocExtensions
 
-  /** Experimental support for richer dependent types */
-  object dependent
-
   /** Source version */
   object `3.0-migration`
   object `3.0`

tests/neg/i2771.scala

@@ -1,3 +1,4 @@
+import language.experimental.namedTypeArguments
 trait A { type L[X] }
 trait B { type L }
 trait C { type M <: A }

tests/neg/i5328.scala

@@ -1,3 +1,4 @@
+import language.experimental.namedTypeArguments
 class C[X, Y] { def apply[Z](x: X, y: Y, z: Z) = (x, y, z) }
 
 object Test {

tests/neg/namedTypeParams.scala

@@ -1,7 +1,12 @@
 class C[T]
 class D[type T] // error: identifier expected, but `type` found
 
+object Test0:
+  def f[X, Y](x: X, y: Y): Int = ???
+  f[X = Int, Y = Int](1, 2) // error: experimental // error: experimental
+
 object Test {
+  import language.experimental.namedTypeArguments
 
   val x: C[T = Int] = // error:  ']' expected, but `=` found // error
     new C[T = Int] // error:  ']' expected, but `=` found // error

tests/pos-custom-args/erased/i7868.scala

@@ -1,3 +1,4 @@
+import language.experimental.namedTypeArguments
 import scala.compiletime._
 
 final case class Coproduct[+Set, +Value, Index <: Int](value: Value & Set, index: Index)

tests/pos/gadt-GadtStlc.scala

@@ -1,3 +1,4 @@
+import language.experimental.namedTypeArguments
 object GadtStlc {
   // creates type-level "strings" like M[M[M[W]]]
   object W