Complete implementation of pattern matching for named tuples

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1445,14 +1445,26 @@ object desugar {
       AppliedTypeTree(
         TypeTree(defn.throwsAlias.typeRef).withSpan(op.span), tpt :: excepts :: Nil)
 
+  private def checkMismatched(elems: List[Tree])(using Context) = elems match
+    case elem :: elems1 =>
+      val misMatchOpt =
+        if elem.isInstanceOf[NamedArg]
+        then elems1.find(!_.isInstanceOf[NamedArg])
+        else elems1.find(_.isInstanceOf[NamedArg])
+      for misMatch <- misMatchOpt do
+        report.error(em"Illegal combination of named and unnamed tuple elements", misMatch.srcPos)
+    case _ =>
+
   /** Translate tuple expressions of arity <= 22
    *
    *     ()             ==>   ()
    *     (t)            ==>   t
    *     (t1, ..., tN)  ==>   TupleN(t1, ..., tN)
    */
-  def tuple(tree: Tuple)(using Context): Tree =
-    val elems = tree.trees.mapConserve(desugarTupleElem)
+  def tuple(tree: Tuple, pt: Type)(using Context): Tree =
+    checkMismatched(tree.trees)
+    val adapted = adaptTupleElems(tree.trees, pt)
+    val elems = adapted.mapConserve(desugarTupleElem)
     val arity = elems.length
     if arity <= Definitions.MaxTupleArity then
       def tupleTypeRef = defn.TupleType(arity).nn
@@ -1465,20 +1477,67 @@ object desugar {
     else
       cpy.Tuple(tree)(elems)
 
-  private def desugarTupleElem(elem: untpd.Tree)(using Context): untpd.Tree = elem match
+  def adaptTupleElems(elems: List[Tree], pt: Type)(using Context): List[Tree] =
+
+    def reorderedNamedArgs(selElems: List[Type], wildcardSpan: Span): List[untpd.Tree] =
+      val nameIdx =
+        for case (defn.NamedTupleElem(name, _), idx) <- selElems.zipWithIndex yield
+          (name, idx)
+      val nameToIdx = nameIdx.toMap[Name, Int]
+      val reordered = Array.fill[untpd.Tree](selElems.length):
+        untpd.Ident(nme.WILDCARD).withSpan(wildcardSpan)
+      for case arg @ NamedArg(name, _) <- elems do
+        nameToIdx.get(name) match
+          case Some(idx) =>
+            if reordered(idx).isInstanceOf[Ident] then
+              reordered(idx) = arg
+            else
+              report.error(em"Duplicate named pattern", arg.srcPos)
+          case _ =>
+            report.error(em"No element named `$name` is defined", arg.srcPos)
+      reordered.toList
+
+    def convertedToNamedArgs(selElems: List[Type]): List[untpd.Tree] =
+      elems.lazyZip(selElems).map:
+        case (arg, defn.NamedTupleElem(name, _)) =>
+          arg match
+            case NamedArg(_, _) => arg // can arise for malformed elements
+            case _ => NamedArg(name, arg)
+        case (arg, _) =>
+          arg
+
+    pt.tupleElementTypes match
+      case Some(selElems @ (firstSelElem :: _)) if ctx.mode.is(Mode.Pattern) =>
+        elems match
+          case (first @ NamedArg(_, _)) :: _ =>
+            reorderedNamedArgs(selElems, first.span.startPos)
+          case _ =>
+            if firstSelElem.isNamedTupleElem
+            then convertedToNamedArgs(selElems)
+            else elems
+      case _ =>
+        elems
+  end adaptTupleElems
+
+  private def desugarTupleElem(elem: Tree)(using Context): Tree = elem match
     case NamedArg(name, arg) =>
-      val nameLit = untpd.Literal(Constant(name.toString))
-      if ctx.mode.is(Mode.Type) then
-        untpd.AppliedTypeTree(untpd.ref(defn.Tuple_NamedValueType),
-          untpd.SingletonTypeTree(nameLit) :: arg :: Nil)
-      else if ctx.mode.is(Mode.Pattern) then
-        untpd.Apply(
-          untpd.Block(Nil,
-            untpd.TypeApply(untpd.ref(defn.Tuple_NamedValue_extract),
-              untpd.SingletonTypeTree(nameLit) :: Nil)),
-          arg :: Nil)
-      else
-        untpd.Apply(untpd.ref(defn.Tuple_NamedValue_apply), nameLit :: arg :: Nil)
+      locally:
+        val nameLit = Literal(Constant(name.toString))
+        if ctx.mode.is(Mode.Type) then
+          AppliedTypeTree(ref(defn.Tuple_NamedValueTypeRef),
+            SingletonTypeTree(nameLit) :: arg :: Nil)
+        else if ctx.mode.is(Mode.Pattern) then
+          Apply(
+            Block(Nil,
+              TypeApply(
+                untpd.Select(untpd.ref(defn.Tuple_NamedValueModuleRef), nme.extract),
+                SingletonTypeTree(nameLit) :: Nil)),
+            arg :: Nil)
+        else
+          Apply(
+            Select(ref(defn.Tuple_NamedValueModuleRef), nme.apply),
+            nameLit :: arg :: Nil)
+      .withSpan(elem.span)
     case _ =>
       elem
 

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

@@ -938,13 +938,11 @@ class Definitions {
   def TupleClass(using Context): ClassSymbol = TupleTypeRef.symbol.asClass
     @tu lazy val Tuple_cons: Symbol = TupleClass.requiredMethod("*:")
   @tu lazy val TupleModule: Symbol = requiredModule("scala.Tuple")
-    @tu lazy val TupleNamedValueModule: Symbol = requiredModule("scala.Tuple.NamedValue")
-    @tu lazy val Tuple_NamedValue_apply: Symbol = TupleNamedValueModule.requiredMethod("apply")
-    @tu lazy val Tuple_NamedValue_extract: Symbol = TupleNamedValueModule.requiredMethod("extract")
 
-    def Tuple_NamedValueType: TypeRef = TupleModule.termRef.select("NamedValue".toTypeName).asInstanceOf
+    def Tuple_NamedValueTypeRef: TypeRef = TupleModule.termRef.select("NamedValue".toTypeName).asInstanceOf
+    def Tuple_NamedValueModuleRef: TermRef = TupleModule.termRef.select("NamedValue".toTermName).asInstanceOf
       // Note: It would be dangerous to expose NamedValue as a symbol, since
-      // NamedValue.typeRef gives the internal view of NamedValue inside Tuple
+      // NamedValue.{typeRef/termRef} give the internal view of NamedValue inside Tuple
       // which reveals the opaque alias. To see it externally, we need the construction
       // above. Without this tweak, named-tuples.scala fails -Ycheck after typer.
 
@@ -1315,10 +1313,10 @@ class Definitions {
 
   object NamedTupleElem:
     def apply(name: Name, tp: Type)(using Context): Type =
-      AppliedType(Tuple_NamedValueType, ConstantType(Constant(name.toString)) :: tp :: Nil)
+      AppliedType(Tuple_NamedValueTypeRef, ConstantType(Constant(name.toString)) :: tp :: Nil)
     def unapply(t: Type)(using Context): Option[(TermName, Type)] = t match
       case AppliedType(tycon, ConstantType(Constant(s: String)) :: tp :: Nil)
-        if tycon.typeSymbol == Tuple_NamedValueType.typeSymbol => Some((s.toTermName, tp))
+        if tycon.typeSymbol == Tuple_NamedValueTypeRef.typeSymbol => Some((s.toTermName, tp))
       case _ => None
 
   final def isCompiletime_S(sym: Symbol)(using Context): Boolean =

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

@@ -479,6 +479,7 @@ object StdNames {
     val eqlAny: N               = "eqlAny"
     val ex: N                   = "ex"
     val extension: N            = "extension"
+    val extract: N              = "extract"
     val experimental: N         = "experimental"
     val f: N                    = "f"
     val false_ : N              = "false"

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

@@ -1447,6 +1447,7 @@ trait Applications extends Compatibility {
 
         val dummyArg = dummyTreeOfType(ownType)
         val unapplyApp = typedExpr(untpd.TypedSplice(Apply(unapplyFn, dummyArg :: Nil)))
+
         def unapplyImplicits(unapp: Tree): List[Tree] = {
           val res = List.newBuilder[Tree]
           def loop(unapp: Tree): Unit = unapp match {
@@ -1481,7 +1482,7 @@ trait Applications extends Compatibility {
         else tryWithTypeTest(Typed(result, TypeTree(ownType)), selType)
       case tp =>
         val unapplyErr = if (tp.isError) unapplyFn else notAnExtractor(unapplyFn)
-        val typedArgsErr = args mapconserve (typed(_, defn.AnyType))
+        val typedArgsErr = args.mapconserve(typed(_, defn.AnyType))
         cpy.UnApply(tree)(unapplyErr, Nil, typedArgsErr) withType unapplyErr.tpe
     }
   }

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

@@ -851,6 +851,15 @@ object Checking {
     templ.parents.find(_.tpe.derivesFrom(defn.PolyFunctionClass)) match
       case Some(parent) => report.error(s"`PolyFunction` marker trait is reserved for compiler generated refinements", parent.srcPos)
       case None =>
+
+  /** Check that `tp` is not a tuple containing a mixture of named and unnamed elements */
+  def checkTupleWF(tp: Type, pos: SrcPos, kind: String = "")(using Context): Unit =
+    tp.tupleElementTypes match
+      case Some(elem :: elems1)
+      if elem.isNamedTupleElem && elems1.exists(!_.isNamedTupleElem)
+      || !elem.isNamedTupleElem && elems1.exists(_.isNamedTupleElem) =>
+        report.error(em"Illegal combination of named and unnamed tuple elements in$kind type $tp", pos)
+      case _ =>
 }
 
 trait Checking {

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

@@ -712,9 +712,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         case _ => false
       if nameIdx >= 0 && Feature.enabled(Feature.namedTuples) then
         typed(
-          untpd.Apply(
-            untpd.Select(untpd.TypedSplice(qual), nme.apply),
-            untpd.Literal(Constant(nameIdx))),
+          untpd.Select(
+            untpd.Apply(
+              untpd.Select(untpd.TypedSplice(qual), nme.apply),
+              untpd.Literal(Constant(nameIdx))),
+            nme.value),
           pt)
       else if qual.tpe.isSmallGenericTuple then
         typedSelect(tree, pt, qual.cast(defn.tupleType(tupleElems)))
@@ -1801,6 +1803,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         val selType = rawSelectorTpe match
           case c: ConstantType if tree.isInline => c
           case otherTpe => otherTpe.widen
+        checkTupleWF(selType, tree.selector.srcPos, " expression's")
 
         /** Does `tree` has the same shape as the given match type?
          *  We only support typed patterns with empty guards, but
@@ -3068,7 +3071,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
   /** Translate tuples of all arities */
   def typedTuple(tree: untpd.Tuple, pt: Type)(using Context): Tree =
-    val tree1 = desugar.tuple(tree)
+    val tree1 = desugar.tuple(tree, pt)
     if tree1 ne tree then typed(tree1, pt)
     else
       val arity = tree.trees.length

tests/neg/i7751.scala

@@ -1,3 +1,3 @@
 import language.`3.3`
-val a = Some(a=a,)=> // error // error
+val a = Some(a=a,)=> // error // error // error
 val a = Some(x=y,)=>

tests/neg/named-tuples.check

@@ -26,3 +26,27 @@
    |                                    Required: (age: Int, name: String)
    |
    | longer explanation available when compiling with `-explain`
+-- Error: tests/neg/named-tuples.scala:20:10 ---------------------------------------------------------------------------
+20 |    case (name = n, age = a) => () // error // error
+   |          ^^^^^^^^
+   |          No element named `name` is defined
+-- Error: tests/neg/named-tuples.scala:20:20 ---------------------------------------------------------------------------
+20 |    case (name = n, age = a) => () // error // error
+   |                    ^^^^^^^
+   |                    No element named `age` is defined
+-- Error: tests/neg/named-tuples.scala:25:9 ----------------------------------------------------------------------------
+25 |  person ++ (1, 2) match // error
+   |  ^^^^^^^^^^^^^^^^
+   | Illegal combination of named and unnamed tuple elements in expression's type (name: String, age: Int, Int, Int)
+-- Error: tests/neg/named-tuples.scala:28:17 ---------------------------------------------------------------------------
+28 |  val bad = ("", age = 10) // error
+   |                 ^^^^^^^^
+   |                 Illegal combination of named and unnamed tuple elements
+-- Error: tests/neg/named-tuples.scala:31:20 ---------------------------------------------------------------------------
+31 |    case (name = n, age) => () // error
+   |                    ^^^
+   |                    Illegal combination of named and unnamed tuple elements
+-- Error: tests/neg/named-tuples.scala:32:16 ---------------------------------------------------------------------------
+32 |    case (name, age = a) => () // error
+   |                ^^^^^^^
+   |                Illegal combination of named and unnamed tuple elements

tests/neg/named-tuples.scala

@@ -15,3 +15,20 @@ import language.experimental.namedTuples
   val _: Person = nameOnly // error
 
   val _: (age: Int, name: String) = person // error
+
+  ("Ives", 2) match
+    case (name = n, age = a) => () // error // error
+
+  val pp = person ++ (1, 2)  // ok, but should also be error
+  val qq = ("a", true) ++ (1, 2)
+
+  person ++ (1, 2) match // error
+    case _ =>
+
+  val bad = ("", age = 10) // error
+
+  person match
+    case (name = n, age) => () // error
+    case (name, age = a) => () // error
+
+

tests/run/named-tuples.scala

@@ -1,4 +1,3 @@
-import annotation.experimental
 import language.experimental.namedTuples
 import NamedTuple.dropNames
 
@@ -76,8 +75,20 @@ val _: CombinedInfo = bob ++ addr
 // But then we could not do this:
 
   def swap[A, B](x: (A, B)): (B, A) = (x(1), x(0))
-
   val bobS = swap(bob)
   val _: (age: Int, name: String) = bobS
 
+  val silly = bob match
+    case (name, age) => name.length + age
+
+  assert(silly == 36)
+
+  val minors = persons.filter:
+    case (age = a) => a < 18
+    case _ => false
 
+  assert(minors.isEmpty)
+
+  bob match
+    case (age = 33, name = "Bob") => ()
+    case _ => assert(false)