Erase *: to tuple classes

Was erased to Object before, but this loses precision and breaks
binary compatibility with Scala 2.

Author: odersky

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

@@ -708,6 +708,8 @@ class Definitions {
 
   lazy val PairType = ctx.requiredClassRef("scala.*:")
   def PairClass(implicit ctx: Context) = PairType.symbol.asClass
+  lazy val TupleXXLType = ctx.requiredClassRef("scala.TupleXXL")
+  def TupleXXLClass(implicit ctx: Context) = TupleXXLType.symbol.asClass
 
   // Annotation base classes
   lazy val AnnotationType              = ctx.requiredClassRef("scala.annotation.Annotation")
@@ -1200,7 +1202,7 @@ class Definitions {
   def isValueSubClass(sym1: Symbol, sym2: Symbol) =
     valueTypeEnc(sym2.asClass.name) % valueTypeEnc(sym1.asClass.name) == 0
 
-  lazy val erasedToObject = Set[Symbol](AnyClass, AnyValClass, TupleClass, PairClass, SingletonClass)
+  lazy val erasedToObject = Set[Symbol](AnyClass, AnyValClass, TupleClass, SingletonClass)
 
   // ----- Initialization ---------------------------------------------------
 

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

@@ -33,6 +33,9 @@ import scala.annotation.tailrec
  */
 object TypeErasure {
 
+  private def erasureDependsOnArgs(tp: Type)(implicit ctx: Context) =
+    tp.isRef(defn.ArrayClass) || tp.isRef(defn.PairClass)
+
   /** A predicate that tests whether a type is a legal erased type. Only asInstanceOf and
    *  isInstanceOf may have types that do not satisfy the predicate.
    *  ErasedValueType is considered an erased type because it is valid after Erasure (it is
@@ -44,7 +47,7 @@ object TypeErasure {
     case tp: TypeRef =>
       val sym = tp.symbol
       sym.isClass &&
-      sym != defn.ArrayClass &&
+      !erasureDependsOnArgs(tp) &&
       !defn.erasedToObject.contains(sym) &&
       !defn.isSyntheticFunctionClass(sym)
     case _: TermRef =>
@@ -388,6 +391,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
       else eraseNormalClassRef(tp)
     case tp: AppliedType =>
       if (tp.tycon.isRef(defn.ArrayClass)) eraseArray(tp)
+      else if (tp.tycon.isRef(defn.PairClass)) erasePair(tp)
       else if (tp.isRepeatedParam) apply(tp.underlyingIfRepeated(isJava))
       else apply(tp.superType)
     case _: TermRef | _: ThisType =>
@@ -418,9 +422,13 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
     case tp @ ClassInfo(pre, cls, parents, decls, _) =>
       if (cls is Package) tp
       else {
+        def eraseParent(tp: Type) = tp.dealias match {
+          case tp: AppliedType if tp.tycon.isRef(defn.PairClass) => defn.ObjectType
+          case _ => apply(tp)
+        }
         val erasedParents: List[Type] =
           if ((cls eq defn.ObjectClass) || cls.isPrimitiveValueClass) Nil
-          else parents.mapConserve(apply) match {
+          else parents.mapConserve(eraseParent) match {
             case tr :: trs1 =>
               assert(!tr.classSymbol.is(Trait), cls)
               val tr1 = if (cls is Trait) defn.ObjectType else tr
@@ -448,6 +456,22 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
     else JavaArrayType(arrayErasure(elemtp))
   }
 
+  private def erasePair(tp: Type)(implicit ctx: Context): Type = {
+    def tupleArity(tp: Type): Int = tp.dealias match {
+      case AppliedType(tycon, _ :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
+        val arity = tupleArity(tl)
+        if (arity < 0) arity else arity + 1
+      case tp1 =>
+        if (tp1.isRef(defn.UnitClass)) 0
+        else if (defn.isTupleClass(tp1.classSymbol)) tp1.dealias.argInfos.length
+        else -1
+    }
+    val arity = tupleArity(tp)
+    if (arity < 0) defn.ObjectType
+    else if (arity <= Definitions.MaxTupleArity) defn.TupleType(arity)
+    else defn.TupleXXLType
+  }
+
   /** The erasure of a symbol's info. This is different from `apply` in the way `ExprType`s and
    *  `PolyType`s are treated. `eraseInfo` maps them them to method types, whereas `apply` maps them
    *  to the underlying type.
@@ -490,7 +514,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
       // constructor method should not be semi-erased.
       else if (isConstructor && isDerivedValueClass(sym)) eraseNormalClassRef(tp)
       else this(tp)
-    case AppliedType(tycon, _) if !(tycon isRef defn.ArrayClass) =>
+    case AppliedType(tycon, _) if !erasureDependsOnArgs(tycon) =>
       eraseResult(tycon)
     case _ =>
       this(tp)
@@ -532,7 +556,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
           normalizeClass(sym.asClass).fullName.asTypeName
       case tp: AppliedType =>
         sigName(
-          if (tp.tycon.isRef(defn.ArrayClass)) this(tp)
+          if (erasureDependsOnArgs(tp.tycon)) this(tp)
           else if (tp.tycon.typeSymbol.isClass) tp.underlying
           else tp.superType)
       case ErasedValueType(_, underlying) =>

library/src/scala/TupleXXL.scala

@@ -1,9 +1,9 @@
 package scala
-import java.util.Arrays.deepEquals
+import java.util.Arrays.{deepEquals, deepHashCode}
 
 final class TupleXXL private (es: Array[Object]) {
   override def toString = elems.mkString("(", ",", ")")
-  override def hashCode = getClass.hashCode * 41 + elems.deep.hashCode
+  override def hashCode = getClass.hashCode * 41 + deepHashCode(elems)
   override def equals(that: Any) = that match {
     case that: TupleXXL => deepEquals(this.elems, that.elems)
     case _ => false

tests/run/tuples1.scala

@@ -1,7 +1,7 @@
 object Test extends App {
   val x0 = (); println(x0)
   val x1 = 1 *: x0; println(x1)
-  val x2 = "A" *: x1; println(x2)
+  val x2 = ("A", 1); println(x2)
   val x3 = 2 *: x2; println(x3)
   val x4 = "B" *: x3; println(x4)
   val x5 = 3 *: x4; println(x5)