handle generic tuples of different arity

Author: bishabosha

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

@@ -281,21 +281,34 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
 
   private def productMirror(mirroredType: Type, formal: Type, span: Span)(using Context): TreeWithErrors =
 
-    var isSafeGenericTuple = Option.empty[List[Type]]
+    var isSafeGenericTuple = Option.empty[(Symbol, List[Type])]
+
+    /** do all parts match the class symbol? Or can we extract a generic tuple type out? */
+    def acceptable(tp: Type, cls: Symbol): Boolean =
+      var genericTupleParts = List.empty[(Symbol, List[Type])]
+
+      def acceptableGenericTuple(tp: AppliedType): Boolean =
+        val tupleArgs = tp.tupleElementTypes
+        val arity = tupleArgs.size
+        val isOk = arity <= Definitions.MaxTupleArity
+        if isOk then
+          genericTupleParts ::= {
+            val cls = defn.TupleType(arity).nn.classSymbol
+            (cls, tupleArgs)
+          }
+        isOk
 
-    def illegalGenericTuple(tp: AppliedType): Boolean =
-      val tupleArgs = tp.tupleElementTypes
-      val isTooLarge = tupleArgs.length > Definitions.MaxTupleArity
-      isSafeGenericTuple = Option.when(!isTooLarge)(tupleArgs)
-      isTooLarge
+      def inner(tp: Type, cls: Symbol): Boolean = tp match
+        case tp: HKTypeLambda if tp.resultType.isInstanceOf[HKTypeLambda] => false
+        case tp @ AppliedType(cons: TypeRef, _) if cons.isRef(defn.PairClass) => acceptableGenericTuple(tp)
+        case tp: TypeProxy    => inner(tp.underlying, cls)
+        case OrType(tp1, tp2) => inner(tp1, cls) && inner(tp2, cls)
+        case _                => tp.classSymbol eq cls
 
-    /** do all parts match the class symbol? */
-    def acceptable(tp: Type, cls: Symbol): Boolean = tp match
-      case tp: HKTypeLambda if tp.resultType.isInstanceOf[HKTypeLambda] => false
-      case tp @ AppliedType(cons: TypeRef, _) if cons.isRef(defn.PairClass) && illegalGenericTuple(tp) => false
-      case tp: TypeProxy    => acceptable(tp.underlying, cls)
-      case OrType(tp1, tp2) => acceptable(tp1, cls) && acceptable(tp2, cls)
-      case _                => tp.classSymbol eq cls
+      val classPartsMatch = inner(tp, cls)
+      classPartsMatch && genericTupleParts.map((cls, _) => cls).distinct.sizeIs <= 1 &&
+        { isSafeGenericTuple = genericTupleParts.headOption ; true }
+    end acceptable
 
     /** for a case class, if it will have an anonymous mirror,
      *  check that its constructor can be accessed
@@ -314,10 +327,10 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       cls.is(Scala2x) || cls.linkedClass.is(Case)
 
     def makeProductMirror(cls: Symbol): TreeWithErrors =
-      val mirroredClass = isSafeGenericTuple.fold(cls)(tps => defn.TupleType(tps.size).nn.classSymbol)
+      val mirroredClass = isSafeGenericTuple.fold(cls)((cls, _) => cls)
       val accessors = mirroredClass.caseAccessors.filterNot(_.isAllOf(PrivateLocal))
       val elemLabels = accessors.map(acc => ConstantType(Constant(acc.name.toString)))
-      val nestedPairs = isSafeGenericTuple.map(TypeOps.nestedPairs).getOrElse {
+      val nestedPairs = isSafeGenericTuple.map((_, tps) => TypeOps.nestedPairs(tps)).getOrElse {
         TypeOps.nestedPairs(accessors.map(mirroredType.resultType.memberInfo(_).widenExpr))
       }
       val (monoType, elemsType) = mirroredType match
@@ -334,7 +347,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
           .refinedWith(tpnme.MirroredElemLabels, TypeAlias(elemsLabels))
       val mirrorRef =
         if genAnonyousMirror(mirroredClass) then
-          anonymousMirror(monoType, ExtendsProductMirror, isSafeGenericTuple.map(_.size), span)
+          anonymousMirror(monoType, ExtendsProductMirror, isSafeGenericTuple.map(_(1).size), span)
         else companionPath(mirroredType, span)
       withNoErrors(mirrorRef.cast(mirrorType))
     end makeProductMirror

tests/neg/i14127a.scala

@@ -0,0 +1,5 @@
+import scala.deriving.Mirror
+
+// mixing arities is not supported
+
+val mT23 = summon[Mirror.Of[(Int *: Int *: EmptyTuple) | (Int *: Int *: Int *: EmptyTuple)]] // error