Implement Tuple specialisation

Of both construction (both `new` and `apply`) and of selection
(`_1$mcI$sp`).

Author: dwijnand

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -96,6 +96,7 @@ class Compiler {
          new InterceptedMethods,     // Special handling of `==`, `|=`, `getClass` methods
          new Getters,                // Replace non-private vals and vars with getter defs (fields are added later)
          new SpecializeFunctions,    // Specialized Function{0,1,2} by replacing super with specialized super
+         new SpecializeTuples,       // Specializes Tuples by replacing tuple construction and selection trees
          new LiftTry,                // Put try expressions that might execute on non-empty stacks into their own methods
          new CollectNullableFields,  // Collect fields that can be nulled out after use in lazy initialization
          new ElimOuterSelect,        // Expand outer selections

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

@@ -1329,6 +1329,8 @@ class Definitions {
 
   @tu lazy val TupleType: Array[TypeRef | Null] = mkArityArray("scala.Tuple", MaxTupleArity, 1)
 
+  def SpecialisedTuple(base: Symbol, args: List[Type]): Symbol = base.owner.requiredClass(base.name.specializedName(args))
+
   private class FunType(prefix: String):
     private var classRefs: Array[TypeRef | Null] = new Array(22)
     def apply(n: Int): TypeRef =
@@ -1587,6 +1589,20 @@ class Definitions {
   def isFunctionType(tp: Type)(using Context): Boolean =
     isNonRefinedFunction(tp.dropDependentRefinement)
 
+  private def withSpecMethods(cls: ClassSymbol, bases: List[Name], paramTypes: Set[TypeRef]) =
+    for base <- bases; tp <- paramTypes do
+      cls.enter(newSymbol(cls, base.specializedName(List(tp)), Method, ExprType(tp)))
+    cls
+
+  @tu lazy val Tuple1: ClassSymbol = withSpecMethods(requiredClass("scala.Tuple1"), List(nme._1), Tuple1SpecializedParamTypes)
+  @tu lazy val Tuple2: ClassSymbol = withSpecMethods(requiredClass("scala.Tuple2"), List(nme._1, nme._2), Tuple2SpecializedParamTypes)
+
+  @tu lazy val TupleSpecializedClasses: Set[Symbol]               = Set(Tuple1, Tuple2)
+  @tu lazy val Tuple1SpecializedParamTypes: Set[TypeRef]          = Set(IntType, LongType, DoubleType)
+  @tu lazy val Tuple2SpecializedParamTypes: Set[TypeRef]          = Set(IntType, LongType, DoubleType, CharType, BooleanType)
+  @tu lazy val Tuple1SpecializedParamClasses: PerRun[Set[Symbol]] = new PerRun(Tuple1SpecializedParamTypes.map(_.symbol))
+  @tu lazy val Tuple2SpecializedParamClasses: PerRun[Set[Symbol]] = new PerRun(Tuple2SpecializedParamTypes.map(_.symbol))
+
   // Specialized type parameters defined for scala.Function{0,1,2}.
   @tu lazy val Function1SpecializedParamTypes: collection.Set[TypeRef] =
     Set(IntType, LongType, FloatType, DoubleType)
@@ -1610,6 +1626,12 @@ class Definitions {
   @tu lazy val Function2SpecializedReturnClasses: PerRun[collection.Set[Symbol]] =
     new PerRun(Function2SpecializedReturnTypes.map(_.symbol))
 
+  def isSpecializableTuple(base: Symbol, args: List[Type])(using Context): Boolean =
+    args.length <= 2 && base.isClass && TupleSpecializedClasses.exists(base.asClass.derivesFrom) && args.match
+      case List(x)    => Tuple1SpecializedParamClasses().contains(x.typeSymbol)
+      case List(x, y) => Tuple2SpecializedParamClasses().contains(x.typeSymbol) && Tuple2SpecializedParamClasses().contains(y.typeSymbol)
+      case _          => false
+
   def isSpecializableFunction(cls: ClassSymbol, paramTypes: List[Type], retType: Type)(using Context): Boolean =
     paramTypes.length <= 2
     && (cls.derivesFrom(FunctionClass(paramTypes.length)) || isByNameFunctionClass(cls))

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

@@ -278,6 +278,15 @@ object NameOps {
         classTags.fold(nme.EMPTY)(_ ++ _) ++ nme.specializedTypeNames.suffix)
     }
 
+    def specializedName(args: List[Type])(using Context): N =
+      val sb = new StringBuilder
+      sb.append(name.toString)
+      sb.append(nme.specializedTypeNames.prefix.toString)
+      sb.append(nme.specializedTypeNames.separator)
+      args.foreach { arg => sb.append(defn.typeTag(arg)) }
+      sb.append(nme.specializedTypeNames.suffix)
+      likeSpacedN(termName(sb.toString))
+
     /** Use for specializing function names ONLY and use it if you are **not**
      *  creating specialized name from type parameters. The order of names will
      *  be:

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -1017,7 +1017,10 @@ class ClassfileParser(
         else return unpickleTASTY(bytes)
       }
 
-      if (scan(tpnme.ScalaATTR) && !scalaUnpickleWhitelist.contains(classRoot.name))
+      if scan(tpnme.ScalaATTR) && !scalaUnpickleWhitelist.contains(classRoot.name)
+        && !(classRoot.name.startsWith("Tuple") && classRoot.name.endsWith("$sp"))
+        && !(classRoot.name.startsWith("Product") && classRoot.name.endsWith("$sp"))
+      then
         // To understand the situation, it's helpful to know that:
         // - Scalac emits the `ScalaSig` attribute for classfiles with pickled information
         // and the `Scala` attribute for everything else.

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

@@ -0,0 +1,48 @@
+package dotty.tools
+package dotc
+package transform
+
+import ast.Trees.*, ast.tpd, core.*
+import Contexts.*, Types.*, Decorators.*, Symbols.*, DenotTransformers.*
+import SymDenotations.*, Scopes.*, StdNames.*, NameOps.*, Names.*
+import MegaPhase.MiniPhase
+
+/** Specializes Tuples by replacing tuple construction and selection trees.
+ *
+ * Specifically:
+ * 1. Replaces `(1, 1)` (which is `Tuple2.apply[Int, Int](1, 1)`) and
+ *    `new Tuple2[Int, Int](1, 1)` with `new Tuple2$mcII$sp(1, 1)`.
+ * 2. Replaces `(_: Tuple2[Int, Int])._1` with `(_: Tuple2[Int, Int])._1$mcI$sp`
+ */
+class SpecializeTuples extends MiniPhase:
+  import tpd.*
+
+  override def phaseName: String                 = SpecializeTuples.name
+  override def description: String               = SpecializeTuples.description
+  override def isEnabled(using Context): Boolean = !ctx.settings.scalajs.value
+
+  override def transformApply(tree: Apply)(using Context): Tree = tree match
+    case Apply(TypeApply(fun: NameTree, targs), args)
+        if fun.name == nme.apply && fun.symbol.exists && defn.isSpecializableTuple(fun.symbol.owner.companionClass, targs.map(_.tpe)) =>
+      Apply(Select(New(defn.SpecialisedTuple(fun.symbol.owner.companionClass, targs.map(_.tpe)).typeRef), nme.CONSTRUCTOR), args)
+    case Apply(TypeApply(fun: NameTree, targs), args)
+        if fun.name == nme.CONSTRUCTOR && fun.symbol.exists && defn.isSpecializableTuple(fun.symbol.owner, targs.map(_.tpe)) =>
+      Apply(Select(New(defn.SpecialisedTuple(fun.symbol.owner, targs.map(_.tpe)).typeRef), nme.CONSTRUCTOR), args)
+    case _ => tree
+  end transformApply
+
+  override def transformSelect(tree: Select)(using Context): Tree = tree match
+    case Select(qual, nme._1) if qual.tpe.widen.match
+      case AppliedType(tycon, args) => defn.isSpecializableTuple(tycon.classSymbol, args)
+      case _                        => false
+    => Select(qual, nme._1.specializedName(qual.tpe.widen.argInfos.slice(0, 1)))
+    case Select(qual, nme._2) if qual.tpe.widen.match
+      case AppliedType(tycon, args) => defn.isSpecializableTuple(tycon.classSymbol, args)
+      case _                        => false
+    => Select(qual, nme._2.specializedName(qual.tpe.widen.argInfos.slice(1, 2)))
+    case _ => tree
+end SpecializeTuples
+
+object SpecializeTuples:
+  val name: String = "specializeTuples"
+  val description: String = "replaces tuple construction and selection trees"

tests/pos/i11114.scala

@@ -0,0 +1,4 @@
+class Foo {
+  val x: (Int, Int) = (1, 1)
+  val y: Int = x._1
+}

tests/run/i11114.check

@@ -0,0 +1,3 @@
+class scala.Tuple2$mcII$sp
+class scala.Tuple2$mcII$sp
+class scala.Tuple2$mcII$sp

tests/run/i11114.scala

@@ -0,0 +1,4 @@
+@main def Test() =
+  println((1, 1).getClass)
+  println(Tuple2.apply(1, 1).getClass)
+  println(new Tuple2(1, 1).getClass)