Switch handling of regular tuple patterns

When matching a regular tuple pattern against a named tuple selector
we adapted the tuple to be named, which could hide errors. We now
adapt the selector to be unnamed instead.

Author: odersky

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

@@ -1461,9 +1461,9 @@ object desugar {
    *     (t)            ==>   t
    *     (t1, ..., tN)  ==>   TupleN(t1, ..., tN)
    */
-  def tuple(tree: Tuple, pt: Type)(using Context): Tree =
+  def tuple(tree: Tuple, pt: Type)(using Context): (Tree, Type) =
     checkMismatched(tree.trees)
-    val adapted = adaptTupleElems(tree.trees, pt)
+    val (adapted, pt1) = adaptTupleElems(tree.trees, pt)
     val elems = adapted.mapConserve(desugarTupleElem)
     val arity = elems.length
     if arity <= Definitions.MaxTupleArity then
@@ -1473,11 +1473,11 @@ object desugar {
           if ctx.mode is Mode.Type then TypeTree(defn.UnitType) else unitLiteral
         else if ctx.mode is Mode.Type then AppliedTypeTree(ref(tupleTypeRef), elems)
         else Apply(ref(tupleTypeRef.classSymbol.companionModule.termRef), elems)
-      tree1.withSpan(tree.span)
+      (tree1.withSpan(tree.span), pt1)
     else
-      cpy.Tuple(tree)(elems)
+      (cpy.Tuple(tree)(elems), pt1)
 
-  def adaptTupleElems(elems: List[Tree], pt: Type)(using Context): List[Tree] =
+  def adaptTupleElems(elems: List[Tree], pt: Type)(using Context): (List[Tree], Type) =
 
     def reorderedNamedArgs(selElems: List[Type], wildcardSpan: Span): List[untpd.Tree] =
       val nameIdx =
@@ -1497,26 +1497,15 @@ object desugar {
             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) =>
+      case Some(selElems) if ctx.mode.is(Mode.Pattern) =>
         elems match
           case (first @ NamedArg(_, _)) :: _ =>
-            reorderedNamedArgs(selElems, first.span.startPos)
+            (reorderedNamedArgs(selElems, first.span.startPos), pt)
           case _ =>
-            if firstSelElem.isNamedTupleElem
-            then convertedToNamedArgs(selElems)
-            else elems
+            (elems, pt.dropNamedTupleElems)
       case _ =>
-        elems
+        (elems, pt)
   end adaptTupleElems
 
   private def desugarTupleElem(elem: Tree)(using Context): Tree = elem match
@@ -1527,12 +1516,7 @@ object desugar {
           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)
+          NamedElemPattern(name, arg)
         else
           Apply(
             Select(ref(defn.Tuple_NamedValueModuleRef), nme.apply),

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

@@ -481,6 +481,31 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
       if id.span == result.span.startPos => Some(result)
       case _ => None
   end ImpureByNameTypeTree
+
+  /** The desugared version of a named tuple element pattern `name = elem`
+   *  (unapply is currently unused)
+   */
+  object NamedElemPattern:
+
+    def apply(name: Name, elem: Tree)(using Context): Tree =
+      Apply(
+        Block(Nil,
+          TypeApply(
+            untpd.Select(untpd.ref(defn.Tuple_NamedValueModuleRef), nme.extract),
+            SingletonTypeTree(Literal(Constant(name.toString))) :: Nil)),
+        elem :: Nil)
+
+    def unapply(tree: Tree)(using Context): Option[(TermName, Tree)] = tree match
+      case Apply(
+        Block(Nil,
+          TypeApply(
+            untpd.Select(TypedSplice(namedValue), nme.extract),
+            SingletonTypeTree(Literal(Constant(name: String))) :: Nil)),
+        elem :: Nil) if namedValue.symbol == defn.Tuple_NamedValueModuleRef.symbol =>
+        Some((name.toTermName, elem))
+      case _ => None
+
+  end NamedElemPattern
 }
 
 trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>

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

@@ -89,7 +89,28 @@ class TypeUtils {
           case _ => false
 
     /** Is this type a named tuple element `name = value`? */
-    def isNamedTupleElem(using Context): Boolean = defn.NamedTupleElem.unapply(self).isDefined
+    def isNamedTupleElem(using Context): Boolean = dropNamedTupleElem ne self
+
+    /** Rewrite `name = elem` to `elem` */
+    def dropNamedTupleElem(using Context) = self match
+      case defn.NamedTupleElem(_, elem) => elem
+      case elem => elem
+
+    /** Drop all named elements in tuple type */
+    def dropNamedTupleElems(using Context): Type = self match
+      case AppliedType(tycon, hd :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
+        val hd1 = hd.dropNamedTupleElem
+        val tl1 = tl.dropNamedTupleElems
+        if (hd1 eq hd) && (tl1 eq tl) then self else AppliedType(tycon, hd1 :: tl1 :: Nil)
+      case tp @ AppliedType(tycon, args) if defn.isTupleNType(tp) =>
+        tp.derivedAppliedType(tycon, args.mapConserve(_.dropNamedTupleElem))
+      case _ =>
+        if self.termSymbol ne defn.EmptyTupleModule then
+          val normed = self.widen.normalized.dealias
+          if normed ne self then
+            val normed1 = normed.dropNamedTupleElems
+            if normed1 ne normed then return normed1
+        self
 
     /** The `*:` equivalent of an instance of a Tuple class */
     def toNestedPairs(using Context): Type =

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

@@ -3071,8 +3071,8 @@ 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, pt)
-    if tree1 ne tree then typed(tree1, pt)
+    val (tree1, pt1) = desugar.tuple(tree, pt)
+    if (tree1 ne tree) || (pt1 ne pt) then typed(tree1, pt1)
     else
       val arity = tree.trees.length
       val pts = pt.tupleElementTypes match

tests/neg/named-tuples-2.check

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

tests/neg/named-tuples-2.scala

@@ -0,0 +1,6 @@
+import language.experimental.namedTuples
+def Test =
+  val person = (name = "Bob", age = 33, married = true)
+  person match
+    case (name, age) => () // error
+    case (n, a, m, x) => () // error

tests/neg/named-tuples.scala

@@ -30,5 +30,3 @@ import language.experimental.namedTuples
   person match
     case (name = n, age) => () // error
     case (name, age = a) => () // error
-
-

tests/run/named-tuples.scala

@@ -90,5 +90,8 @@ val _: CombinedInfo = bob ++ addr
   assert(minors.isEmpty)
 
   bob match
-    case (age = 33, name = "Bob") => ()
+    case bob1 @ (age = 33, name = "Bob") =>
+      val x: Person = bob1 // bob1 still has type Person with the unswapped elements
     case _ => assert(false)
+
+