Add FieldsOf type

Author: odersky

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

@@ -1320,6 +1320,9 @@ 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
+
   private val compiletimePackageAnyTypes: Set[Name] = Set(
     tpnme.Equals, tpnme.NotEquals, tpnme.IsConst, tpnme.ToString
   )
@@ -1348,7 +1351,7 @@ class Definitions {
     tpnme.Plus, tpnme.Length, tpnme.Substring, tpnme.Matches, tpnme.CharAt
   )
   private val compiletimePackageOpTypes: Set[Name] =
-    Set(tpnme.S)
+    Set(tpnme.S, tpnme.FieldsOf)
     ++ compiletimePackageAnyTypes
     ++ compiletimePackageIntTypes
     ++ compiletimePackageLongTypes
@@ -1361,6 +1364,7 @@ class Definitions {
     compiletimePackageOpTypes.contains(sym.name)
     && (
          isCompiletime_S(sym)
+      || isNamedTuple_FieldsOf(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,6 +361,7 @@ object StdNames {
     val Eql: N                  = "Eql"
     val EnumValue: N            = "EnumValue"
     val ExistentialTypeTree: N  = "ExistentialTypeTree"
+    val FieldsOf: N             = "FieldsOf"
     val Flag : N                = "Flag"
     val Ident: N                = "Ident"
     val Import: N               = "Import"

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

@@ -6,11 +6,14 @@ import Types.*, Contexts.*, Symbols.*, Constants.*, Decorators.*
 import config.Printers.typr
 import reporting.trace
 import StdNames.tpnme
+import Flags.CaseClass
+import TypeOps.nestedPairs
 
 object TypeEval:
 
   def tryCompiletimeConstantFold(tp: AppliedType)(using Context): Type = tp.tycon match
     case tycon: TypeRef if defn.isCompiletimeAppliedType(tycon.symbol) =>
+
       extension (tp: Type) def fixForEvaluation: Type =
         tp.normalized.dealias match
           // enable operations for constant singleton terms. E.g.:
@@ -94,6 +97,21 @@ object TypeEval:
             throw TypeError(em"${e.getMessage.nn}")
         ConstantType(Constant(result))
 
+      def fieldsOf: Option[Type] =
+        expectArgsNum(1)
+        val arg = tp.args.head
+        val cls = arg.classSymbol
+        if cls.is(CaseClass) then
+          val fields = cls.caseAccessors
+          val fieldLabels = fields.map: field =>
+            ConstantType(Constant(field.name.toString))
+          val fieldTypes = fields.map(arg.memberInfo)
+          Some:
+            defn.NamedTupleTypeRef.appliedTo:
+              nestedPairs(fieldLabels) :: nestedPairs(fieldTypes) :: Nil
+        else
+          None
+
       def constantFold1[T](extractor: Type => Option[T], op: T => Any): Option[Type] =
         expectArgsNum(1)
         extractor(tp.args.head).map(a => runConstantOp(op(a)))
@@ -122,11 +140,14 @@ object TypeEval:
         yield runConstantOp(op(a, b, c))
 
       trace(i"compiletime constant fold $tp", typr, show = true) {
-        val name = tycon.symbol.name
-        val owner = tycon.symbol.owner
+        val sym = tycon.symbol
+        val name = sym.name
+        val owner = sym.owner
         val constantType =
-          if defn.isCompiletime_S(tycon.symbol) then
+          if defn.isCompiletime_S(sym) then
             constantFold1(natValue, _ + 1)
+          else if defn.isNamedTuple_FieldsOf(sym) then
+            fieldsOf
           else if owner == defn.CompiletimeOpsAnyModuleClass then name match
             case tpnme.Equals     => constantFold2(constValue, _ == _)
             case tpnme.NotEquals  => constantFold2(constValue, _ != _)

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

@@ -100,6 +100,24 @@ 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` object contains a type definition
+```scala
+  type FieldsOf[T] <: AnyNamedTuple
+```
+`FieldsOf` is treated specially by the compiler. When `FieldsOf` 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
+```scala
+(zip: Int, name: String, population: Int)
+```
+The same works for enum cases expanding to case classes.
+
 ### Restrictions
 
 The following restrictions apply to named tuple elements:
@@ -130,7 +148,29 @@ SimpleExpr        ::=  ...
                     |  '(' NamedExprInParens {‘,’ NamedExprInParens} ')'
 NamedExprInParens ::=  id '=' ExprInParens
 
-SimplePattern     ::=  ...
-                    |  '(' NamedPattern {‘,’ NamedPattern} ')'
+Patterns          ::=  Pattern {‘,’ Pattern}
+                    |  NamedPattern {‘,’ NamedPattern}
 NamedPattern      ::=  id '=' Pattern
 ```
+
+### Named Pattern Matching
+
+We allow named patterns not just for named tuples but also for case classes.
+For instance:
+```scala
+city match
+  case c @ City(name = "London") => println(p.population)
+  case City(name = n, zip = 1026, population = pop) => println(pop)
+```
+
+Named constructor patterns are analogous to named tuple patterns. In both cases
+
+ - either all fields are named or none is,
+ - every name must match the name some field of the selector,
+ - names can come in any order,
+ - not all fields of the selector need to be matched.
+
+This revives SIP 43, with a much simpler desugaring than originally proposed.
+Named patterns are compatible with extensible pattern matching simply because
+`unapply` results can be named tuples.
+

library/src/scala/NamedTuple.scala

@@ -175,10 +175,12 @@ object NamedTuple:
       case true =>
         NamedTuple[Names[X], Tuple.Zip[DropNames[X], DropNames[Y]]]
 
+  type FieldsOf[T] <: AnyNamedTuple
+
 end NamedTuple
 
-@experimental
 /** Separate from NamedTuple object so that we can match on the opaque type NamedTuple. */
+@experimental
 object NamedTupleDecomposition:
   import NamedTuple.*
 

tests/neg/fieldsOf.scala

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

tests/pos/fieldsOf.scala

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

tests/run/fieldsOf.check

@@ -0,0 +1,17 @@
+-- [E007] Type Mismatch Error: ../neg/fieldsOf.scala:10:15 ---------------------
+10 |  x = foo[Anon]() // error
+   |      ^^^^^^^^^^^
+   |      Found:    NamedTuple.FieldsOf[Anon]
+   |      Required: (name : String, age : Int)
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: ../neg/fieldsOf.scala:11:9 ----------------------
+11 |  x = foo() // error
+   |      ^^^^^
+   |      Found:    NamedTuple.FieldsOf[T]
+   |      Required: (name : String, age : Int)
+   |
+   |      where:    T is a type variable
+   |
+   | longer explanation available when compiling with `-explain`
+2 errors found