Fix conflict between tupleArity and tupleElementTypes

There are cases where we know the tuple arity but cannot know the
flat element types of the tuple. For example `(A, B) | (C, D)` has
arity 2 but we cannot create a single tuple containing these elements.

In tupleArity we are missing a dealias. We need to investigate this
further. At first glance it seems that the signature of `Tuple.apply(x)`
is erased to `(Object): Product` and not `(Object): Tuple1`. This would
have been caused be the missing dealias. Unfortunately, if this is the
case we might not be able to fix the erasure without breaking binary
compatibility of the standard library.

Author: nicolasstucki

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

@@ -691,7 +691,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
   private def erasePair(tp: Type)(using Context): Type = {
     // 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()
+    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/printing/RefinedPrinter.scala

@@ -215,15 +215,17 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
     def appliedText(tp: Type): Text = tp match
       case tp @ AppliedType(tycon, args) =>
-        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(relaxEmptyTuple = true) >= 2 && !printDebug then toTextTuple(tp.tupleElementTypes)
-        else if isInfixType(tp) then
-          val l :: r :: Nil = args: @unchecked
-          val opName = tyconName(tycon)
-          toTextInfixType(tyconName(tycon), l, r) { simpleNameString(tycon.typeSymbol) }
-        else Str("")
+        tp.tupleElementTypes match
+          case Some(types) if types.size >= 2 && !printDebug => toTextTuple(types)
+          case _ =>
+            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 isInfixType(tp) then
+              val l :: r :: Nil = args: @unchecked
+              val opName = tyconName(tycon)
+              toTextInfixType(tyconName(tycon), l, r) { simpleNameString(tycon.typeSymbol) }
+            else Str("")
       case _ =>
         Str("")
 

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/TypeUtils.scala

@@ -51,44 +51,44 @@ 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(relaxEmptyTuple: Boolean = false)(using Context): Int = self match {
+    def tupleArity(using Context): Int = self/*.dealias*/ match { // TODO: why does dealias cause a failure in tests/run-deep-subtype/Tuple-toArray.scala
       case AppliedType(tycon, _ :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
-        val arity = tl.tupleArity(relaxEmptyTuple)
+        val arity = tl.tupleArity
         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: AndOrType =>
-        val arity1 = self.tp1.tupleArity(relaxEmptyTuple)
-        val arity2 = self.tp2.tupleArity(relaxEmptyTuple)
+        val arity1 = self.tp1.tupleArity
+        val arity2 = self.tp2.tupleArity
         if arity1 == arity2 then arity1 else -1
       case _ =>
         if defn.isTupleClass(self.classSymbol) then self.dealias.argInfos.length
         else -1
     }
 
     /** The element types of this tuple type, which can be made up of EmptyTuple, TupleX and `*:` pairs */
-    def tupleElementTypes(using Context): List[Type] = self match {
+    def tupleElementTypes(using Context): Option[List[Type]] = self.dealias match {
       case AppliedType(tycon, hd :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
-        hd :: tl.tupleElementTypes
+        tl.tupleElementTypes.map(hd :: _)
       case self: SingletonType =>
-        assert(self.termSymbol == defn.EmptyTupleModule, "not a tuple")
-        Nil
-      case self: TypeRef if self.classSymbol == defn.EmptyTupleModule.moduleClass =>
-         Nil
-      case self if defn.isTupleClass(self.classSymbol) =>
-        self.dealias.argInfos
+        if self.termSymbol == defn.EmptyTupleModule then Some(Nil) else None
+      case AndType(tp1, tp2) =>
+        // We assume that we have the following property:
+        // (T1, T2, ..., Tn) & (U1, U2, ..., Un) = (T1 & U1, T2 & U2, ..., Tn & Un)
+        tp1.tupleElementTypes.zip(tp2.tupleElementTypes).map { case (t1, t2) => t1 & t2 }
+      case OrType(tp1, tp2) =>
+        None // We can't combine the type of two tuples
       case _ =>
-        throw new AssertionError("not a tuple")
+        if defn.isTupleClass(self.classSymbol) then Some(self.dealias.argInfos)
+        else None
     }
 
     /** The `*:` equivalent of an instance of a Tuple class */
     def toNestedPairs(using Context): Type =
-      TypeOps.nestedPairs(tupleElementTypes)
+      tupleElementTypes match
+        case Some(types) => TypeOps.nestedPairs(types)
+        case None => throw new AssertionError("not a tuple")
 
     def refinedWith(name: Name, info: Type)(using Context) = RefinedType(self, name, info)
 

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

@@ -358,13 +358,15 @@ 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 @ AppliedType(tref: TypeRef, _)
-        if tref.symbol == defn.PairClass
-        && tp.tupleArity(relaxEmptyTuple = true) > 0 =>
-        // avoid type aliases for tuples
-        Right(MirrorSource.GenericTuple(tp.tupleElementTypes))
       case tp: TypeProxy =>
-        reduce(tp.underlying)
+        tp match
+          case tp @ AppliedType(tref: TypeRef, _) if tref.symbol == defn.PairClass =>
+            tp.tupleElementTypes match
+              case Some(types) =>
+                // avoid type aliases for tuples
+                Right(MirrorSource.GenericTuple(types))
+              case _ => reduce(tp.underlying)
+          case _ => reduce(tp.underlying)
       case tp @ AndType(l, r) =>
         for
           lsrc <- reduce(l)

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

@@ -2768,8 +2768,9 @@ 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
-        else List.fill(arity)(defn.AnyType)
+        pt.tupleElementTypes match
+          case Some(types) if types.size == arity => types
+          case _ => List.fill(arity)(defn.AnyType)
       val elems = tree.trees.lazyZip(pts).map(
         if ctx.mode.is(Mode.Type) then typedType(_, _, mapPatternBounds = true)
         else typed(_, _))