Support tuple specialisation

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

@@ -282,8 +282,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
 
   private def printTree(last: PrintedTree)(using Context): PrintedTree = {
     val unit = ctx.compilationUnit
-    val prevPhase = ctx.phase.prev // can be a mini-phase
-    val fusedPhase = ctx.base.fusedContaining(prevPhase)
+    val fusedPhase = ctx.phase.prevMega
     val echoHeader = f"[[syntax trees at end of $fusedPhase%25s]] // ${unit.source}"
     val tree = if ctx.isAfterTyper then unit.tpdTree else unit.untpdTree
     val treeString = tree.show(using ctx.withProperty(XprintMode, Some(())))

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

@@ -1329,6 +1329,12 @@ class Definitions {
 
   @tu lazy val TupleType: Array[TypeRef | Null] = mkArityArray("scala.Tuple", MaxTupleArity, 1)
 
+  def isSpecializedTuple(cls: Symbol)(using Context): Boolean =
+    TupleSpecializedClasses.exists(tupleCls => cls.name.isSpecializedNameOf(tupleCls.name))
+
+  def SpecialisedTuple(base: Symbol, args: List[Type])(using Context): 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 +1593,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 +1630,13 @@ 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.classSymbol)
+      case List(x, y) => Tuple2SpecializedParamClasses().contains(x.classSymbol) && Tuple2SpecializedParamClasses().contains(y.classSymbol)
+      case _          => false
+    && base.owner.denot.info.member(base.name.specializedName(args)).exists // when dotc compiles the stdlib there are no specialised classes
+
   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,25 @@ object NameOps {
         classTags.fold(nme.EMPTY)(_ ++ _) ++ nme.specializedTypeNames.suffix)
     }
 
+    def isSpecializedNameOf(base: N)(using Context): Boolean =
+      import Decorators.*
+      val sb = new StringBuilder
+      sb.append(base.toString)
+      sb.append(nme.specializedTypeNames.prefix.toString)
+      sb.append(nme.specializedTypeNames.separator)
+      val prefix = sb.toString()
+      val suffix = nme.specializedTypeNames.suffix.toString
+      name.startsWith(prefix) && name.endsWith(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/Phases.scala

@@ -402,6 +402,9 @@ object Phases {
     final def prev: Phase =
       if (id > FirstPhaseId) myBase.phases(start - 1) else NoPhase
 
+    final def prevMega(using Context): Phase =
+      ctx.base.fusedContaining(ctx.phase.prev)
+
     final def next: Phase =
       if (hasNext) myBase.phases(end + 1) else NoPhase
 

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

@@ -92,6 +92,10 @@ object SymDenotations {
         if (myFlags.is(Trait)) NoInitsInterface & bodyFlags // no parents are initialized from a trait
         else NoInits & bodyFlags & parentFlags)
 
+    final def setStableConstructor()(using Context): Unit =
+      val ctorStable = if myFlags.is(Trait) then myFlags.is(NoInits) else isNoInitsRealClass
+      if ctorStable then primaryConstructor.setFlag(StableRealizable)
+
     def isCurrent(fs: FlagSet)(using Context): Boolean =
       def knownFlags(info: Type): FlagSet = info match
         case _: SymbolLoader | _: ModuleCompleter => FromStartFlags

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/core/unpickleScala2/Scala2Unpickler.scala

@@ -617,7 +617,9 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
                 // we need the checkNonCyclic call to insert LazyRefs for F-bounded cycles
               else if (!denot.is(Param)) tp1.translateFromRepeated(toArray = false)
               else tp1
-            if (denot.isConstructor) addConstructorTypeParams(denot)
+            if (denot.isConstructor)
+              denot.owner.setStableConstructor()
+              addConstructorTypeParams(denot)
             if (atEnd)
               assert(!denot.symbol.isSuperAccessor, denot)
             else {

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

@@ -33,9 +33,16 @@ object Formatting {
     object ShowAny extends Show[Any]:
       def show(x: Any): Shown = x
 
-    class ShowImplicits2:
+    class ShowImplicits3:
       given Show[Product] = ShowAny
 
+    class ShowImplicits2 extends ShowImplicits3:
+      given Show[ParamInfo] with
+        def show(x: ParamInfo) = x match
+          case x: Symbol      => Show[x.type].show(x)
+          case x: LambdaParam => Show[x.type].show(x)
+          case _              => ShowAny
+
     class ShowImplicits1 extends ShowImplicits2:
       given Show[ImplicitRef]      = ShowAny
       given Show[Names.Designator] = ShowAny
@@ -99,6 +106,8 @@ object Formatting {
         val sep = StringContext.processEscapes(rawsep)
         if (rest.nonEmpty) (arg.map(showArg).mkString(sep), rest.tail)
         else (arg, suffix)
+      case arg: Seq[?] =>
+        (arg.map(showArg).mkString("[", ", ", "]"), suffix)
       case _ =>
         (showArg(arg), suffix)
     }

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

@@ -0,0 +1,53 @@
+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
+import typer.Inliner.isElideableExpr
+
+/** 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.symbol.name == nme.apply && fun.symbol.exists && defn.isSpecializableTuple(fun.symbol.owner.companionClass, targs.map(_.tpe))
+        && isElideableExpr(tree)
+    =>
+      cpy.Apply(tree)(Select(New(defn.SpecialisedTuple(fun.symbol.owner.companionClass, targs.map(_.tpe)).typeRef), nme.CONSTRUCTOR), args).withType(tree.tpe)
+    case Apply(TypeApply(fun: NameTree, targs), args)
+        if fun.symbol.name == nme.CONSTRUCTOR && fun.symbol.exists && defn.isSpecializableTuple(fun.symbol.owner, targs.map(_.tpe))
+        && isElideableExpr(tree)
+    =>
+      cpy.Apply(tree)(Select(New(defn.SpecialisedTuple(fun.symbol.owner, targs.map(_.tpe)).typeRef), nme.CONSTRUCTOR), args).withType(tree.tpe)
+    case _ => tree
+  end transformApply
+
+  override def transformSelect(tree: Select)(using Context): Tree = tree match
+    case Select(qual, nme._1) if isAppliedSpecializableTuple(qual.tpe.widen) =>
+      Select(qual, nme._1.specializedName(qual.tpe.widen.argInfos.slice(0, 1)))
+    case Select(qual, nme._2) if isAppliedSpecializableTuple(qual.tpe.widen) =>
+      Select(qual, nme._2.specializedName(qual.tpe.widen.argInfos.slice(1, 2)))
+    case _ => tree
+
+  private def isAppliedSpecializableTuple(tp: Type)(using Context) = tp match
+    case AppliedType(tycon, args) => defn.isSpecializableTuple(tycon.classSymbol, args)
+    case _                        => false
+end SpecializeTuples
+
+object SpecializeTuples:
+  val name: String = "specializeTuples"
+  val description: String = "replaces tuple construction and selection trees"

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

@@ -91,7 +91,7 @@ class TreeChecker extends Phase with SymTransformer {
     if (ctx.phaseId <= erasurePhase.id) {
       val initial = symd.initial
       assert(symd == initial || symd.signature == initial.signature,
-        i"""Signature of ${sym.showLocated} changed at phase ${ctx.base.fusedContaining(ctx.phase.prev)}
+        i"""Signature of ${sym.showLocated} changed at phase ${ctx.phase.prevMega}
            |Initial info: ${initial.info}
            |Initial sig : ${initial.signature}
            |Current info: ${symd.info}
@@ -122,8 +122,7 @@ class TreeChecker extends Phase with SymTransformer {
   }
 
   def check(phasesToRun: Seq[Phase], ctx: Context): Tree = {
-    val prevPhase = ctx.phase.prev // can be a mini-phase
-    val fusedPhase = ctx.base.fusedContaining(prevPhase)
+    val fusedPhase = ctx.phase.prevMega(using ctx)
     report.echo(s"checking ${ctx.compilationUnit} after phase ${fusedPhase}")(using ctx)
 
     inContext(ctx) {
@@ -145,7 +144,7 @@ class TreeChecker extends Phase with SymTransformer {
     catch {
       case NonFatal(ex) =>     //TODO CHECK. Check that we are bootstrapped
         inContext(checkingCtx) {
-          println(i"*** error while checking ${ctx.compilationUnit} after phase ${ctx.phase.prev} ***")
+          println(i"*** error while checking ${ctx.compilationUnit} after phase ${ctx.phase.prevMega(using ctx)} ***")
         }
         throw ex
     }
@@ -422,6 +421,13 @@ class TreeChecker extends Phase with SymTransformer {
       assert(tree.qual.typeOpt.isInstanceOf[ThisType], i"expect prefix of Super to be This, actual = ${tree.qual}")
       super.typedSuper(tree, pt)
 
+    override def typedApply(tree: untpd.Apply, pt: Type)(using Context): Tree = tree match
+      case Apply(Select(qual, nme.CONSTRUCTOR), _)
+          if !ctx.phase.erasedTypes
+            && defn.isSpecializedTuple(qual.typeOpt.typeSymbol) =>
+        promote(tree) // e.g. `new Tuple2$mcII$sp(7, 8)` should keep its `(7, 8)` type instead of `Tuple2$mcII$sp`
+      case _ => super.typedApply(tree, pt)
+
     override def typedTyped(tree: untpd.Typed, pt: Type)(using Context): Tree =
       val tpt1 = checkSimpleKinded(typedType(tree.tpt))
       val expr1 = tree.expr match

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

@@ -411,6 +411,70 @@ object Inliner {
 
   }
 
+  /** Very similar to TreeInfo.isPureExpr, but with the following inliner-only exceptions:
+   *  - synthetic case class apply methods, when the case class constructor is empty, are
+   *    elideable but not pure. Elsewhere, accessing the apply method might cause the initialization
+   *    of a containing object so they are merely idempotent.
+   */
+  object isElideableExpr {
+    def isStatElideable(tree: Tree)(using Context): Boolean = unsplice(tree) match {
+      case EmptyTree
+         | TypeDef(_, _)
+         | Import(_, _)
+         | DefDef(_, _, _, _) =>
+        true
+      case vdef @ ValDef(_, _, _) =>
+        if (vdef.symbol.flags is Mutable) false else apply(vdef.rhs)
+      case _ =>
+        false
+    }
+
+    def apply(tree: Tree)(using Context): Boolean = unsplice(tree) match {
+      case EmptyTree
+         | This(_)
+         | Super(_, _)
+         | Literal(_) =>
+        true
+      case Ident(_) =>
+        isPureRef(tree) || tree.symbol.isAllOf(Inline | Param)
+      case Select(qual, _) =>
+        if (tree.symbol.is(Erased)) true
+        else isPureRef(tree) && apply(qual)
+      case New(_) | Closure(_, _, _) =>
+        true
+      case TypeApply(fn, _) =>
+        if (fn.symbol.is(Erased) || fn.symbol == defn.QuotedTypeModule_of) true else apply(fn)
+      case Apply(fn, args) =>
+        val isCaseClassApply = {
+          val cls = tree.tpe.classSymbol
+          val meth = fn.symbol
+          meth.name == nme.apply &&
+          meth.flags.is(Synthetic) &&
+          meth.owner.linkedClass.is(Case) &&
+          cls.isNoInitsRealClass &&
+          funPart(fn).match
+            case Select(qual, _) => qual.symbol.is(Synthetic) // e.g: disallow `{ ..; Foo }.apply(..)`
+            case meth @ Ident(_) => meth.symbol.is(Synthetic) // e.g: allow `import Foo.{ apply => foo }; foo(..)`
+            case _               => false
+        }
+        if isPureApply(tree, fn) then
+          apply(fn) && args.forall(apply)
+        else if (isCaseClassApply)
+          args.forall(apply)
+        else if (fn.symbol.is(Erased)) true
+        else false
+      case Typed(expr, _) =>
+        apply(expr)
+      case Block(stats, expr) =>
+        apply(expr) && stats.forall(isStatElideable)
+      case Inlined(_, bindings, expr) =>
+        apply(expr) && bindings.forall(isStatElideable)
+      case NamedArg(_, expr) =>
+        apply(expr)
+      case _ =>
+        false
+    }
+  }
 }
 
 /** Produces an inlined version of `call` via its `inlined` method.
@@ -691,67 +755,6 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
     || tpe.cls.is(Package)
     || tpe.cls.isStaticOwner && !(tpe.cls.seesOpaques && inlinedMethod.isContainedIn(tpe.cls))
 
-  /** Very similar to TreeInfo.isPureExpr, but with the following inliner-only exceptions:
-   *  - synthetic case class apply methods, when the case class constructor is empty, are
-   *    elideable but not pure. Elsewhere, accessing the apply method might cause the initialization
-   *    of a containing object so they are merely idempotent.
-   */
-  object isElideableExpr {
-    def isStatElideable(tree: Tree)(using Context): Boolean = unsplice(tree) match {
-      case EmptyTree
-         | TypeDef(_, _)
-         | Import(_, _)
-         | DefDef(_, _, _, _) =>
-        true
-      case vdef @ ValDef(_, _, _) =>
-        if (vdef.symbol.flags is Mutable) false else apply(vdef.rhs)
-      case _ =>
-        false
-    }
-
-    def apply(tree: Tree): Boolean = unsplice(tree) match {
-      case EmptyTree
-         | This(_)
-         | Super(_, _)
-         | Literal(_) =>
-        true
-      case Ident(_) =>
-        isPureRef(tree) || tree.symbol.isAllOf(Inline | Param)
-      case Select(qual, _) =>
-        if (tree.symbol.is(Erased)) true
-        else isPureRef(tree) && apply(qual)
-      case New(_) | Closure(_, _, _) =>
-        true
-      case TypeApply(fn, _) =>
-        if (fn.symbol.is(Erased) || fn.symbol == defn.QuotedTypeModule_of) true else apply(fn)
-      case Apply(fn, args) =>
-        val isCaseClassApply = {
-          val cls = tree.tpe.classSymbol
-          val meth = fn.symbol
-          meth.name == nme.apply &&
-          meth.flags.is(Synthetic) &&
-          meth.owner.linkedClass.is(Case) &&
-          cls.isNoInitsRealClass
-        }
-        if isPureApply(tree, fn) then
-          apply(fn) && args.forall(apply)
-        else if (isCaseClassApply)
-          args.forall(apply)
-        else if (fn.symbol.is(Erased)) true
-        else false
-      case Typed(expr, _) =>
-        apply(expr)
-      case Block(stats, expr) =>
-        apply(expr) && stats.forall(isStatElideable)
-      case Inlined(_, bindings, expr) =>
-        apply(expr) && bindings.forall(isStatElideable)
-      case NamedArg(_, expr) =>
-        apply(expr)
-      case _ =>
-        false
-      }
-  }
-
   /** Populate `thisProxy` and `paramProxy` as follows:
    *
    *  1a. If given type refers to a static this, thisProxy binds it to corresponding global reference,