Make NamedTupls an experimental feature again

Author: WojciechMazur

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

@@ -34,6 +34,7 @@ object Feature:
   val pureFunctions = experimental("pureFunctions")
   val captureChecking = experimental("captureChecking")
   val into = experimental("into")
+  val namedTuples = experimental("namedTuples")
   val modularity = experimental("modularity")
   val betterMatchTypeExtractors = experimental("betterMatchTypeExtractors")
   val quotedPatternsWithPolymorphicFunctions = experimental("quotedPatternsWithPolymorphicFunctions")
@@ -65,6 +66,7 @@ object Feature:
     (pureFunctions, "Enable pure functions for capture checking"),
     (captureChecking, "Enable experimental capture checking"),
     (into, "Allow into modifier on parameter types"),
+    (namedTuples, "Allow named tuples"),
     (modularity, "Enable experimental modularity features"),
     (betterMatchTypeExtractors, "Enable better match type extractors"),
     (betterFors, "Enable improvements in `for` comprehensions")

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

@@ -667,7 +667,7 @@ object Parsers {
       else leading :: Nil
 
     def maybeNamed(op: () => Tree): () => Tree = () =>
-      if isIdent && in.lookahead.token == EQUALS && sourceVersion.isAtLeast(`3.6`) then
+      if isIdent && in.lookahead.token == EQUALS && in.featureEnabled(Feature.namedTuples) then
         atSpan(in.offset):
           val name = ident()
           in.nextToken()
@@ -2172,7 +2172,7 @@ object Parsers {
 
       if namedOK && isIdent && in.lookahead.token == EQUALS then
         commaSeparated(() => namedArgType())
-      else if tupleOK && isIdent && in.lookahead.isColon && sourceVersion.isAtLeast(`3.6`) then
+      else if tupleOK && isIdent && in.lookahead.isColon && in.featureEnabled(Feature.namedTuples) then
         commaSeparated(() => namedElem())
       else
         commaSeparated(() => argType())

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

@@ -795,7 +795,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     def tryNamedTupleSelection() =
       val namedTupleElems = qual.tpe.widenDealias.namedTupleElementTypes
       val nameIdx = namedTupleElems.indexWhere(_._1 == selName)
-      if nameIdx >= 0 && sourceVersion.isAtLeast(`3.6`) then
+      if nameIdx >= 0 && Feature.enabled(Feature.namedTuples) then
         typed(
           untpd.Apply(
             untpd.Select(untpd.TypedSplice(qual), nme.apply),

docs/_docs/reference/other-new-features/named-tuples.md renamed to docs/_docs/reference/experimental/named-tuples.md

@@ -1,10 +1,10 @@
 ---
 layout: doc-page
 title: "Named Tuples"
-nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/named-tuples.html
+nightlyOf: https://docs.scala-lang.org/scala3/reference/experimental/named-tuples.html
 ---
 
-Starting in Scala 3.6, the elements of a tuple can be named. Example:
+The elements of a tuple can now be named. Example:
 ```scala
 type Person = (name: String, age: Int)
 val Bob: Person = (name = "Bob", age = 33)

docs/sidebar.yml

@@ -72,7 +72,6 @@ subsection:
           - page: reference/other-new-features/export.md
           - page: reference/other-new-features/opaques.md
           - page: reference/other-new-features/opaques-details.md
-          - page: reference/other-new-features/named-tuples.md
           - page: reference/other-new-features/open-classes.md
           - page: reference/other-new-features/parameter-untupling.md
           - page: reference/other-new-features/parameter-untupling-spec.md
@@ -159,6 +158,7 @@ subsection:
           - page: reference/experimental/cc.md
           - page: reference/experimental/purefuns.md
           - page: reference/experimental/tupled-function.md
+          - page: reference/experimental/named-tuples.md
           - page: reference/experimental/modularity.md
           - page: reference/experimental/typeclasses.md
           - page: reference/experimental/runtimeChecked.md

library/src/scala/NamedTuple.scala

@@ -1,6 +1,8 @@
 package scala
+import annotation.experimental
 import compiletime.ops.boolean.*
 
+@experimental
 object NamedTuple:
 
   /** The type to which named tuples get mapped to. For instance,
@@ -131,6 +133,7 @@ object NamedTuple:
 end NamedTuple
 
 /** Separate from NamedTuple object so that we can match on the opaque type NamedTuple. */
+@experimental
 object NamedTupleDecomposition:
   import NamedTuple.*
   extension [N <: Tuple, V <: Tuple](x: NamedTuple[N, V])

library/src/scala/runtime/stdLibPatches/language.scala

@@ -97,7 +97,6 @@ object language:
      *  @see [[https://dotty.epfl.ch/docs/reference/experimental/named-tuples]]
      */
     @compileTimeOnly("`namedTuples` can only be used at compile time in import statements")
-    @deprecated("The experimental.namedTuples language import is no longer needed since the feature is now standard", since = "3.6")
     object namedTuples
 
     /** Experimental support for new features for better modularity, including

presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala

@@ -1988,7 +1988,8 @@ class CompletionSuite extends BaseCompletionSuite:
 
   @Test def `namedTuple completions` =
     check(
-      """|import scala.NamedTuple.*
+      """|import scala.language.experimental.namedTuples
+         |import scala.NamedTuple.*
          |
          |val person = (name = "Jamie", city = "Lausanne")
          |
@@ -1999,7 +2000,8 @@ class CompletionSuite extends BaseCompletionSuite:
 
   @Test def `Selectable with namedTuple Fields member` =
     check(
-      """|import scala.NamedTuple.*
+      """|import scala.language.experimental.namedTuples
+         |import scala.NamedTuple.*
          |
          |class NamedTupleSelectable extends Selectable {
          |  type Fields <: AnyNamedTuple

tests/neg/i20517.check

@@ -1,7 +1,7 @@
--- [E007] Type Mismatch Error: tests/neg/i20517.scala:9:43 -------------------------------------------------------------
-9 |  def dep(foo: Foo[Any]): From[foo.type] = (elem = "") // error
-  |                                           ^^^^^^^^^^^
-  |                                           Found:    (elem : String)
-  |                                           Required: NamedTuple.From[(foo : Foo[Any])]
-  |
-  | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg/i20517.scala:10:43 ------------------------------------------------------------
+10 |  def dep(foo: Foo[Any]): From[foo.type] = (elem = "") // error
+   |                                           ^^^^^^^^^^^
+   |                                           Found:    (elem : String)
+   |                                           Required: NamedTuple.From[(foo : Foo[Any])]
+   |
+   | longer explanation available when compiling with `-explain`

tests/neg/i20517.scala

@@ -1,3 +1,4 @@
+import scala.language.experimental.namedTuples
 import NamedTuple.From
 
 case class Foo[+T](elem: T)

tests/neg/infix-named-args.check

@@ -1,5 +1,5 @@
--- [E134] Type Error: tests/neg/infix-named-args.scala:2:13 ------------------------------------------------------------
-2 |  def f = 42 + (x = 1) // error // werror
+-- [E134] Type Error: tests/neg/infix-named-args.scala:4:13 ------------------------------------------------------------
+4 |  def f = 42 + (x = 1) // error // werror
   |          ^^^^
   |          None of the overloaded alternatives of method + in class Int with types
   |           (x: Double): Double
@@ -11,29 +11,29 @@
   |           (x: Byte): Int
   |           (x: String): String
   |          match arguments ((x : Int)) (a named tuple)
--- [E204] Syntax Warning: tests/neg/infix-named-args.scala:2:15 --------------------------------------------------------
-2 |  def f = 42 + (x = 1) // error // werror
+-- [E204] Syntax Warning: tests/neg/infix-named-args.scala:4:15 --------------------------------------------------------
+4 |  def f = 42 + (x = 1) // error // werror
   |               ^^^^^^^
   |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
   |This can be rewritten automatically under -rewrite -source 3.6-migration.
   |
   | longer explanation available when compiling with `-explain`
--- [E204] Syntax Warning: tests/neg/infix-named-args.scala:5:26 --------------------------------------------------------
-5 |  def g = new C() `multi` (x = 42, y = 27) // werror
+-- [E204] Syntax Warning: tests/neg/infix-named-args.scala:7:26 --------------------------------------------------------
+7 |  def g = new C() `multi` (x = 42, y = 27) // werror
   |                          ^^^^^^^^^^^^^^^^
   |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
   |This can be rewritten automatically under -rewrite -source 3.6-migration.
   |
   | longer explanation available when compiling with `-explain`
--- [E204] Syntax Warning: tests/neg/infix-named-args.scala:6:21 --------------------------------------------------------
-6 |  def h = new C() ** (x = 42, y = 27) // werror
+-- [E204] Syntax Warning: tests/neg/infix-named-args.scala:8:21 --------------------------------------------------------
+8 |  def h = new C() ** (x = 42, y = 27) // werror
   |                     ^^^^^^^^^^^^^^^^
   |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
   |This can be rewritten automatically under -rewrite -source 3.6-migration.
   |
   | longer explanation available when compiling with `-explain`
--- [E204] Syntax Warning: tests/neg/infix-named-args.scala:13:18 -------------------------------------------------------
-13 |  def f = this ** (x = 2) // werror
+-- [E204] Syntax Warning: tests/neg/infix-named-args.scala:15:18 -------------------------------------------------------
+15 |  def f = this ** (x = 2) // werror
    |                  ^^^^^^^
    |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
    |This can be rewritten automatically under -rewrite -source 3.6-migration.

tests/neg/infix-named-args.scala

@@ -1,3 +1,5 @@
+import scala.language.experimental.namedTuples
+
 class C:
   def f = 42 + (x = 1) // error // werror
   def multi(x: Int, y: Int): Int = x + y

tests/neg/named-tuple-selectable.scala

@@ -1,3 +1,5 @@
+import scala.language.experimental.namedTuples
+
 class FromFields extends Selectable:
   type Fields = (i: Int)
   def selectDynamic(key: String) =

tests/neg/named-tuples-2.check

@@ -1,8 +1,8 @@
--- Error: tests/neg/named-tuples-2.scala:4:9 ---------------------------------------------------------------------------
-4 |    case (name, age) => () // error
+-- Error: tests/neg/named-tuples-2.scala:5:9 ---------------------------------------------------------------------------
+5 |    case (name, age) => () // error
   |         ^
   |         this case is unreachable since type (String, Int, Boolean) is not a subclass of class Tuple2
--- Error: tests/neg/named-tuples-2.scala:5:9 ---------------------------------------------------------------------------
-5 |    case (n, a, m, x) => () // error
+-- Error: tests/neg/named-tuples-2.scala:6:9 ---------------------------------------------------------------------------
+6 |    case (n, a, m, x) => () // error
   |         ^
   |         this case is unreachable since type (String, Int, Boolean) is not a subclass of class Tuple4

tests/neg/named-tuples-2.scala

@@ -1,3 +1,4 @@
+import language.experimental.namedTuples
 def Test =
   val person = (name = "Bob", age = 33, married = true)
   person match

tests/neg/named-tuples-3.check

@@ -1,5 +1,5 @@
--- [E007] Type Mismatch Error: tests/neg/named-tuples-3.scala:5:16 -----------------------------------------------------
-5 |val p: Person = f  // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples-3.scala:7:16 -----------------------------------------------------
+7 |val p: Person = f  // error
   |                ^
   |                Found:    NamedTuple.NamedTuple[(Int, Any), (Int, String)]
   |                Required: Person

tests/neg/named-tuples-3.scala

@@ -1,3 +1,5 @@
+import language.experimental.namedTuples
+
 def f: NamedTuple.NamedTuple[(Int, Any), (Int, String)] = ???
 
 type Person = (name: Int, age: String)