Rename NamedTuple.FieldsOf --> NamedTuple.From

Author: odersky

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

@@ -1320,8 +1320,8 @@ class Definitions {
   final def isCompiletime_S(sym: Symbol)(using Context): Boolean =
     sym.name == tpnme.S && sym.owner == CompiletimeOpsIntModuleClass
 
-  final def isNamedTuple_FieldsOf(sym: Symbol)(using Context): Boolean =
-    sym.name == tpnme.FieldsOf && sym.owner == NamedTupleModule.moduleClass
+  final def isNamedTuple_From(sym: Symbol)(using Context): Boolean =
+    sym.name == tpnme.From && sym.owner == NamedTupleModule.moduleClass
 
   private val compiletimePackageAnyTypes: Set[Name] = Set(
     tpnme.Equals, tpnme.NotEquals, tpnme.IsConst, tpnme.ToString
@@ -1351,7 +1351,7 @@ class Definitions {
     tpnme.Plus, tpnme.Length, tpnme.Substring, tpnme.Matches, tpnme.CharAt
   )
   private val compiletimePackageOpTypes: Set[Name] =
-    Set(tpnme.S, tpnme.FieldsOf)
+    Set(tpnme.S, tpnme.From)
     ++ compiletimePackageAnyTypes
     ++ compiletimePackageIntTypes
     ++ compiletimePackageLongTypes
@@ -1364,7 +1364,7 @@ class Definitions {
     compiletimePackageOpTypes.contains(sym.name)
     && (
          isCompiletime_S(sym)
-      || isNamedTuple_FieldsOf(sym)
+      || isNamedTuple_From(sym)
       || sym.owner == CompiletimeOpsAnyModuleClass && compiletimePackageAnyTypes.contains(sym.name)
       || sym.owner == CompiletimeOpsIntModuleClass && compiletimePackageIntTypes.contains(sym.name)
       || sym.owner == CompiletimeOpsLongModuleClass && compiletimePackageLongTypes.contains(sym.name)

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

@@ -361,8 +361,8 @@ object StdNames {
     val Eql: N                  = "Eql"
     val EnumValue: N            = "EnumValue"
     val ExistentialTypeTree: N  = "ExistentialTypeTree"
-    val FieldsOf: N             = "FieldsOf"
     val Flag : N                = "Flag"
+    val From: N                 = "From"
     val Ident: N                = "Ident"
     val Import: N               = "Import"
     val Literal: N              = "Literal"

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

@@ -146,7 +146,7 @@ object TypeEval:
         val constantType =
           if defn.isCompiletime_S(sym) then
             constantFold1(natValue, _ + 1)
-          else if defn.isNamedTuple_FieldsOf(sym) then
+          else if defn.isNamedTuple_From(sym) then
             fieldsOf
           else if owner == defn.CompiletimeOpsAnyModuleClass then name match
             case tpnme.Equals     => constantFold2(constValue, _ == _)

docs/_docs/reference/experimental/named-tuples.md

@@ -100,19 +100,19 @@ The translation of named tuples to instances of `NamedTuple` is fixed by the spe
  - All tuple operations also work with named tuples "out of the box".
  - Macro libraries can rely on this expansion.
 
-### The FieldsOf Type
+### The NamedTuple.From Type
 
 The `NamedTuple` object contains a type definition
 ```scala
-  type FieldsOf[T] <: AnyNamedTuple
+  type From[T] <: AnyNamedTuple
 ```
-`FieldsOf` is treated specially by the compiler. When `FieldsOf` is applied to
+`From` is treated specially by the compiler. When `NamedTuple.From` is applied to
 an argument type that is an instance of a case class, the type expands to the named
 tuple consisting of all the fields of that case class. Here, fields means: elements of the first parameter section. For instance, assuming
 ```scala
 case class City(zip: Int, name: String, population: Int)
 ```
-then `FieldsOf[City]` is the named tuple
+then `NamedTuple.From[City]` is the named tuple
 ```scala
 (zip: Int, name: String, population: Int)
 ```

library/src/scala/NamedTuple.scala

@@ -175,7 +175,7 @@ object NamedTuple:
       case true =>
         NamedTuple[Names[X], Tuple.Zip[DropNames[X], DropNames[Y]]]
 
-  type FieldsOf[T] <: AnyNamedTuple
+  type From[T] <: AnyNamedTuple
 
 end NamedTuple
 

tests/neg/fieldsOf.scala

@@ -1,11 +1,9 @@
-import NamedTuple.FieldsOf
-
 case class Person(name: String, age: Int)
 class Anon(name: String, age: Int)
-def foo[T](): FieldsOf[T] = ???
+def foo[T](): NamedTuple.From[T] = ???
 
 def test =
-  var x: FieldsOf[Person] = ???
+  var x: NamedTuple.From[Person] = ???
   x = foo[Person]() // ok
   x = foo[Anon]() // error
   x = foo() // error

tests/pos/fieldsOf.scala

@@ -1,15 +1,13 @@
-import NamedTuple.FieldsOf
-
 case class Person(name: String, age: Int)
 
-type PF = FieldsOf[Person]
+type PF = NamedTuple.From[Person]
 
-def foo[T]: FieldsOf[T] = ???
+def foo[T]: NamedTuple.From[T] = ???
 
 class Anon(name: String, age: Int)
 
 def test =
-  var x: FieldsOf[Person] = ???
+  var x: NamedTuple.From[Person] = ???
   val y: (name: String, age: Int) = x
   x = y
   x = foo[Person]