Try partial inlining

Author: nicolasstucki

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

@@ -807,6 +807,7 @@ class Definitions {
   lazy val DynamicTupleModule: Symbol = ctx.requiredModule("scala.runtime.DynamicTuple")
     lazy val DynamicTuple_consIterator: Symbol = DynamicTupleModule.requiredMethod("consIterator")
     lazy val DynamicTuple_dynamicTail: Symbol = DynamicTupleModule.requiredMethod("dynamicTail")
+    lazy val DynamicTuple_dynamicCons: Symbol = DynamicTupleModule.requiredMethod("dynamicCons")
 
   // Annotation base classes
   lazy val AnnotationType: TypeRef              = ctx.requiredClassRef("scala.annotation.Annotation")

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

@@ -15,7 +15,6 @@ import MegaPhase._
 import Types._
 import dotty.tools.dotc.ast.tpd
 
-
 import scala.annotation.tailrec
 
 /** TODO
@@ -26,17 +25,20 @@ class GenericTuples extends MiniPhase with IdentityDenotTransformer {
   def phaseName: String = "genericTuples"
 
   override def transformApply(tree: tpd.Apply)(implicit ctx: Context): tpd.Tree = {
-    if (tree.symbol == defn.Tuple_cons) transformTupleCons(tree)
+    if (tree.symbol == defn.DynamicTuple_dynamicCons) transformTupleCons(tree)
     else super.transformApply(tree)
   }
 
+
+
 //  override def transformTypeApply(tree: tpd.TypeApply)(implicit ctx: Context): tpd.Tree = {
 //    if (tree.symbol == defn.NonEmptyTuple_tail) transformTupleTail(tree)
 //    else super.transformTypeApply(tree)
 //  }
 
   private def transformTupleCons(tree: tpd.Apply)(implicit ctx: Context): Tree = {
-    val TypeApply(Select(qual, _), headType :: tailType :: Nil) = tree.fun
+    val TypeApply(_, headType :: tailType :: Nil) = tree.fun
+    val tail :: head :: Nil = tree.args
     tupleTypes(tree.tpe) match {
       case Some(tpes) =>
         val size = tpes.size
@@ -46,21 +48,22 @@ class GenericTuples extends MiniPhase with IdentityDenotTransformer {
           val tailType =
             if (size == 1) defn.UnitType
             else defn.TupleType(size - 1).appliedTo(tpes.tail)
-          evalOnce(Typed(qual, TypeTree(tailType))) { tup =>
-            val elements = tree.args.head :: (0 until size - 1).map(i => tup.select(nme.selectorName(i))).toList
+          evalOnce(Typed(tail, TypeTree(tailType))) { tup =>
+            val elements = head :: (0 until size - 1).map(i => tup.select(nme.selectorName(i))).toList
             knownTupleFromElements(tpes, elements)
           }
         } else {
           // val it = Iterator.single(head) ++ tail.asInstanceOf[Product].productIterator
           // TupleN(it.next(), ..., it.next())
-          val fullIterator = ref(defn.DynamicTuple_consIterator).appliedToArgs(tree.args.head :: qual :: Nil)
+          val fullIterator = ref(defn.DynamicTuple_consIterator).appliedToArgs(head :: tail :: Nil)
           evalOnce(fullIterator) { it =>
             knownTupleFromIterator(tpes.length, it).asInstance(tree.tpe)
           }
         }
       case _ =>
-        // DynamicTuple.dynamic_*:(tail, head)
-        ref(defn.DynamicTupleModule).select("dynamic_*:".toTermName).appliedToTypeTrees(tailType :: headType :: Nil).appliedToArgs(qual :: tree.args).asInstance(tree.tpe)
+        // DynamicTuple.dynamicCons:(tail, head)
+        tree
+//        ref(defn.DynamicTupleModule).select("dynamicCons".toTermName).appliedToTypeTrees(tailType :: headType :: Nil).appliedToArgs(qual :: tree.args).asInstance(tree.tpe)
     }
   }
 

library/src-3.x/scala/Tuple.scala

@@ -32,7 +32,8 @@ sealed trait Tuple extends Any {
         DynamicTuple.dynamicToArray(this)
     }
 
-  def *: [H, This >: this.type <: Tuple] (x: H): H *: This = ???
+  inline def *: [H, This >: this.type <: Tuple] (x: H): H *: This =
+    DynamicTuple.dynamicCons[This, H](this, x)
 
   inline def ++ [This >: this.type <: Tuple](that: Tuple): Concat[This, that.type] = {
     type Result = Concat[This, that.type]

library/src-3.x/scala/runtime/DynamicTuple.scala

@@ -199,7 +199,7 @@ object DynamicTuple {
       arr
   }
 
-  def dynamic_*: [This <: Tuple, H] (self: Tuple, x: H): H *: This = {
+  def dynamicCons[This <: Tuple, H] (self: Tuple, x: H): H *: This = {
     type Result = H *: This
     (self: Any) match {
       case () =>

tests/run-with-compiler/staged-tuples/StagedTuple.scala

@@ -184,7 +184,7 @@ object StagedTuple {
   }
 
   def consStaged[T <: Tuple & Singleton : Type, H : Type](self: Expr[T], x: Expr[H], tailSize: Option[Int]): Expr[H *: T] =
-  if (!specialize) '{dynamic_*:[T, H]($self, $x)}
+  if (!specialize) '{dynamicCons[T, H]($self, $x)}
   else {
     val res = tailSize match {
       case Some(0) =>
@@ -200,7 +200,7 @@ object StagedTuple {
       case Some(n) =>
         fromArrayStaged[H *: T]('{cons$Array($x, ${ toArrayStaged(self, tailSize) })}, Some(n + 1))
       case _ =>
-        '{dynamic_*:[T, H]($self, $x)}
+        '{dynamicCons[T, H]($self, $x)}
     }
     res.as[H *: T]
   }