Fix #10958: handle tupling for generic tuples without affecting patmat

This commit refactor the PR #5259 so that it will not impact pattern
matching code. The phase patternMatcher requires members `_N` for to
generate correct code.

#5259

Author: liufengyun

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

@@ -111,21 +111,23 @@ object Applications {
   }
 
   def productSelectorTypes(tp: Type, errorPos: SrcPos)(using Context): List[Type] = {
-    def tupleSelectors(n: Int, tp: Type): List[Type] = {
-      val sel = extractorMemberType(tp, nme.selectorName(n), errorPos)
-      // extractorMemberType will return NoType if this is the tail of tuple with an unknown tail
-      // such as `Int *: T` where `T <: Tuple`.
-      if (sel.exists) sel :: tupleSelectors(n + 1, tp) else Nil
-    }
-    def genTupleSelectors(n: Int, tp: Type): List[Type] = tp match {
-      case tp: AppliedType if !defn.isTupleClass(tp.tycon.typeSymbol) && tp.derivesFrom(defn.PairClass) =>
-        val List(head, tail) = tp.args
-        head :: genTupleSelectors(n, tail)
-      case _ => tupleSelectors(n, tp)
-    }
-    genTupleSelectors(0, tp)
+    val sels = for (n <- Iterator.from(0)) yield extractorMemberType(tp, nme.selectorName(n), errorPos)
+    sels.takeWhile(_.exists).toList
   }
 
+  def tupleComponentTypes(tp: Type)(using Context): List[Type] =
+    tp match
+    case tp: AppliedType =>
+      if defn.isTupleClass(tp.tycon.typeSymbol) then
+        tp.args
+      else if tp.tycon.derivesFrom(defn.PairClass) then
+        val List(head, tail) = tp.args
+        head :: tupleComponentTypes(tail)
+      else
+        Nil
+    case _ =>
+      Nil
+
   def productArity(tp: Type, errorPos: SrcPos = NoSourcePosition)(using Context): Int =
     if (defn.isProductSubType(tp)) productSelectorTypes(tp, errorPos).size else -1
 

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

@@ -30,7 +30,7 @@ import TypeComparer.CompareResult
 import util.Spans._
 import util.common._
 import util.{Property, SimpleIdentityMap, SrcPos}
-import Applications.{ExtMethodApply, IntegratedTypeArgs, productSelectorTypes, wrapDefs}
+import Applications.{ExtMethodApply, IntegratedTypeArgs, tupleComponentTypes, wrapDefs}
 
 import collection.mutable
 import annotation.tailrec
@@ -1257,8 +1257,8 @@ class Typer extends Namer
     /** Is `formal` a product type which is elementwise compatible with `params`? */
     def ptIsCorrectProduct(formal: Type) =
       isFullyDefined(formal, ForceDegree.flipBottom) &&
-      (defn.isProductSubType(formal) || formal.derivesFrom(defn.PairClass)) &&
-      productSelectorTypes(formal, tree.srcPos).corresponds(params) {
+      defn.isProductSubType(formal) &&
+      tupleComponentTypes(formal).corresponds(params) {
         (argType, param) =>
           param.tpt.isEmpty || argType.widenExpr <:< typedAheadType(param.tpt).tpe
       }

library/src-non-bootstrapped/scala/Tuple.scala

@@ -199,7 +199,7 @@ object Tuple {
   def apply(): EmptyTuple = EmptyTuple
 
   /** Tuple with one element */
-  def apply[T](x: T): T *: EmptyTuple = Tuple1(x)
+  def apply[T](x: T): Tuple1[T] = Tuple1(x)
 
   /** Matches an empty tuple. */
   def unapply(x: EmptyTuple): true = true

scala3doc/src/dotty/renderers/MemberRenderer.scala

@@ -33,7 +33,7 @@ class MemberRenderer(signatureRenderer: SignatureRenderer, buildNode: ContentNod
     case Origin.Overrides(defs) =>
       def renderDef(d: Overriden): Seq[TagArg] =
         Seq(" -> ", signatureRenderer.renderLink(d.name, d.dri))
-      val headNode = m.inheritedFrom.map(signatureRenderer.renderLink(_, _))
+      val headNode = m.inheritedFrom.map(form => signatureRenderer.renderLink(form.name, form.dri))
       val tailNodes = defs.flatMap(renderDef)
       val nodes = headNode.fold(tailNodes.drop(1))(_ +: tailNodes)
       tableRow("Definition Classes", div(nodes:_*))

tests/run/i10958.scala

@@ -0,0 +1,8 @@
+object U:
+  def unapply(s:String) = Tuple(s) // specifying the type :Tuple1[String] fixes the issue
+
+@main
+def Test =
+  "" match
+  case s"${U(u)})" =>
+    val x: String = u