Equate TupleN(...) and *: types

Make `T1 *: ... *: Tn *: Unit` a subtype of `(T1, ..., Tn)`. This is sound since
the two types are erased to the same representation.

I tried alternatively to (...) types to `*:` types instead of `Tuple` types.
But then we have to translate `TupleN` classes as well since these can come
from Scala-2. This looked more fragile than the solution in this commit.

Author: odersky

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

@@ -12,6 +12,7 @@ import config.Printers.{typr, constr, subtyping, gadts, noPrinter}
 import TypeErasure.{erasedLub, erasedGlb}
 import TypeApplications._
 import Constants.Constant
+import transform.TypeUtils._
 import scala.util.control.NonFatal
 import typer.ProtoTypes.constrained
 import reporting.trace
@@ -847,6 +848,8 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
               case info2: TypeBounds =>
                 compareLower(info2, tyconIsTypeRef = true)
               case info2: ClassInfo =>
+                tycon2.name.toString.startsWith("Tuple") &&
+                  defn.isTupleType(tp2) && isSubType(tp1, tp2.toNestedPairs) ||
                 tryBaseType(info2.cls)
               case _ =>
                 fourthTry

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

@@ -24,7 +24,8 @@ import TypeApplications._
 import Decorators._
 import config.Config
 import util.Positions._
-import dotty.tools.dotc.transform.SymUtils._
+import transform.SymUtils._
+import transform.TypeUtils._
 import dotty.tools.dotc.transform.FirstTransform
 
 import scala.annotation.switch
@@ -176,11 +177,11 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     }
 
     homogenize(tp) match {
-      case AppliedType(tycon, args) =>
+      case tp @ AppliedType(tycon, args) =>
         val cls = tycon.typeSymbol
         if (tycon.isRepeatedParam) return toTextLocal(args.head) ~ "*"
         if (defn.isFunctionClass(cls)) return toTextFunction(args, cls.name.isImplicitFunction, cls.name.isErasedFunction)
-        if (defn.isTupleClass(cls)) return toTextTuple(args)
+        if (tp.tupleArity >= 2) return toTextTuple(tp.tupleElementTypes)
         if (isInfixType(tp)) {
           val l :: r :: Nil = args
           val opName = tyconName(tycon)

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

@@ -50,5 +50,9 @@ object TypeUtils {
         else if (defn.isTupleClass(tp1.classSymbol)) tp1.dealias.argInfos
         else throw new AssertionError("not a tuple")
     }
+
+    /** The `*:` equivalent of an instantce of a Tuple class */
+    def toNestedPairs(implicit ctx: Context): Type =
+      (tupleElementTypes :\ (defn.UnitType: Type))(defn.PairType.appliedTo(_, _))
   }
 }

tests/run/tuples1.scala

@@ -14,7 +14,7 @@ object Test extends App {
   val h8 = x8.head; val h8c: String = h8; println(s"h8 = $h8")
   val t1 = x1.tail; val t1c: Unit = t1; println(s"t1 = $t1")
   val t2 = x2.tail; val t2c: Int *: Unit = t2; println(s"t2 = $t2")
-  val t7 = x7.tail; val t7c: String *: Int *: Unit = t7.tail.tail.tail.tail; println(s"t7 = $t7")
+  val t7 = x7.tail; val t7c: (String, Int) = t7.tail.tail.tail.tail; println(s"t7 = $t7")
   val t8 = x8.tail; val t8c: Int = t8(6); println(s"t8 = $t8")
   val a1_0 = x1(0); val a1_0c: Int = a1_0; println(s"a1_0 = $a1_0")
   val a2_0 = x2(0); val a2_0c: String = a2_0; println(s"a2_0 = $a2_0")
@@ -25,14 +25,14 @@ object Test extends App {
   val c0_0 = x0 ++ x0; val c0_0c: Unit = c0_0; println(s"c0_0 = $c0_0")
   val c0_1 = x0 ++ x1; val c0_1c: Int *: Unit = c0_1c; println(s"c0_1 = $c0_1")
   val c1_0 = x1 ++ x0; val c1_0c: Int *: Unit = c1_0c; println(s"c1_0 = $c1_0")
-  val c0_4 = x0 ++ x4; val c0_4c: String *: Int *: String *: Int *: Unit = c0_4; println(s"c0_4 = $c0_4")
-  val c4_0 = x4 ++ x0; val c4_0c: String *: Int *: String *: Int *: Unit = c4_0; println(s"c4_0 = $c4_0")
-  val c1_1 = x1 ++ x1; val c1_1c: Int *: Int *: Unit = c1_1; println(s"c1_1 = $c1_1")
-  val c1_8 = x1 ++ x8; val c1_8c: Int *: String *: Int *: String *: Int *: String *: Int *: String *: Int *: Unit = c1_8; println(s"c1_8 = $c1_8")
-  val c2_1 = x2 ++ x1; val c2_1c: String *: Int *: Int *: Unit = c2_1; println(s"c2_1 = $c2_1")
-  val c2_2 = x2 ++ x2; val c2_2c: String *: Int *: String *: Int *: Unit = c2_2; println(s"c2_2 = $c2_2")
-  val c2_3 = x2 ++ x3; val c2_3c: String *: Int *: Int *: String *: Int *: Unit = c2_3; println(s"c2_3 = $c2_3")
-  val c3_3 = x3 ++ x3; val c3_3c: Int *: String *: Int *: Int *: String *: Int *: Unit = c3_3; println(s"c3_3 = $c3_3")
+  val c0_4 = x0 ++ x4; val c0_4c: (String, Int, String, Int) = c0_4; println(s"c0_4 = $c0_4")
+  val c4_0 = x4 ++ x0; val c4_0c: (String, Int, String, Int) = c4_0; println(s"c4_0 = $c4_0")
+  val c1_1 = x1 ++ x1; val c1_1c: (Int, Int) = c1_1; println(s"c1_1 = $c1_1")
+  val c1_8 = x1 ++ x8; val c1_8c: (Int, String, Int, String, Int, String, Int, String, Int) = c1_8; println(s"c1_8 = $c1_8")
+  val c2_1 = x2 ++ x1; val c2_1c: (String, Int, Int) = c2_1; println(s"c2_1 = $c2_1")
+  val c2_2 = x2 ++ x2; val c2_2c: (String, Int, String, Int) = c2_2; println(s"c2_2 = $c2_2")
+  val c2_3 = x2 ++ x3; val c2_3c: (String, Int, Int, String, Int) = c2_3; println(s"c2_3 = $c2_3")
+  val c3_3 = x3 ++ x3; val c3_3c: (Int, String, Int, Int, String, Int) = c3_3; println(s"c3_3 = $c3_3")
 
   val x23 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23)
   type T23 = (Int, Int, Int, Int, Int,
@@ -102,12 +102,12 @@ object Test extends App {
 
   def concat[X <: Tuple, Y <: Tuple](x: X, y: Y): Tuple.Concat[X, Y] = x ++ y
   def concat0(x: Tuple, y: Tuple): Tuple.Concat[x.type, y.type] = x ++ y
-  val conc1: String *: Int *: Unit = concat((), tl1)
-  val conc2: String *: Int *: Unit = concat(tl1, ())
-  val conc3: String *: Int *: String *: Int *: Unit = concat(tl1, tl1)
-  val conc4: String *: Int *: Unit = concat0((), tl1)
-  val conc5: String *: Int *: Unit = concat0(tl1, ())
-  val conc6: String *: Int *: String *: Int *: Unit = concat0(tl1, tl1)
+  val conc1: (String, Int) = concat((), tl1)
+  val conc2: (String, Int) = concat(tl1, ())
+  val conc3: (String, Int, String, Int) = concat(tl1, tl1)
+  val conc4: (String, Int) = concat0((), tl1)
+  val conc5: (String, Int) = concat0(tl1, ())
+  val conc6: (String, Int, String, Int) = concat0(tl1, tl1)
 
   def size[X <: Tuple](x: X): Tuple.Size[X] = x.size
   def size0(x: Tuple): Tuple.Size[x.type] = x.size