Merge pull request #14434 from dotty-staging/fix-11008

Fix #11008: Support generic tuples as a valid unapply result

Author: anatoliykmetyuk

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

@@ -8,7 +8,7 @@ import collection.mutable
 import Symbols._, Contexts._, Types._, StdNames._, NameOps._
 import ast.Trees._
 import util.Spans._
-import typer.Applications.{isProductMatch, isGetMatch, isProductSeqMatch, productSelectors, productArity, unapplySeqTypeElemTp}
+import typer.Applications.*
 import SymUtils._
 import Flags._, Constants._
 import Decorators._
@@ -329,15 +329,16 @@ object PatternMatcher {
         def isSyntheticScala2Unapply(sym: Symbol) =
           sym.isAllOf(SyntheticCase) && sym.owner.is(Scala2x)
 
+        def tupleApp(i: Int, receiver: Tree) = // manually inlining the call to NonEmptyTuple#apply, because it's an inline method
+          ref(defn.RuntimeTuplesModule)
+            .select(defn.RuntimeTuples_apply)
+            .appliedTo(receiver, Literal(Constant(i)))
+            .cast(args(i).tpe.widen)
+
         if (isSyntheticScala2Unapply(unapp.symbol) && caseAccessors.length == args.length)
           def tupleSel(sym: Symbol) = ref(scrutinee).select(sym)
-          def tupleApp(i: Int) = // manually inlining the call to NonEmptyTuple#apply, because it's an inline method
-            ref(defn.RuntimeTuplesModule)
-              .select(defn.RuntimeTuples_apply)
-              .appliedTo(ref(scrutinee), Literal(Constant(i)))
-              .cast(args(i).tpe.widen)
           val isGenericTuple = defn.isTupleClass(caseClass) && !defn.isTupleNType(tree.tpe)
-          val components = if isGenericTuple then caseAccessors.indices.toList.map(tupleApp) else caseAccessors.map(tupleSel)
+          val components = if isGenericTuple then caseAccessors.indices.toList.map(tupleApp(_, ref(scrutinee))) else caseAccessors.map(tupleSel)
           matchArgsPlan(components, args, onSuccess)
         else if (unapp.tpe <:< (defn.BooleanType))
           TestPlan(GuardTest, unapp, unapp.span, onSuccess)
@@ -356,6 +357,9 @@ object PatternMatcher {
             else if (isUnapplySeq && unapplySeqTypeElemTp(unapp.tpe.widen.finalResultType).exists) {
               unapplySeqPlan(unappResult, args)
             }
+            else if unappResult.info <:< defn.NonEmptyTupleTypeRef then
+              val components = (0 until foldApplyTupleType(unappResult.denot.info).length).toList.map(tupleApp(_, ref(unappResult)))
+              matchArgsPlan(components, args, onSuccess)
             else {
               assert(isGetMatch(unapp.tpe))
               val argsPlan = {

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

@@ -173,6 +173,7 @@ object Applications {
       val elemTp = unapplySeqTypeElemTp(tp)
       if (elemTp.exists) args.map(Function.const(elemTp))
       else if (isProductSeqMatch(tp, args.length, pos)) productSeqSelectors(tp, args.length, pos)
+      else if tp.derivesFrom(defn.NonEmptyTupleClass) then foldApplyTupleType(tp)
       else fallback
     }
 
@@ -193,10 +194,22 @@ object Applications {
         productSelectorTypes(unapplyResult, pos)
           // this will cause a "wrong number of arguments in pattern" error later on,
           // which is better than the message in `fail`.
+      else if unapplyResult.derivesFrom(defn.NonEmptyTupleClass) then
+        foldApplyTupleType(unapplyResult)
       else fail
     }
   }
 
+  def foldApplyTupleType(tp: Type)(using Context): List[Type] =
+    object tupleFold extends TypeAccumulator[List[Type]]:
+      override def apply(accum: List[Type], t: Type): List[Type] =
+        t match
+          case AppliedType(tycon, x :: x2 :: Nil) if tycon.typeSymbol == defn.PairClass =>
+            apply(x :: accum, x2)
+          case x => foldOver(accum, x)
+    end tupleFold
+    tupleFold(Nil, tp).reverse
+
   def wrapDefs(defs: mutable.ListBuffer[Tree], tree: Tree)(using Context): Tree =
     if (defs != null && defs.nonEmpty) tpd.Block(defs.toList, tree) else tree
 

tests/run/i11008.check

@@ -0,0 +1,2 @@
+hello
+hello and 10

tests/run/i11008.scala

@@ -0,0 +1,13 @@
+object A:
+  def unapply(s: String): String *: EmptyTuple = Tuple1(s)
+
+object B:
+  def unapply(s:String): String *: Int *: EmptyTuple = Tuple2(s, 10)
+
+@main def Test =
+  "hello" match
+    case A(x) =>
+      println(x)
+  "hello" match
+    case B(x, y) =>
+      println(s"$x and $y")

tests/run/i11008b.check

@@ -0,0 +1 @@
+Many 3 characters List(f, o, o)

tests/run/i11008b.scala

@@ -0,0 +1,7 @@
+object Foo:
+  def unapplySeq(x: String): Int *: Seq[String] *: EmptyTuple = (x.length, x.toList.map(_.toString))
+
+@main def Test =
+  "foo" match
+    case Foo(1, c) => println("One character " + c)
+    case Foo(x, xs*) => println(s"Many $x characters $xs")