Make named tuples a standard feature

odersky · odersky · commit 87cdbc8c7851 · 2024-10-01T11:39:00.000+02:00
- Deprecate experimental language import
 - Make named tuple features conditional on -source &gt;= 3.6 instead
 - Make the NamedTuple object non-experimental.
 - Move NamedTuple it to src-bootstrapped since it relies on clause interleaving
   which is only standard in 3.6 as well.
 - Drop the experimental.namedTuple import from tests
diff --git a/compiler/src/dotty/tools/dotc/config/Feature.scala b/compiler/src/dotty/tools/dotc/config/Feature.scala
@@ -34,7 +34,6 @@ 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")
@@ -66,7 +65,6 @@ 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")
diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettingsProperties.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettingsProperties.scala
@@ -25,7 +25,7 @@ object ScalaSettingsProperties:
     ScalaRelease.values.toList.map(_.show)
 
   def supportedSourceVersions: List[String] =
-    SourceVersion.values.toList.map(_.toString)
+    (SourceVersion.values.toList.diff(SourceVersion.illegalSourceVersionNames)).toList.map(_.toString)
 
   def supportedLanguageFeatures: List[ChoiceWithHelp[String]] =
     Feature.values.map((n, d) => ChoiceWithHelp(n.toString, d))
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -651,7 +651,7 @@ object Parsers {
       else leading :: Nil
 
     def maybeNamed(op: () => Tree): () => Tree = () =>
-      if isIdent && in.lookahead.token == EQUALS && in.featureEnabled(Feature.namedTuples) then
+      if isIdent && in.lookahead.token == EQUALS && sourceVersion.isAtLeast(`3.6`) then
         atSpan(in.offset):
           val name = ident()
           in.nextToken()
@@ -2137,7 +2137,7 @@ object Parsers {
 
       if namedOK && isIdent && in.lookahead.token == EQUALS then
         commaSeparated(() => namedArgType())
-      else if tupleOK && isIdent && in.lookahead.isColon && in.featureEnabled(Feature.namedTuples) then
+      else if tupleOK && isIdent && in.lookahead.isColon && sourceVersion.isAtLeast(`3.6`) then
         commaSeparated(() => namedElem())
       else
         commaSeparated(() => argType())
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -789,7 +789,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 && Feature.enabled(Feature.namedTuples) then
+      if nameIdx >= 0 && sourceVersion.isAtLeast(`3.6`) then
         typed(
           untpd.Apply(
             untpd.Select(untpd.TypedSplice(qual), nme.apply),
diff --git a/library/src-bootstrapped/scala/NamedTuple.scala b/library/src-bootstrapped/scala/NamedTuple.scala
@@ -1,9 +1,6 @@
 package scala
-import scala.language.experimental.clauseInterleaving
-import annotation.experimental
 import compiletime.ops.boolean.*
 
-@experimental
 object NamedTuple:
 
   /** The type to which named tuples get mapped to. For instance,
@@ -133,7 +130,6 @@ 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])
diff --git a/library/src/scala/runtime/stdLibPatches/language.scala b/library/src/scala/runtime/stdLibPatches/language.scala
@@ -97,6 +97,7 @@ 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
diff --git a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala
@@ -1988,8 +1988,7 @@ class CompletionSuite extends BaseCompletionSuite:
 
   @Test def `namedTuple completions` =
     check(
-      """|import scala.language.experimental.namedTuples
-         |import scala.NamedTuple.*
+      """|import scala.NamedTuple.*
          |
          |val person = (name = "Jamie", city = "Lausanne")
          |
@@ -2000,8 +1999,7 @@ class CompletionSuite extends BaseCompletionSuite:
 
   @Test def `Selectable with namedTuple Fields member` =
     check(
-      """|import scala.language.experimental.namedTuples
-         |import scala.NamedTuple.*
+      """|import scala.NamedTuple.*
          |
          |class NamedTupleSelectable extends Selectable {
          |  type Fields <: AnyNamedTuple
@@ -2091,7 +2089,7 @@ class CompletionSuite extends BaseCompletionSuite:
          |""".stripMargin
     )
 
-  @Test def `conflict-3` = 
+  @Test def `conflict-3` =
    check(
      """|package a
         |object A {
diff --git a/tests/neg/i20517.check b/tests/neg/i20517.check
@@ -1,7 +1,7 @@
--- [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`
+-- [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`
diff --git a/tests/neg/i20517.scala b/tests/neg/i20517.scala
@@ -1,4 +1,3 @@
-import scala.language.experimental.namedTuples
 import NamedTuple.From
 
 case class Foo[+T](elem: T)
diff --git a/tests/neg/named-tuple-selectable.scala b/tests/neg/named-tuple-selectable.scala
@@ -1,5 +1,3 @@
-import scala.language.experimental.namedTuples
-
 class FromFields extends Selectable:
   type Fields = (i: Int)
   def selectDynamic(key: String) =
diff --git a/tests/neg/named-tuples-2.check b/tests/neg/named-tuples-2.check
@@ -1,8 +1,8 @@
--- Error: tests/neg/named-tuples-2.scala:5:9 ---------------------------------------------------------------------------
-5 |    case (name, age) => () // error
+-- Error: tests/neg/named-tuples-2.scala:4:9 ---------------------------------------------------------------------------
+4 |    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:6:9 ---------------------------------------------------------------------------
-6 |    case (n, a, m, x) => () // error
+-- Error: tests/neg/named-tuples-2.scala:5:9 ---------------------------------------------------------------------------
+5 |    case (n, a, m, x) => () // error
   |         ^
   |         this case is unreachable since type (String, Int, Boolean) is not a subclass of class Tuple4
diff --git a/tests/neg/named-tuples-2.scala b/tests/neg/named-tuples-2.scala
@@ -1,4 +1,3 @@
-import language.experimental.namedTuples
 def Test =
   val person = (name = "Bob", age = 33, married = true)
   person match
diff --git a/tests/neg/named-tuples-3.check b/tests/neg/named-tuples-3.check
@@ -1,5 +1,5 @@
--- [E007] Type Mismatch Error: tests/neg/named-tuples-3.scala:7:16 -----------------------------------------------------
-7 |val p: Person = f  // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples-3.scala:5:16 -----------------------------------------------------
+5 |val p: Person = f  // error
   |                ^
   |                Found:    NamedTuple.NamedTuple[(Int, Any), (Int, String)]
   |                Required: Person
diff --git a/tests/neg/named-tuples-3.scala b/tests/neg/named-tuples-3.scala
@@ -1,5 +1,3 @@
-import language.experimental.namedTuples
-
 def f: NamedTuple.NamedTuple[(Int, Any), (Int, String)] = ???
 
 type Person = (name: Int, age: String)
diff --git a/tests/neg/named-tuples.check b/tests/neg/named-tuples.check
@@ -1,101 +1,101 @@
--- Error: tests/neg/named-tuples.scala:9:19 ----------------------------------------------------------------------------
-9 |  val illformed = (_2 = 2) // error
+-- Error: tests/neg/named-tuples.scala:8:19 ----------------------------------------------------------------------------
+8 |  val illformed = (_2 = 2) // error
   |                   ^^^^^^
   |                   _2 cannot be used as the name of a tuple element because it is a regular tuple selector
--- Error: tests/neg/named-tuples.scala:10:20 ---------------------------------------------------------------------------
-10 |  type Illformed = (_1: Int) // error
-   |                    ^^^^^^^
-   |                    _1 cannot be used as the name of a tuple element because it is a regular tuple selector
--- Error: tests/neg/named-tuples.scala:11:40 ---------------------------------------------------------------------------
-11 |  val illformed2 = (name = "", age = 0, name = true)  // error
+-- Error: tests/neg/named-tuples.scala:9:20 ----------------------------------------------------------------------------
+9 |  type Illformed = (_1: Int) // error
+  |                    ^^^^^^^
+  |                    _1 cannot be used as the name of a tuple element because it is a regular tuple selector
+-- Error: tests/neg/named-tuples.scala:10:40 ---------------------------------------------------------------------------
+10 |  val illformed2 = (name = "", age = 0, name = true)  // error
    |                                        ^^^^^^^^^^^
    |                                        Duplicate tuple element name
--- Error: tests/neg/named-tuples.scala:12:45 ---------------------------------------------------------------------------
-12 |  type Illformed2 = (name: String, age: Int, name: Boolean) // error
+-- Error: tests/neg/named-tuples.scala:11:45 ---------------------------------------------------------------------------
+11 |  type Illformed2 = (name: String, age: Int, name: Boolean) // error
    |                                             ^^^^^^^^^^^^^
    |                                             Duplicate tuple element name
--- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:20:20 ------------------------------------------------------
-20 |  val _: NameOnly = person // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:19:20 ------------------------------------------------------
+19 |  val _: NameOnly = person // error
    |                    ^^^^^^
    |                    Found:    (Test.person : (name : String, age : Int))
    |                    Required: Test.NameOnly
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:21:18 ------------------------------------------------------
-21 |  val _: Person = nameOnly // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:20:18 ------------------------------------------------------
+20 |  val _: Person = nameOnly // error
    |                  ^^^^^^^^
    |                  Found:    (Test.nameOnly : (name : String))
    |                  Required: Test.Person
    |
    | longer explanation available when compiling with `-explain`
--- [E172] Type Error: tests/neg/named-tuples.scala:22:41 ---------------------------------------------------------------
-22 |  val _: Person = (name = "") ++ nameOnly // error
+-- [E172] Type Error: tests/neg/named-tuples.scala:21:41 ---------------------------------------------------------------
+21 |  val _: Person = (name = "") ++ nameOnly // error
    |                                         ^
    |    Cannot prove that Tuple.Disjoint[Tuple1[("name" : String)], Tuple1[("name" : String)]] =:= (true : Boolean).
--- [E008] Not Found Error: tests/neg/named-tuples.scala:23:9 -----------------------------------------------------------
-23 |  person._1 // error
+-- [E008] Not Found Error: tests/neg/named-tuples.scala:22:9 -----------------------------------------------------------
+22 |  person._1 // error
    |  ^^^^^^^^^
    |  value _1 is not a member of (name : String, age : Int)
--- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:25:36 ------------------------------------------------------
-25 |  val _: (age: Int, name: String) = person // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:24:36 ------------------------------------------------------
+24 |  val _: (age: Int, name: String) = person // error
    |                                    ^^^^^^
    |                                    Found:    (Test.person : (name : String, age : Int))
    |                                    Required: (age : Int, name : String)
    |
    | longer explanation available when compiling with `-explain`
--- Error: tests/neg/named-tuples.scala:27:17 ---------------------------------------------------------------------------
-27 |  val (name = x, agee = y) = person // error
+-- Error: tests/neg/named-tuples.scala:26:17 ---------------------------------------------------------------------------
+26 |  val (name = x, agee = y) = person // error
    |                 ^^^^^^^^
    |                 No element named `agee` is defined in selector type (name : String, age : Int)
--- Error: tests/neg/named-tuples.scala:30:10 ---------------------------------------------------------------------------
-30 |    case (name = n, age = a) => () // error // error
+-- Error: tests/neg/named-tuples.scala:29:10 ---------------------------------------------------------------------------
+29 |    case (name = n, age = a) => () // error // error
    |          ^^^^^^^^
    |          No element named `name` is defined in selector type (String, Int)
--- Error: tests/neg/named-tuples.scala:30:20 ---------------------------------------------------------------------------
-30 |    case (name = n, age = a) => () // error // error
+-- Error: tests/neg/named-tuples.scala:29:20 ---------------------------------------------------------------------------
+29 |    case (name = n, age = a) => () // error // error
    |                    ^^^^^^^
    |                    No element named `age` is defined in selector type (String, Int)
--- [E172] Type Error: tests/neg/named-tuples.scala:32:27 ---------------------------------------------------------------
-32 |  val pp = person ++ (1, 2)  // error
+-- [E172] Type Error: tests/neg/named-tuples.scala:31:27 ---------------------------------------------------------------
+31 |  val pp = person ++ (1, 2)  // error
    |                           ^
    |            Cannot prove that Tuple.Disjoint[(("name" : String), ("age" : String)), Tuple] =:= (true : Boolean).
--- [E172] Type Error: tests/neg/named-tuples.scala:35:18 ---------------------------------------------------------------
-35 |  person ++ (1, 2) match // error
+-- [E172] Type Error: tests/neg/named-tuples.scala:34:18 ---------------------------------------------------------------
+34 |  person ++ (1, 2) match // error
    |                  ^
    |            Cannot prove that Tuple.Disjoint[(("name" : String), ("age" : String)), Tuple] =:= (true : Boolean).
--- Error: tests/neg/named-tuples.scala:38:17 ---------------------------------------------------------------------------
-38 |  val bad = ("", age = 10) // error
+-- Error: tests/neg/named-tuples.scala:37:17 ---------------------------------------------------------------------------
+37 |  val bad = ("", age = 10) // error
    |                 ^^^^^^^^
    |                 Illegal combination of named and unnamed tuple elements
--- Error: tests/neg/named-tuples.scala:41:20 ---------------------------------------------------------------------------
-41 |    case (name = n, age) => () // error
+-- Error: tests/neg/named-tuples.scala:40:20 ---------------------------------------------------------------------------
+40 |    case (name = n, age) => () // error
    |                    ^^^
    |                    Illegal combination of named and unnamed tuple elements
--- Error: tests/neg/named-tuples.scala:42:16 ---------------------------------------------------------------------------
-42 |    case (name, age = a) => () // error
+-- Error: tests/neg/named-tuples.scala:41:16 ---------------------------------------------------------------------------
+41 |    case (name, age = a) => () // error
    |                ^^^^^^^
    |                Illegal combination of named and unnamed tuple elements
--- Error: tests/neg/named-tuples.scala:45:10 ---------------------------------------------------------------------------
-45 |    case (age = x) => // error
+-- Error: tests/neg/named-tuples.scala:44:10 ---------------------------------------------------------------------------
+44 |    case (age = x) => // error
    |          ^^^^^^^
    |          No element named `age` is defined in selector type Tuple
--- [E172] Type Error: tests/neg/named-tuples.scala:47:27 ---------------------------------------------------------------
-47 |  val p2 = person ++ person // error
+-- [E172] Type Error: tests/neg/named-tuples.scala:46:27 ---------------------------------------------------------------
+46 |  val p2 = person ++ person // error
    |                           ^
    |Cannot prove that Tuple.Disjoint[(("name" : String), ("age" : String)), (("name" : String), ("age" : String))] =:= (true : Boolean).
--- [E172] Type Error: tests/neg/named-tuples.scala:48:43 ---------------------------------------------------------------
-48 |  val p3 = person ++ (first = 11, age = 33) // error
+-- [E172] Type Error: tests/neg/named-tuples.scala:47:43 ---------------------------------------------------------------
+47 |  val p3 = person ++ (first = 11, age = 33) // error
    |                                           ^
    |Cannot prove that Tuple.Disjoint[(("name" : String), ("age" : String)), (("first" : String), ("age" : String))] =:= (true : Boolean).
--- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:50:22 ------------------------------------------------------
-50 |  val p5 = person.zip((first = 11, age = 33)) // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:49:22 ------------------------------------------------------
+49 |  val p5 = person.zip((first = 11, age = 33)) // error
    |                      ^^^^^^^^^^^^^^^^^^^^^^
    |                      Found:    (first : Int, age : Int)
    |                      Required: NamedTuple.NamedTuple[(("name" : String), ("age" : String)), Tuple]
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:61:32 ------------------------------------------------------
-61 |  val typo: (name: ?, age: ?) = (name = "he", ag = 1) // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:60:32 ------------------------------------------------------
+60 |  val typo: (name: ?, age: ?) = (name = "he", ag = 1) // error
    |                                ^^^^^^^^^^^^^^^^^^^^^
    |                                Found:    (name : String, ag : Int)
    |                                Required: (name : ?, age : ?)
diff --git a/tests/neg/named-tuples.scala b/tests/neg/named-tuples.scala
@@ -1,7 +1,6 @@
 import annotation.experimental
-import language.experimental.namedTuples
 
-@experimental object Test:
+object Test:
 
   type Person = (name: String, age: Int)
   val person = (name = "Bob", age = 33): (name: String, age: Int)
diff --git a/tests/new/test.scala b/tests/new/test.scala
@@ -1,5 +1,3 @@
-import language.experimental.namedTuples
-
 type Person = (name: String, age: Int)
 
 trait A:
diff --git a/tests/pos/fieldsOf.scala b/tests/pos/fieldsOf.scala
@@ -1,5 +1,3 @@
-import language.experimental.namedTuples
-
 case class Person(name: String, age: Int)
 
 type PF = NamedTuple.From[Person]
diff --git a/tests/pos/i20377.scala b/tests/pos/i20377.scala
@@ -1,4 +1,3 @@
-import language.experimental.namedTuples
 import NamedTuple.{NamedTuple, AnyNamedTuple}
 
 // Repros for bugs or questions
diff --git a/tests/pos/i21300.scala b/tests/pos/i21300.scala
@@ -1,17 +1,15 @@
-import scala.language.experimental.namedTuples
-
 class Test[S <: String & Singleton](name: S):
 
   type NT = NamedTuple.NamedTuple[(S, "foo"), (Int, Long)]
   def nt: NT = ???
 
   type Name = S
-  
+
   type NT2 = NamedTuple.NamedTuple[(Name, "foo"), (Int, Long)]
   def nt2: NT2 = ???
 
 def test =
   val foo = new Test("bar")
-  
+
   foo.nt.bar
   foo.nt2.bar
diff --git a/tests/pos/named-tuple-combinators.scala b/tests/pos/named-tuple-combinators.scala
@@ -1,4 +1,3 @@
-import scala.language.experimental.namedTuples
 
 object Test:
   // original code from issue https://github.com/scala/scala3/issues/20427
diff --git a/tests/pos/named-tuple-selectable.scala b/tests/pos/named-tuple-selectable.scala
@@ -1,4 +1,3 @@
-import scala.language.experimental.namedTuples
 
 class FromFields extends Selectable:
   type Fields = (xs: List[Int], poly: [T] => (x: List[T]) => Option[T])
diff --git a/tests/pos/named-tuple-selections.scala b/tests/pos/named-tuple-selections.scala
@@ -1,4 +1,3 @@
-import scala.language.experimental.namedTuples
 
 object Test1:
   // original code from issue https://github.com/scala/scala3/issues/20439
diff --git a/tests/pos/named-tuple-unstable.scala b/tests/pos/named-tuple-unstable.scala
@@ -1,4 +1,3 @@
-import scala.language.experimental.namedTuples
 import NamedTuple.{AnyNamedTuple, NamedTuple}
 
 trait Foo extends Selectable:
diff --git a/tests/pos/named-tuple-widen.scala b/tests/pos/named-tuple-widen.scala
diff --git a/tests/pos/named-tuples-ops-mirror.scala b/tests/pos/named-tuples-ops-mirror.scala
diff --git a/tests/pos/named-tuples1.scala b/tests/pos/named-tuples1.scala
diff --git a/tests/pos/namedtuple-src-incompat.scala b/tests/pos/namedtuple-src-incompat.scala
diff --git a/tests/pos/tuple-ops.scala b/tests/pos/tuple-ops.scala
diff --git a/tests/run-tasty-inspector/stdlibExperimentalDefinitions.scala b/tests/run-tasty-inspector/stdlibExperimentalDefinitions.scala
diff --git a/tests/run/named-patmatch.scala b/tests/run/named-patmatch.scala
diff --git a/tests/run/named-patterns.scala b/tests/run/named-patterns.scala
diff --git a/tests/run/named-tuple-ops.scala b/tests/run/named-tuple-ops.scala
diff --git a/tests/run/named-tuples-xxl.scala b/tests/run/named-tuples-xxl.scala
diff --git a/tests/run/named-tuples.scala b/tests/run/named-tuples.scala
diff --git a/tests/run/tyql.scala b/tests/run/tyql.scala

Original file line number	Diff line number	Diff line change
`@@ -1988,8 +1988,7 @@ class CompletionSuite extends BaseCompletionSuite:`
`1988`	`1988`
`1989`	`1989`	@Test def `namedTuple completions` =
`1990`	`1990`	`check(`
`1991`		`- """\|import scala.language.experimental.namedTuples`
`1992`		`- \|import scala.NamedTuple.*`
	`1991`	`+ """\|import scala.NamedTuple.*`
`1993`	`1992`	`\|`
`1994`	`1993`	`\|val person = (name = "Jamie", city = "Lausanne")`
`1995`	`1994`	`\|`
`@@ -2000,8 +1999,7 @@ class CompletionSuite extends BaseCompletionSuite:`
`2000`	`1999`
`2001`	`2000`	@Test def `Selectable with namedTuple Fields member` =
`2002`	`2001`	`check(`
`2003`		`- """\|import scala.language.experimental.namedTuples`
`2004`		`- \|import scala.NamedTuple.*`
	`2002`	`+ """\|import scala.NamedTuple.*`
`2005`	`2003`	`\|`
`2006`	`2004`	`\|class NamedTupleSelectable extends Selectable {`
`2007`	`2005`	`\| type Fields <: AnyNamedTuple`
`@@ -2091,7 +2089,7 @@ class CompletionSuite extends BaseCompletionSuite:`
`2091`	`2089`	`\|""".stripMargin`
`2092`	`2090`	`)`
`2093`	`2091`
`2094`		- @Test def `conflict-3` =
	`2092`	+ @Test def `conflict-3` =
`2095`	`2093`	`check(`
`2096`	`2094`	`"""\|package a`
`2097`	`2095`	`\|object A {`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,3 @@`
`1`		`-import scala.language.experimental.namedTuples`
`2`	`1`	`import NamedTuple.From`
`3`	`2`
`4`	`3`	`case class Foo[+T](elem: T)`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,3 @@`
`1`		`-import scala.language.experimental.namedTuples`
`2`		`-`
`3`	`1`	`class FromFields extends Selectable:`
`4`	`2`	`type Fields = (i: Int)`
`5`	`3`	`def selectDynamic(key: String) =`