synthesize mirrors for small generic tuples

- handles generic tuples of different arity

Author: bishabosha

compiler/src/dotty/tools/dotc/core/TypeErasure.scala

@@ -689,7 +689,9 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
   }
 
   private def erasePair(tp: Type)(using Context): Type = {
-    val arity = tp.tupleArity
+    // NOTE: `tupleArity` does not consider TypeRef(EmptyTuple$) equivalent to EmptyTuple.type,
+    // we fix this for printers, but type erasure should be preserved.
+    val arity = tp.tupleArity()
     if (arity < 0) defn.ProductClass.typeRef
     else if (arity <= Definitions.MaxTupleArity) defn.TupleType(arity).nn
     else defn.TupleXXLClass.typeRef

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -40,13 +40,22 @@ import scala.annotation.internal.sharable
 import scala.annotation.threadUnsafe
 
 import dotty.tools.dotc.transform.SymUtils._
+import dotty.tools.dotc.transform.TypeUtils.*
 
 object Types {
 
   @sharable private var nextId = 0
 
   implicit def eqType: CanEqual[Type, Type] = CanEqual.derived
 
+  object GenericTupleType:
+    def unapply(tp: AppliedType)(using Context): Option[List[Type]] =
+      tp.tycon match
+        case TypeRef(_, cls: ClassSymbol) if tp.tupleArity(relaxEmptyTuple = true) > 0 => // avoid type aliases
+          Some(tp.tupleElementTypes)
+        case _ =>
+          None
+
   /** Main class representing types.
    *
    *  The principal subclasses and sub-objects are as follows:

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -218,7 +218,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         val cls = tycon.typeSymbol
         if tycon.isRepeatedParam then toTextLocal(args.head) ~ "*"
         else if defn.isFunctionClass(cls) then toTextFunction(args, cls.name.isContextFunction, cls.name.isErasedFunction)
-        else if tp.tupleArity >= 2 && !printDebug then toTextTuple(tp.tupleElementTypes)
+        else if tp.tupleArity(relaxEmptyTuple = true) >= 2 && !printDebug then toTextTuple(tp.tupleElementTypes)
         else if isInfixType(tp) then
           val l :: r :: Nil = args: @unchecked
           val opName = tyconName(tycon)

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

@@ -248,7 +248,7 @@ object GenericSignatures {
               case _ => jsig(elemtp)
 
         case RefOrAppliedType(sym, pre, args) =>
-          if (sym == defn.PairClass && tp.tupleArity > Definitions.MaxTupleArity)
+          if (sym == defn.PairClass && tp.tupleArity() > Definitions.MaxTupleArity)
             jsig(defn.TupleXXLClass.typeRef)
           else if (isTypeParameterInSig(sym, sym0)) {
             assert(!sym.isAliasType, "Unexpected alias type: " + sym)

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

@@ -26,6 +26,9 @@ object SyntheticMembers {
 
   /** Attachment recording that an anonymous class should extend Mirror.Sum */
   val ExtendsSumMirror: Property.StickyKey[Unit] = new Property.StickyKey
+
+  /** Attachment recording that an anonymous class should extend Mirror.Sum */
+  val GenericTupleArity: Property.StickyKey[Int] = new Property.StickyKey
 }
 
 /** Synthetic method implementations for case classes, case objects,
@@ -601,7 +604,11 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     else if (impl.removeAttachment(ExtendsSingletonMirror).isDefined)
       makeSingletonMirror()
     else if (impl.removeAttachment(ExtendsProductMirror).isDefined)
-      makeProductMirror(monoType.typeRef.dealias.classSymbol)
+      val tupleArity = impl.removeAttachment(GenericTupleArity)
+      val cls = tupleArity match
+        case Some(n) => defn.TupleType(n).nn.classSymbol
+        case _ => monoType.typeRef.dealias.classSymbol
+      makeProductMirror(cls)
     else if (impl.removeAttachment(ExtendsSumMirror).isDefined)
       makeSumMirror(monoType.typeRef.dealias.classSymbol)
 

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

@@ -51,13 +51,17 @@ object TypeUtils {
 
     /** The arity of this tuple type, which can be made up of EmptyTuple, TupleX and `*:` pairs,
      *  or -1 if this is not a tuple type.
+     *
+     *  @param relaxEmptyTuple if true then TypeRef(EmptyTuple$) =:= EmptyTuple.type
      */
-    def tupleArity(using Context): Int = self match {
+    def tupleArity(relaxEmptyTuple: Boolean = false)(using Context): Int = self match {
       case AppliedType(tycon, _ :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
-        val arity = tl.tupleArity
+        val arity = tl.tupleArity(relaxEmptyTuple)
         if (arity < 0) arity else arity + 1
       case self: SingletonType =>
         if self.termSymbol == defn.EmptyTupleModule then 0 else -1
+      case self: TypeRef if relaxEmptyTuple && self.classSymbol == defn.EmptyTupleModule.moduleClass =>
+        0
       case self if defn.isTupleClass(self.classSymbol) =>
         self.dealias.argInfos.length
       case _ =>
@@ -69,12 +73,14 @@ object TypeUtils {
       case AppliedType(tycon, hd :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
         hd :: tl.tupleElementTypes
       case self: SingletonType =>
-        assert(self.termSymbol == defn.EmptyTupleModule, "not a tuple")
+        assert(self.termSymbol == defn.EmptyTupleModule, i"not a tuple `$self`")
+        Nil
+      case self: TypeRef if self.classSymbol == defn.EmptyTupleModule.moduleClass =>
         Nil
       case self if defn.isTupleClass(self.classSymbol) =>
         self.dealias.argInfos
-      case _ =>
-        throw new AssertionError("not a tuple")
+      case tp =>
+        throw new AssertionError(i"not a tuple `$tp`")
     }
 
     /** The `*:` equivalent of an instance of a Tuple class */

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

@@ -223,16 +223,19 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
   /** Create an anonymous class `new Object { type MirroredMonoType = ... }`
    *  and mark it with given attachment so that it is made into a mirror at PostTyper.
    */
-  private def anonymousMirror(monoType: Type, attachment: Property.StickyKey[Unit], span: Span)(using Context) =
+  private def anonymousMirror(monoType: Type, attachment: Property.StickyKey[Unit], tupleArity: Option[Int], span: Span)(using Context) =
     if ctx.isAfterTyper then ctx.compilationUnit.needsMirrorSupport = true
     val monoTypeDef = untpd.TypeDef(tpnme.MirroredMonoType, untpd.TypeTree(monoType))
-    val newImpl = untpd.Template(
+    var newImpl = untpd.Template(
       constr = untpd.emptyConstructor,
       parents = untpd.TypeTree(defn.ObjectType) :: Nil,
       derived = Nil,
       self = EmptyValDef,
       body = monoTypeDef :: Nil
     ).withAttachment(attachment, ())
+    tupleArity.foreach { n =>
+      newImpl = newImpl.withAttachment(GenericTupleArity, n)
+    }
     typer.typed(untpd.New(newImpl).withSpan(span))
 
   /** The mirror type
@@ -279,6 +282,20 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
   private[Synthesizer] enum MirrorSource:
     case ClassSymbol(cls: Symbol)
     case Singleton(src: Symbol, tref: TermRef)
+    case GenericTuple(tuplArity: Int, tpArgs: List[Type])
+
+    def whyNotGenericProd(using Context): Option[String] = this match
+      case GenericTuple(arity, _) =>
+        val maxArity = Definitions.MaxTupleArity
+        if arity <= maxArity then None
+        else Some(i"it reduces to tuple with arity $arity, expected arity <= $maxArity")
+      case ClassSymbol(cls) => if cls.isGenericProduct then None else Some(cls.whyNotGenericProduct)
+      case _ => None
+
+    /** tuple arity, works for TupleN classes and generic tuples */
+    final def arity(using Context): Int = this match
+      case GenericTuple(arity, _) => arity
+      case _ => -1
 
     /** A comparison that chooses the most specific MirrorSource, this is guided by what is necessary for
      * `Mirror.Product.fromProduct`. i.e. its result type should be compatible with the erasure of `mirroredType`.
@@ -289,12 +306,29 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
         case (ClassSymbol(cls1), ClassSymbol(cls2)) => cls1.isSubClass(cls2)
         case (Singleton(src1, _), Singleton(src2, _)) => src1 eq src2
         case (_: ClassSymbol, _: Singleton) => false
+        case _ => (this.arity, that.arity) match
+          case (n, m) if n > 0 || m > 0 =>
+            // we shortcut when at least one was a tuple.
+            // This protects us from comparing classes for two TupleXXL with different arities.
+            n == m
+          case _ => false
+
+    def asClass(using Context): Symbol = this match
+      case ClassSymbol(cls) => cls
+      case Singleton(src, _) => src.info.classSymbol
+      case GenericTuple(arity, _) =>
+        if arity <= Definitions.MaxTupleArity then defn.TupleType(arity).nn.classSymbol
+        else defn.PairClass
 
     def show(using Context): String = this match
       case ClassSymbol(cls) => i"$cls"
       case Singleton(src, _) => i"$src"
+      case GenericTuple(arity, _) =>
+        if arity <= Definitions.MaxTupleArity then i"class Tuple$arity"
+        else i"trait Tuple { def size: $arity }"
 
   private[Synthesizer] object MirrorSource:
+    type WithArity = ClassSymbol | GenericTuple
 
     /** Reduces a mirroredType to either its most specific ClassSymbol,
      *  or a TermRef to a singleton value. These are
@@ -332,6 +366,9 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
           reduce(tp.underlying)
       case tp: HKTypeLambda if tp.resultType.isInstanceOf[HKTypeLambda] =>
         Left(i"its subpart `$tp` is not a supported kind (either `*` or `* -> *`)")
+      case tp @ GenericTupleType(args) =>
+        val arity = args.size
+        Right(MirrorSource.GenericTuple(arity, args))
       case tp: TypeProxy =>
         reduce(tp.underlying)
       case tp @ AndType(l, r) =>
@@ -354,10 +391,22 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
 
   private def productMirror(mirroredType: Type, formal: Type, span: Span)(using Context): TreeWithErrors =
 
-    def makeProductMirror(cls: Symbol): TreeWithErrors =
-      val accessors = cls.caseAccessors.filterNot(_.isAllOf(PrivateLocal))
+    /** widen TermRef to see if they are an alias to an enum singleton */
+    def isEnumSingletonRef(tp: Type)(using Context): Boolean = tp match
+      case tp: TermRef =>
+        val sym = tp.termSymbol
+        sym.isEnumCase || (!tp.isOverloaded && isEnumSingletonRef(tp.underlying.widenExpr))
+      case _ => false
+
+    def makeProductMirror(msrc: MirrorSource.WithArity): TreeWithErrors =
+      val mirroredClass = msrc.asClass
+      val accessors = mirroredClass.caseAccessors.filterNot(_.isAllOf(PrivateLocal))
       val elemLabels = accessors.map(acc => ConstantType(Constant(acc.name.toString)))
-      val nestedPairs = TypeOps.nestedPairs(accessors.map(mirroredType.resultType.memberInfo(_).widenExpr))
+      val (arity, nestedPairs) = msrc match
+        case MirrorSource.GenericTuple(arity, args) =>
+          (Some(arity), TypeOps.nestedPairs(args))
+        case MirrorSource.ClassSymbol(cls) =>
+          (None, TypeOps.nestedPairs(accessors.map(mirroredType.resultType.memberInfo(_).widenExpr)))
       val (monoType, elemsType) = mirroredType match
         case mirroredType: HKTypeLambda =>
           (mkMirroredMonoType(mirroredType), mirroredType.derivedLambdaType(resType = nestedPairs))
@@ -367,12 +416,12 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       checkRefinement(formal, tpnme.MirroredElemTypes, elemsType, span)
       checkRefinement(formal, tpnme.MirroredElemLabels, elemsLabels, span)
       val mirrorType =
-        mirrorCore(defn.Mirror_ProductClass, monoType, mirroredType, cls.name, formal)
+        mirrorCore(defn.Mirror_ProductClass, monoType, mirroredType, mirroredClass.name, formal)
           .refinedWith(tpnme.MirroredElemTypes, TypeAlias(elemsType))
           .refinedWith(tpnme.MirroredElemLabels, TypeAlias(elemsLabels))
       val mirrorRef =
-        if cls.useCompanionAsProductMirror then companionPath(mirroredType, span)
-        else anonymousMirror(monoType, ExtendsProductMirror, span)
+        if mirroredClass.useCompanionAsProductMirror then companionPath(mirroredType, span)
+        else anonymousMirror(monoType, ExtendsProductMirror, arity, span)
       withNoErrors(mirrorRef.cast(mirrorType))
     end makeProductMirror
 
@@ -389,9 +438,10 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
           else
             val mirrorType = mirrorCore(defn.Mirror_SingletonClass, mirroredType, mirroredType, singleton.name, formal)
             withNoErrors(singletonPath.cast(mirrorType))
-        case MirrorSource.ClassSymbol(cls) =>
-          if cls.isGenericProduct then makeProductMirror(cls)
-          else withErrors(i"$cls is not a generic product because ${cls.whyNotGenericProduct}")
+        case msrc: MirrorSource.WithArity =>
+          msrc.whyNotGenericProd match
+            case Some(err) => withErrors(i"${msrc.asClass} is not a generic product because $err")
+            case _ => makeProductMirror(msrc)
       case Left(msg) =>
         withErrors(i"type `$mirroredType` is not a generic product because $msg")
   end productMirror
@@ -400,7 +450,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
 
     val (acceptableMsg, cls) = MirrorSource.reduce(mirroredType) match
       case Right(MirrorSource.Singleton(_, tp)) => (i"its subpart `$tp` is a term reference", NoSymbol)
-      case Right(MirrorSource.ClassSymbol(cls)) => ("", cls)
+      case Right(msrc) => ("", msrc.asClass)
       case Left(msg) => (msg, NoSymbol)
 
     val clsIsGenericSum = cls.isGenericSum
@@ -457,7 +507,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
             .refinedWith(tpnme.MirroredElemLabels, TypeAlias(TypeOps.nestedPairs(elemLabels)))
       val mirrorRef =
         if cls.useCompanionAsSumMirror then companionPath(mirroredType, span)
-        else anonymousMirror(monoType, ExtendsSumMirror, span)
+        else anonymousMirror(monoType, ExtendsSumMirror, tupleArity = None, span)
       withNoErrors(mirrorRef.cast(mirrorType))
     else if acceptableMsg.nonEmpty then
       withErrors(i"type `$mirroredType` is not a generic sum because $acceptableMsg")

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

@@ -2767,7 +2767,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       typed(desugar.smallTuple(tree).withSpan(tree.span), pt)
     else {
       val pts =
-        if (arity == pt.tupleArity) pt.tupleElementTypes
+        if (arity == pt.tupleArity()) pt.tupleElementTypes
         else List.fill(arity)(defn.AnyType)
       val elems = tree.trees.lazyZip(pts).map(
         if ctx.mode.is(Mode.Type) then typedType(_, _, mapPatternBounds = true)

tests/neg/i14127.check

@@ -0,0 +1,10 @@
+-- Error: tests/neg/i14127.scala:6:55 ----------------------------------------------------------------------------------
+6 |    *: Int *: Int *: Int *: Int *: Int *: EmptyTuple)]] // error
+  |                                                       ^
+  |No given instance of type deriving.Mirror.Of[(Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, 
+  |  Int
+  |, Int, Int)] was found for parameter x of method summon in object Predef. Failed to synthesize an instance of type deriving.Mirror.Of[(Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, 
+  |  Int
+  |, Int, Int)]: 
+  |	* class *: is not a generic product because it reduces to tuple with arity 23, expected arity <= 22
+  |	* class *: is not a generic sum because it does not have subclasses

tests/neg/i14127.scala

@@ -0,0 +1,6 @@
+import scala.deriving.Mirror
+
+val mT23 = summon[Mirror.Of[(
+  Int *: Int *: Int *: Int *: Int *: Int *: Int *: Int *: Int
+    *: Int *: Int *: Int *: Int *: Int *: Int *: Int *: Int *: Int
+    *: Int *: Int *: Int *: Int *: Int *: EmptyTuple)]] // error

tests/run/i14127.scala

@@ -0,0 +1,14 @@
+import scala.deriving.Mirror
+
+@main def Test =
+  val mISB = summon[Mirror.Of[Int *: String *: Boolean *: EmptyTuple]]
+  assert(mISB.fromProduct((1, "foo", true)) == (1, "foo", true))
+
+  val mT22 = summon[Mirror.Of[(
+    Int *: Int *: Int *: Int *: Int *: Int *: Int *: Int *: Int
+      *: Int *: Int *: Int *: Int *: Int *: Int *: Int *: Int *: Int
+      *: Int *: Int *: Int *: Int *: EmptyTuple)]]
+
+  // tuple of 22 elements
+  val t22 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)
+  assert(mT22.fromProduct(t22) == t22)

tests/run/i7049.scala

@@ -0,0 +1,18 @@
+import scala.deriving._
+
+case class Foo(x: Int, y: String)
+
+def toTuple[T <: Product](x: T)(using m: Mirror.ProductOf[T], mt: Mirror.ProductOf[m.MirroredElemTypes]) =
+  mt.fromProduct(x)
+
+@main def Test = {
+  val m = summon[Mirror.ProductOf[Foo]]
+  val mt1 = summon[Mirror.ProductOf[(Int, String)]]
+  type R = (Int, String)
+  val mt2 = summon[Mirror.ProductOf[R]]
+  val mt3 = summon[Mirror.ProductOf[m.MirroredElemTypes]]
+
+  val f = Foo(1, "foo")
+  val g: (Int, String) = toTuple(f)// (using m, mt1)
+  assert(g == (1, "foo"))
+}