Implement Tuple.head as Tuple.apply(0)

Author: nicolasstucki

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

@@ -809,7 +809,6 @@ class Definitions {
     lazy val DynamicTuple_concatIterator: Symbol = DynamicTupleModule.requiredMethod("concatIterator")
     lazy val DynamicTuple_dynamicApply: Symbol = DynamicTupleModule.requiredMethod("dynamicApply")
     lazy val DynamicTuple_dynamicCons: Symbol = DynamicTupleModule.requiredMethod("dynamicCons")
-    lazy val DynamicTuple_dynamicHead: Symbol = DynamicTupleModule.requiredMethod("dynamicHead")
     lazy val DynamicTuple_dynamicSize: Symbol = DynamicTupleModule.requiredMethod("dynamicSize")
     lazy val DynamicTuple_dynamicTail: Symbol = DynamicTupleModule.requiredMethod("dynamicTail")
     lazy val DynamicTuple_dynamicConcat: Symbol = DynamicTupleModule.requiredMethod("dynamicConcat")

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

@@ -26,7 +26,6 @@ class GenericTuples extends MiniPhase with IdentityDenotTransformer {
 
   override def transformApply(tree: tpd.Apply)(implicit ctx: Context): tpd.Tree = {
     if (tree.symbol == defn.DynamicTuple_dynamicCons) transformTupleCons(tree)
-    else if (tree.symbol == defn.DynamicTuple_dynamicHead) transformTupleHead(tree)
     else if (tree.symbol == defn.DynamicTuple_dynamicTail) transformTupleTail(tree)
     else if (tree.symbol == defn.DynamicTuple_dynamicSize) transformTupleSize(tree)
     else if (tree.symbol == defn.DynamicTuple_dynamicConcat) transformTupleConcat(tree)
@@ -96,23 +95,6 @@ class GenericTuples extends MiniPhase with IdentityDenotTransformer {
     }
   }
 
-  private def transformTupleHead(tree: tpd.Apply)(implicit ctx: Context): Tree = {
-    val Apply(TypeApply(_, tpt :: Nil), tup :: Nil) = tree
-    tupleTypes(tpt.tpe) match { // TODO tupleBoundedTypes
-      case Some(tpes) =>
-        if (tpes.size <= Definitions.MaxTupleArity) {
-          // tup._1
-          Typed(tup, TypeTree(defn.tupleType(tpes))).select(nme.selectorName(0))
-        } else {
-          // tup.asInstanceOf[TupleXXL].productElement(0)
-          tup.asInstance(defn.TupleXXLType).select(nme.productElement).appliedTo(Literal(Constant(0)))
-        }
-      case None =>
-        // DynamicTuple.dynamicHead(tup)
-        tree
-    }
-  }
-
   private def transformTupleSize(tree: tpd.Apply)(implicit ctx: Context): Tree = {
     tree.tpe.tryNormalize match {
       case tp: ConstantType => Literal(tp.value)

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

@@ -66,14 +66,15 @@ object Tuple {
 sealed trait NonEmptyTuple extends Tuple {
   import Tuple._
 
+  inline def apply[This >: this.type <: NonEmptyTuple](n: Int): Elem[This, n.type] =
+    DynamicTuple.dynamicApply[This, n.type](this, n)
+
   inline def head[This >: this.type <: NonEmptyTuple]: Head[This] =
-    DynamicTuple.dynamicHead[This](this)
+    DynamicTuple.dynamicApply[This, 0](this, 0)
 
   inline def tail[This >: this.type <: NonEmptyTuple]: Tail[This] =
     DynamicTuple.dynamicTail[This](this)
 
-  inline def apply[This >: this.type <: NonEmptyTuple](n: Int): Elem[This, n.type] =
-    DynamicTuple.dynamicApply[This, n.type](this, n)
 }
 
 @showAsInfix

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

@@ -226,9 +226,6 @@ object DynamicTuple {
     case self: Product => self.productArity.asInstanceOf[Size[This]]
   }
 
-  def dynamicHead[This <: NonEmptyTuple] (self: This): Head[This] =
-    self.asInstanceOf[Product].productElement(0).asInstanceOf[Head[This]]
-
   def dynamicTail[This <: NonEmptyTuple] (self: This): Tail[This] = {
     type Result = Tail[This]
     val res = (self: Any) match {
@@ -245,7 +242,6 @@ object DynamicTuple {
     type Result = Elem[This, N]
     val res = (self: Any) match {
       case self: Unit => throw new IndexOutOfBoundsException(n.toString)
-      case self: TupleXXL => self.elems(n)
       case self: Product => self.productElement(n)
     }
     res.asInstanceOf[Result]

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

@@ -79,7 +79,7 @@ object StagedTuple {
   }
 
   def headStaged[Tup <: NonEmptyTuple : Type](tup: Expr[Tup], size: Option[Int]): Expr[Head[Tup]] = {
-    if (!specialize) '{dynamicHead($tup)}
+    if (!specialize) '{dynamicApply($tup, 0)}
     else {
       val resVal = size match {
         case Some(1) =>
@@ -95,7 +95,7 @@ object StagedTuple {
         case Some(n) if n > MaxSpecialized =>
           '{${tup.as[TupleXXL] }.elems(0)}
         case None =>
-          '{dynamicHead($tup)}
+          '{dynamicApply($tup, 0)}
       }
       resVal.as[Head[Tup]]
     }