Fix #23224: Optimize simple tuple extraction

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

@@ -1483,14 +1483,14 @@ object desugar {
               |please bind to an identifier and use an alias given.""", bind)
         false
 
-      def isTuplePattern(arity: Int): Boolean = pat match {
-        case Tuple(pats) if pats.size == arity =>
-          pats.forall(isVarPattern)
-        case _ => false
+      // The arity of the tuple pattern if it only contains simple variables or wildcards.
+      val varTuplePatternArity = pat match {
+        case Tuple(pats) if pats.forall(isVarPattern) => pats.length
+        case _ => -1
       }
 
       val isMatchingTuple: Tree => Boolean = {
-        case Tuple(es) => isTuplePattern(es.length) && !hasNamedArg(es)
+        case Tuple(es) => varTuplePatternArity == es.length && !hasNamedArg(es)
         case _ => false
       }
 
@@ -1519,10 +1519,28 @@ object desugar {
 
       val ids = for ((named, _) <- vars) yield Ident(named.name)
       val matchExpr =
-        if (tupleOptimizable) rhs
+        if tupleOptimizable then rhs
         else
-          val caseDef = CaseDef(pat, EmptyTree, makeTuple(ids).withAttachment(ForArtifact, ()))
+          val caseDef =
+            if varTuplePatternArity >= 0 && ids.length > 1 then
+              // If the pattern contains only simple variables or wildcards,
+              // we don't need to create a new tuple.
+              // If there is only one variable (ids.length == 1),
+              // `makeTuple` will optimize it to `Ident(named)`,
+              // so we don't need to handle that case here.
+              val tmpTuple = UniqueName.fresh()
+              // Replace all variables with wildcards in the pattern
+              val pat1 = pat match
+                case Tuple(pats) =>
+                  Tuple(pats.map(pat => Ident(nme.WILDCARD).withSpan(pat.span)))
+              CaseDef(
+                Bind(tmpTuple, pat1),
+                EmptyTree,
+                Ident(tmpTuple).withAttachment(ForArtifact, ())
+              )
+            else CaseDef(pat, EmptyTree, makeTuple(ids).withAttachment(ForArtifact, ()))
           Match(makeSelector(rhs, MatchCheck.IrrefutablePatDef), caseDef :: Nil)
+
       vars match {
         case Nil if !mods.is(Lazy) =>
           matchExpr

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

@@ -2774,6 +2774,16 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     if !isFullyDefined(pt, ForceDegree.all) then
       return errorTree(tree, em"expected type of $tree is not fully defined")
     val body1 = typed(tree.body, pt)
+
+    // If the body is a named tuple pattern, we need to use pt for symbol type,
+    // because the desugared body is a regular tuple unapply.
+    def isNamedTuplePattern =
+      ctx.mode.is(Mode.Pattern)
+      && pt.dealias.isNamedTupleType
+      && tree.body.match
+          case untpd.Tuple((_: NamedArg) :: _) => true
+          case _ => false
+
     body1 match {
       case UnApply(fn, Nil, arg :: Nil)
       if fn.symbol.exists && (fn.symbol.owner.derivesFrom(defn.TypeTestClass) || fn.symbol.owner == defn.ClassTagClass) && !body1.tpe.isError =>
@@ -2799,8 +2809,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             body1.isInstanceOf[RefTree] && !isWildcardArg(body1)
             || body1.isInstanceOf[Literal]
           val symTp =
-            if isStableIdentifierOrLiteral || pt.dealias.isNamedTupleType then pt
-              // need to combine tuple element types with expected named type
+            if isStableIdentifierOrLiteral || isNamedTuplePattern then pt
             else if isWildcardStarArg(body1)
                     || pt == defn.ImplicitScrutineeTypeRef
                     || body1.tpe <:< pt  // There is some strange interaction with gadt matching.

tests/pos/simple-tuple-extract.scala

@@ -0,0 +1,34 @@
+
+class Test:
+  def f1: (Int, Int, Int) = (1, 2, 3)
+  def f2: (x: Int, y: Int) = (3, 4)
+
+  def test1 =
+    val (a, b, c) = f1
+    // Desugared to:
+    // val $2$: (Int, Int, Int) =
+    //   this.f1:(Int, Int, Int) @unchecked match
+    //     {
+    //       case $1$ @ Tuple3.unapply[Int, Int, Int](_, _, _) =>
+    //         $1$:(Int, Int, Int)
+    //     }
+    // val a: Int = $2$._1
+    // val b: Int = $2$._2
+    // val c: Int = $2$._3
+    a + b + c
+
+  def test2 =
+    val (_, d, e) = f1
+    e + e
+
+  def test3 =
+    val (_, f, _) = f1
+    f + f
+
+  def test4 =
+    val (x, y) = f2
+    x + y
+
+  def test5 =
+    val (_, a) = f2
+    a + a