Two fixes to NamedTuple pattern matching

 1. Fix translation for named patterns where the selector is a single-element
    named tuple. We used to take the whole tuple as result (which is correct
    for unnamed patterns) but for named patterns we have to select the field
    instead.
 2. Take account of named patterns in the refutability check.

Author: odersky

compiler/src/dotty/tools/dotc/transform/FirstTransform.scala

@@ -19,10 +19,14 @@ import NameKinds.OuterSelectName
 import StdNames.*
 import config.Feature
 import inlines.Inlines.inInlineMethod
+import util.Property
 
 object FirstTransform {
   val name: String = "firstTransform"
   val description: String = "some transformations to put trees into a canonical form"
+
+  /** Attachment key for named argument patterns */
+  val WasNamedArg: Property.StickyKey[Unit] = Property.StickyKey()
 }
 
 /** The first tree transform
@@ -38,6 +42,7 @@ object FirstTransform {
  */
 class FirstTransform extends MiniPhase with SymTransformer { thisPhase =>
   import ast.tpd.*
+  import FirstTransform.*
 
   override def phaseName: String = FirstTransform.name
 
@@ -156,7 +161,13 @@ class FirstTransform extends MiniPhase with SymTransformer { thisPhase =>
 
   override def transformOther(tree: Tree)(using Context): Tree = tree match {
     case tree: Export => EmptyTree
-    case tree: NamedArg => transformAllDeep(tree.arg)
+    case tree: NamedArg =>
+      val res = transformAllDeep(tree.arg)
+      if ctx.mode.is(Mode.Pattern) then
+        // Need to keep NamedArg status for pattern matcher to work correctly when faced
+        // with single-element named tuples.
+        res.pushAttachment(WasNamedArg, ())
+      res
     case tree => if (tree.isType) toTypeTree(tree) else tree
   }
 

compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala

@@ -386,9 +386,20 @@ object PatternMatcher {
                   }
                 else
                   letAbstract(get) { getResult =>
-                    val selectors =
-                      if (args.tail.isEmpty) ref(getResult) :: Nil
-                      else productSelectors(getResult.info).map(ref(getResult).select(_))
+                    def isUnaryNamedTupleSelectArg(arg: Tree) =
+                      get.tpe.widenDealias.isNamedTupleType
+                      && arg.removeAttachment(FirstTransform.WasNamedArg).isDefined
+                    // Special case: Normally, we pull out the argument wholesale if
+                    // there is only one. But if the argument is a named argument for
+                    // a single-element named tuple, we have to select the field instead.
+                    // NamedArg trees are eliminated in FirstTransform but for named arguments
+                    // of patterns we add a WasNamedArg attachment, which is used to guide the
+                    // logic here. See i22900.scala for test cases.
+                    val selectors = args match
+                      case arg :: Nil if !isUnaryNamedTupleSelectArg(arg) =>
+                        ref(getResult) :: Nil
+                      case _ =>
+                        productSelectors(getResult.info).map(ref(getResult).select(_))
                     matchArgsPlan(selectors, args, onSuccess)
                   }
               }

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

@@ -1040,6 +1040,8 @@ trait Checking {
             pats.forall(recur(_, pt))
           case Typed(arg, tpt) =>
             check(pat, pt) && recur(arg, pt)
+          case NamedArg(name, pat) =>
+            recur(pat, pt)
           case Ident(nme.WILDCARD) =>
             true
           case pat: QuotePattern =>

tests/run/i22900.scala

@@ -0,0 +1,26 @@
+object NameBaseExtractor {
+  def unapply(x: Int): Some[(someName: Int)] = Some((someName = x + 3))
+}
+object NameBaseExtractor2 {
+  def unapply(x: Int): Some[(someName: Int, age: Int)] = Some((someName = x + 3, age = x + 4))
+}
+@main
+def Test =
+  val x1 = 3 match
+    case NameBaseExtractor(someName = x) => x
+  println(x1)
+  val NameBaseExtractor(someName = x2) = 3
+  println(x2)
+  val NameBaseExtractor((someName = x3)) = 3
+  println(x3)
+
+  val NameBaseExtractor2(someName = x4, age = x5) = 3
+  println(x4)
+  println(x5)
+
+  val NameBaseExtractor2((someName = x6, age = x7)) = 3
+  println(x6)
+  println(x7)
+
+  val NameBaseExtractor(y1) = 3
+  println(y1)

tests/run/i22900a.scala

@@ -0,0 +1,15 @@
+case class C(someName: Int)
+
+object NameBaseExtractor3 {
+  def unapply(x: Int): Some[C] = Some(C(someName = x + 3))
+}
+
+@main
+def Test = {
+  val C(someName = xx) = C(3)
+  println(xx)
+  val NameBaseExtractor3(C(someName = x)) = 3
+  println(x)
+  C(3) match
+    case C(someName = xx) => println(xx)
+}