Fix type in tupleApp by indexing the generic tuple components

Author: dwijnand

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

@@ -328,11 +328,11 @@ 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
+        def tupleApp(tuple: Type, 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(scrutinee.info.memberInfo(caseAccessors(i)).widen)
+            .cast(indexTupleType(tuple, i).ensuring(_ != NoType, i"Failed to find type at index $i in $tuple"))
 
         if (isSyntheticScala2Unapply(unapp.symbol) && caseAccessors.length == args.length)
           def tupleSel(sym: Symbol) = ref(scrutinee).select(sym)
@@ -342,7 +342,7 @@ object PatternMatcher {
               case tp                => tp
             !defn.isTupleNType(tp)
           }
-          val components = if isGenericTuple then caseAccessors.indices.toList.map(tupleApp(_, ref(scrutinee))) else caseAccessors.map(tupleSel)
+          val components = if isGenericTuple then caseAccessors.indices.toList.map(tupleApp(unapp.tpe.finalResultType, _, ref(scrutinee))) else caseAccessors.map(tupleSel)
           matchArgsPlan(components, args, onSuccess)
         else if (unapp.tpe <:< (defn.BooleanType))
           TestPlan(GuardTest, unapp, unapp.span, onSuccess)
@@ -362,7 +362,7 @@ object PatternMatcher {
               unapplySeqPlan(unappResult, args)
             }
             else if unappResult.info <:< defn.NonEmptyTupleTypeRef then
-              val components = (0 until foldApplyTupleType(unappResult.denot.info).length).toList.map(tupleApp(_, ref(unappResult)))
+              val components = (0 until foldApplyTupleType(unappResult.denot.info).length).toList.map(tupleApp(unappResult.info, _, ref(unappResult)))
               matchArgsPlan(components, args, onSuccess)
             else {
               assert(isGetMatch(unapp.tpe))

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

@@ -207,6 +207,11 @@ object Applications {
     end tupleFold
     tupleFold(Nil, tp).reverse
 
+  /** The component type of a generic tuple at index `idx`.  For example, `indexTupleType(A *: B *: EmptyTuple, 1) = B`. */
+  def indexTupleType(tp: Type, idx: Int)(using Context): Type = tp.widen match
+    case AppliedType(tycon, List(l, r)) if tycon.typeSymbol == defn.PairClass => if idx == 0 then l else indexTupleType(r, idx - 1)
+    case t                                                                    => NoType
+
   def wrapDefs(defs: mutable.ListBuffer[Tree], tree: Tree)(using Context): Tree =
     if (defs != null && defs.nonEmpty) tpd.Block(defs.toList, tree) else tree