Erasure/Scala2Unpickler hacks to restore binary compatibility

To stay binary compatibility with scala 2.11 binaries, we hijack the
unpickling of types to fake an HList structure. Later on in erasure, HList
types are eraised back to scala.TupleN (for N <= 22). In addition because the
actual scala.TupleN classes are neither `<: Tuple` now `<: TupleCons`, these
types needs to be systematically araised to Object.

In addition to all these carefully compensating hacks, this also imposes a new
contain: the dotty-library, which defines several `Tuple/TupleCons` methods,
can should now *always* be compiled by dotty itself. Indeed, when compiled
with scalac, these types will stay as they are instead of being eraised to
Object.

Author: OlivierBlanvillain

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

@@ -18,7 +18,7 @@ object Definitions {
    *  The limit 22 is chosen for Scala2x interop. It could be something
    *  else without affecting the set of programs that can be compiled.
    */
-  val MaxImplementedTupleArity = 6
+  val MaxImplementedTupleArity = 22
 
   /** The maximum arity N of a function type that's implemented
    *  as a trait `scala.FunctionN`. Functions of higher arity are possible,

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

@@ -325,6 +325,10 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
 
   /**  The erasure |T| of a type T. This is:
    *
+   *   - For dotty.TupleCons:
+   *      - if lenght staticaly known as N, TupleN
+   *      - otherwise Product
+   *   - For dotty.Tuple, java.lang.Object
    *   - For a refined type scala.Array+[T]:
    *      - if T is Nothing or Null, []Object
    *      - otherwise, if T <: Object, []|T|
@@ -356,6 +360,27 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
    *   - For any other type, exception.
    */
   private def apply(tp: Type)(implicit ctx: Context): Type = tp match {
+    case _ if tp.isRef(defn.TupleConsType.symbol) =>
+      // Compute the arity of a tuple type, -1 if it's not statically known.
+      def tupleArity(t: Type, acc: Int = 0): Int = t match {
+        case RefinedType(RefinedType(_, _, TypeAlias(headType)), _, TypeAlias(tailType)) =>
+          tupleArity(tailType, acc + 1)
+        case _ if t.isRef(defn.UnitType.symbol) =>
+          acc
+        case tp: TypeProxy =>
+          tupleArity(tp.underlying, acc)
+        case AnnotatedType(tpe, _) =>
+          tupleArity(tpe, acc)
+        case t =>
+          -1
+      }
+      val arity = tupleArity(tp)
+      if (arity > 0 && arity <= Definitions.MaxImplementedTupleArity)
+        defn.TupleNType(arity)
+      else
+        defn.ProductType
+    case _ if tp.isRef(defn.TupleType.symbol) =>
+      defn.ObjectType
     case _: ErasedValueType =>
       tp
     case tp: TypeRef =>
@@ -467,7 +492,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 RefinedType(parent, _, _) if !(parent isRef defn.ArrayClass) =>
+    case RefinedType(parent, _, _) if !(parent isRef defn.ArrayClass) && !(tp isRef defn.TupleConsType.symbol) =>
       eraseResult(parent)
     case _ =>
       this(tp)

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -26,6 +26,7 @@ import classfile.ClassfileParser
 import scala.collection.{ mutable, immutable }
 import scala.collection.mutable.ListBuffer
 import scala.annotation.switch
+import transform.TupleRewrites.UnfoldedTupleType
 
 object Scala2Unpickler {
 
@@ -97,7 +98,19 @@ object Scala2Unpickler {
       else selfInfo
     val tempInfo = new TempClassInfo(denot.owner.thisType, denot.classSymbol, decls, ost)
     denot.info = tempInfo // first rough info to avoid CyclicReferences
-    var parentRefs = ctx.normalizeToClassRefs(parents, cls, decls)
+
+    val tupleArity = defn.TupleNSymbol.indexOf(cls)
+    val tupledParents =
+      if (cls == defn.UnitType.classSymbol) parents :+ defn.TupleType
+      else if (tupleArity != -1) {
+        val productClass = defn.ProductNType(tupleArity).classSymbol
+        val productTypes = parents.collect { case t: RefinedType => t.baseArgTypes(productClass) }.head
+        val tupleType = UnfoldedTupleType(productTypes).folded.asTupleConsType
+        parents :+ tupleType
+      } else parents
+
+    var parentRefs = ctx.normalizeToClassRefs(tupledParents, cls, decls)
+
     if (parentRefs.isEmpty) parentRefs = defn.ObjectType :: Nil
     for (tparam <- tparams) {
       val tsym = decls.lookup(tparam.name)
@@ -721,7 +734,9 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
           }
           else TypeRef(pre, sym.name.asTypeName)
         val args = until(end, readTypeRef)
-        if (sym == defn.ByNameParamClass2x) ExprType(args.head)
+        val isTupleClass = """Tuple\d+.class""".r.findFirstIn(source.name).nonEmpty
+        if (!isTupleClass && defn.TupleNSymbol.contains(sym)) UnfoldedTupleType(args).folded.asTupleConsType
+        else if (sym == defn.ByNameParamClass2x) ExprType(args.head)
         else if (args.nonEmpty) tycon.safeAppliedTo(EtaExpandIfHK(sym.typeParams, args))
         else if (sym.typeParams.nonEmpty) tycon.EtaExpand(sym.typeParams)
         else tycon

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

@@ -403,7 +403,13 @@ object Erasure extends TypeTestsCasts {
         }
       }
 
-      recur(typed(tree.qualifier, AnySelectionProto))
+      if (defn.DottyTupleNModule contains tree.qualifier.symbol) {
+        val arity = defn.DottyTupleNModule.indexOf(tree.qualifier.symbol)
+        val tupleCompanion = defn.TupleNType(arity).classSymbol.companionModule.symbol
+        ref(tupleCompanion).select(tree.name).withPos(tree.pos)
+      } else {
+        recur(typed(tree.qualifier, AnySelectionProto))
+      }
     }
 
     override def typedThis(tree: untpd.This)(implicit ctx: Context): Tree =