Fix tuple match types

nicolasstucki · nicolasstucki · commit db7e1836fc69 · 2018-10-09T09:21:44.000+02:00
Removed all use of match types inside the implementation
of the staged tuples. Pass the expansion of match types
as type parameters instead.
diff --git a/compiler/src/dotty/tools/dotc/CompilationUnit.scala b/compiler/src/dotty/tools/dotc/CompilationUnit.scala
@@ -3,12 +3,14 @@ package dotc
 
 import util.SourceFile
 import ast.{tpd, untpd}
-import tpd.{ Tree, TreeTraverser }
+import dotty.tools.dotc.ast.Trees
+import tpd.{Tree, TreeTraverser}
 import typer.PrepareInlineable.InlineAccessors
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.SymDenotations.ClassDenotation
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.transform.SymUtils._
+import dotty.tools.dotc.typer.Inliner
 
 class CompilationUnit(val source: SourceFile) {
 
@@ -57,6 +59,11 @@ object CompilationUnit {
     def traverse(tree: Tree)(implicit ctx: Context): Unit = {
       if (tree.symbol.isQuote)
         containsQuotes = true
+      tree match {
+        case _: tpd.RefTree | _: Trees.GenericApply[_] if Inliner.isInlineable(tree) =>
+          containsQuotes = true // May inline a quote
+        case _ =>
+      }
       traverseChildren(tree)
     }
   }
diff --git a/library/src-scala3/scala/StagedTuple.scala b/library/src-scala3/scala/StagedTuple.scala
@@ -72,59 +72,61 @@ object StagedTuple {
     res.as[Res]
   }
 
-  def headStaged[Tup <: NonEmptyTuple : Type](tup: Expr[Tup], size: Option[Int]): Expr[Head[Tup]] = {
-    if (!specialize) '(dynamicHead(~tup))
-    else {
-      val resVal = size match {
-        case Some(1) =>
-          '((~tup.as[Tuple1[_]])._1)
-        case Some(2) =>
-          '((~tup.as[Tuple2[_, _]])._1)
-        case Some(3) =>
-          '((~tup.as[Tuple3[_, _, _]])._1)
-        case Some(4) =>
-          '((~tup.as[Tuple4[_, _, _, _]])._1)
-        case Some(n) if n > 4 && n <= $MaxSpecialized =>
-          '((~tup.as[Product]).productElement(0))
-        case Some(n) if n > $MaxSpecialized =>
-          '((~tup.as[TupleXXL]).elems(0))
-        case None =>
-          '(dynamicHead(~tup))
+  def headStaged[Head : Type](tup: Expr[NonEmptyTuple], size: Option[Int]): Expr[Head] = {
+    val res=
+      if (!specialize) '(dynamicHead(~tup))
+      else {
+        size match {
+          case Some(1) =>
+            '((~tup.as[Tuple1[_]])._1)
+          case Some(2) =>
+            '((~tup.as[Tuple2[_, _]])._1)
+          case Some(3) =>
+            '((~tup.as[Tuple3[_, _, _]])._1)
+          case Some(4) =>
+            '((~tup.as[Tuple4[_, _, _, _]])._1)
+          case Some(n) if n > 4 && n <= $MaxSpecialized =>
+            '((~tup.as[Product]).productElement(0))
+          case Some(n) if n > $MaxSpecialized =>
+            '((~tup.as[TupleXXL]).elems(0))
+          case None =>
+            '(dynamicHead(~tup))
+        }
       }
-      resVal.as[Head[Tup]]
-    }
+    res.as[Head]
   }
 
-  def tailStaged[Tup <: NonEmptyTuple : Type](tup: Expr[Tup], size: Option[Int]): Expr[Tail[Tup]] = {
-    if (!specialize) '(dynamicTail[Tup](~tup))
-    else {
-      val res = size match {
-        case Some(1) =>
-          '()
-        case Some(2) =>
-          tup.as[Tuple2[_, _]].bind(t => '(Tuple1((~t)._2)))
-        case Some(3) =>
-          tup.as[Tuple3[_, _, _]].bind(t => '(Tuple2((~t)._2, (~t)._3)))
-        case Some(4) =>
-          tup.as[Tuple4[_, _, _, _]].bind(t => '(Tuple3((~t)._2, (~t)._3, (~t)._4)))
-        case Some(5) =>
-          tup.as[Tuple5[_, _, _, _, _]].bind(t => '(Tuple4((~t)._2, (~t)._3, (~t)._4, (~t)._5)))
-        case Some(n) if n > 5 =>
-          val arr = toArrayStaged(tup, size)
-          fromArrayStaged('((~arr).tail) , Some(n - 1))
-        case None =>
-          '(dynamicTail(~tup))
+  def tailStaged[Tail <: Tuple : Type](tup: Expr[NonEmptyTuple], size: Option[Int]): Expr[Tail] = {
+    val res =
+      if (!specialize) '(dynamicTail(~tup))
+      else {
+        size match {
+          case Some(1) =>
+            '()
+          case Some(2) =>
+            tup.as[Tuple2[_, _]].bind(t => '(Tuple1((~t)._2)))
+          case Some(3) =>
+            tup.as[Tuple3[_, _, _]].bind(t => '(Tuple2((~t)._2, (~t)._3)))
+          case Some(4) =>
+            tup.as[Tuple4[_, _, _, _]].bind(t => '(Tuple3((~t)._2, (~t)._3, (~t)._4)))
+          case Some(5) =>
+            tup.as[Tuple5[_, _, _, _, _]].bind(t => '(Tuple4((~t)._2, (~t)._3, (~t)._4, (~t)._5)))
+          case Some(n) if n > 5 =>
+            val arr = toArrayStaged(tup, size)
+            fromArrayStaged('((~arr).tail) , Some(n - 1))
+          case None =>
+            '(dynamicTail(~tup))
+        }
       }
-      res.as[Tail[Tup]]
-    }
+    res.as[Tail]
   }
 
-  def applyStaged[Tup <: NonEmptyTuple : Type, N <: Int : Type](tup: Expr[Tup], size: Option[Int], n: Expr[N], nValue: Option[Int]): Expr[Elem[Tup, N]] = {
-    if (!specialize) '(dynamicApply(~tup, ~n))
+  def applyStaged[Elem : Type](tup: Expr[NonEmptyTuple], size: Option[Int], n: Expr[Int], nValue: Option[Int]): Expr[Elem] = {
+    if (!specialize) ('(dynamicApply(~tup, ~n))).as[Elem]
     else {
-      def fallbackApply(): Expr[Elem[Tup, N]] = nValue match {
+      def fallbackApply(): Expr[Elem] = nValue match {
         case Some(n) => quoted.QuoteError("index out of bounds: " + n)
-        case None => '(dynamicApply(~tup, ~n))
+        case None => ('(dynamicApply(~tup, ~n))).as[Elem]
       }
       val res = size match {
         case Some(1) =>
@@ -171,89 +173,91 @@ object StagedTuple {
           }
         case _ => fallbackApply()
       }
-      res.as[Elem[Tup, N]]
+      res.as[Elem]
     }
   }
 
-  def stagedCons[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))
-  else {
-    val res = tailSize match {
-      case Some(0) =>
-        '(Tuple1(~x))
-      case Some(1) =>
-        self.as[Tuple1[_]].bind(t => '(Tuple2(~x, (~t)._1)))
-      case Some(2) =>
-        self.as[Tuple2[_, _]].bind(t => '(Tuple3(~x, (~t)._1, (~t)._2)))
-      case Some(3) =>
-        self.as[Tuple3[_, _, _]].bind(t => '(Tuple4(~x, (~t)._1, (~t)._2, (~t)._3)))
-      case Some(4) =>
-        self.as[Tuple4[_, _, _, _]].bind(t => '(Tuple5(~x, (~t)._1, (~t)._2, (~t)._3, (~t)._4)))
-      case Some(n) =>
-        fromArrayStaged('($consArray(~x, ~toArrayStaged(self, tailSize))), Some(n + 1))
-      case _ =>
-        '(dynamic_*:[T, H](~self, ~x))
-    }
-    res.as[H *: T]
+  def stagedCons[Res <: NonEmptyTuple : Type, H : Type](self: Expr[Tuple], x: Expr[H], tailSize: Option[Int]): Expr[Res] = {
+    val res =
+      if (!specialize) '(dynamic_*:(~self, ~x))
+      else {
+        tailSize match {
+          case Some(0) =>
+            '(Tuple1(~x))
+          case Some(1) =>
+            self.as[Tuple1[_]].bind(t => '(Tuple2(~x, (~t)._1)))
+          case Some(2) =>
+            self.as[Tuple2[_, _]].bind(t => '(Tuple3(~x, (~t)._1, (~t)._2)))
+          case Some(3) =>
+            self.as[Tuple3[_, _, _]].bind(t => '(Tuple4(~x, (~t)._1, (~t)._2, (~t)._3)))
+          case Some(4) =>
+            self.as[Tuple4[_, _, _, _]].bind(t => '(Tuple5(~x, (~t)._1, (~t)._2, (~t)._3, (~t)._4)))
+          case Some(n) =>
+            fromArrayStaged('($consArray(~x, ~toArrayStaged(self, tailSize))), Some(n + 1))
+          case _ =>
+            '(dynamic_*:(~self, ~x))
+        }
+      }
+    res.as[Res]
   }
 
-  def stagedConcat[Self <: Tuple & Singleton : Type, That <: Tuple & Singleton : Type](self: Expr[Self], selfSize: Option[Int], that: Expr[That], thatSize: Option[Int]): Expr[Concat[Self, That]] = {
-    if (!specialize) '(dynamic_++[Self, That](~self, ~that))
-    else {
-      def genericConcat(xs: Expr[Tuple], ys: Expr[Tuple]): Expr[Tuple] =
-        fromArrayStaged[Tuple]('((~toArrayStaged(xs, None)) ++ (~toArrayStaged(ys, None))), None)
-
-      val res = selfSize match {
-        case Some(0) =>
-          that
-        case Some(1) =>
-          if (thatSize.contains(0)) self
-          else stagedCons(that, self.as[Tuple1[_]], thatSize)
-        case Some(2) =>
-          val self2 = self.as[Tuple2[_, _]]
-          thatSize match {
-            case Some(0) => self
-            case Some(1) =>
-              self2.bind { t =>
-                that.as[Tuple1[_]].bind(u => '(Tuple3((~t)._1, (~t)._2, (~u)._1)))
-              }
-            case Some(2) =>
-              self2.bind { t =>
-                that.as[Tuple2[_, _]].bind(u => '(Tuple4((~t)._1, (~t)._2, (~u)._1, (~u)._2)))
-              }
-            case _ =>
-              genericConcat(self, that)
-          }
-        case Some(3) =>
-          val self2 = self.as[Tuple3[_, _, _]]
-          thatSize match {
-            case Some(0) => self
-            case Some(1) =>
-              self2.bind { t =>
-                that.as[Tuple1[_]].bind(u => '(Tuple4((~t)._1, (~t)._2, (~t)._3, (~u)._1)))
-              }
-            case _ =>
-              genericConcat(self, that)
-          }
-        case Some(_) =>
-          if (thatSize.contains(0)) self
-          else genericConcat(self, that)
-        case None =>
-          '(dynamic_++(~self, ~that))
+  def stagedConcat[Concat <: Tuple : Type](self: Expr[Tuple], selfSize: Option[Int], that: Expr[Tuple], thatSize: Option[Int]): Expr[Concat] = {
+    val res =
+      if (!specialize) '(dynamic_++(~self, ~that))
+      else {
+        def genericConcat(xs: Expr[Tuple], ys: Expr[Tuple]): Expr[Tuple] =
+          fromArrayStaged[Tuple]('((~toArrayStaged(xs, None)) ++ (~toArrayStaged(ys, None))), None)
+        selfSize match {
+          case Some(0) =>
+            that
+          case Some(1) =>
+            if (thatSize.contains(0)) self
+            else stagedCons(that, self.as[Tuple1[_]], thatSize)
+          case Some(2) =>
+            val self2 = self.as[Tuple2[_, _]]
+            thatSize match {
+              case Some(0) => self
+              case Some(1) =>
+                self2.bind { t =>
+                  that.as[Tuple1[_]].bind(u => '(Tuple3((~t)._1, (~t)._2, (~u)._1)))
+                }
+              case Some(2) =>
+                self2.bind { t =>
+                  that.as[Tuple2[_, _]].bind(u => '(Tuple4((~t)._1, (~t)._2, (~u)._1, (~u)._2)))
+                }
+              case _ =>
+                genericConcat(self, that)
+            }
+          case Some(3) =>
+            val self2 = self.as[Tuple3[_, _, _]]
+            thatSize match {
+              case Some(0) => self
+              case Some(1) =>
+                self2.bind { t =>
+                  that.as[Tuple1[_]].bind(u => '(Tuple4((~t)._1, (~t)._2, (~t)._3, (~u)._1)))
+                }
+              case _ =>
+                genericConcat(self, that)
+            }
+          case Some(_) =>
+            if (thatSize.contains(0)) self
+            else genericConcat(self, that)
+          case None =>
+            '(dynamic_++(~self, ~that))
+        }
       }
-      res.as[Concat[Self, That]]
-    }
+    res.as[Concat]
   }
 
-  private implicit class ExprOps[U: Type](expr: Expr[U]) {
-
+  private implicit class ExprOps[U](expr: Expr[U]) {
     def as[T: Type]: Expr[T] = '{ (~expr).asInstanceOf[T] }
+  }
 
+  private implicit class ExprTypedOps[U: Type](expr: Expr[U]) {
     def bind[T](in: Expr[U] => Expr[T]): Expr[T] = '{
       val t: U = (~expr)
       ~(in('(t)))
     }
-
   }
 
 }
diff --git a/library/src-scala3/scala/Tuple.scala b/library/src-scala3/scala/Tuple.scala
@@ -10,10 +10,10 @@ sealed trait Tuple extends Any {
     ~toArrayStaged('(this), constValueOpt[BoundedSize[this.type]])
 
   inline def *: [H] (x: H): H *: this.type =
-    ~stagedCons('(this), '(x), constValueOpt[BoundedSize[this.type]])
+    ~stagedCons[H *: this.type, H]('(this), '(x), constValueOpt[BoundedSize[this.type]])
 
   inline def ++(that: Tuple): Concat[this.type, that.type] =
-    ~stagedConcat('(this), constValueOpt[BoundedSize[this.type]], '(that), constValueOpt[BoundedSize[that.type]])
+    ~stagedConcat[Concat[this.type, that.type]]('(this), constValueOpt[BoundedSize[this.type]], '(that), constValueOpt[BoundedSize[that.type]])
 
   inline def size: Size[this.type] =
     ~sizeStaged[Size[this.type]]('(this), constValueOpt[BoundedSize[this.type]])
@@ -182,13 +182,13 @@ abstract sealed class NonEmptyTuple extends Tuple {
   import StagedTuple._
 
   inline def head: Head[this.type] =
-    ~headStaged[this.type]('(this), constValueOpt[BoundedSize[this.type]])
+    ~headStaged[Head[this.type]]('(this), constValueOpt[BoundedSize[this.type]])
 
   inline def tail: Tail[this.type] =
-    ~tailStaged[this.type]('(this), constValueOpt[BoundedSize[this.type]])
+    ~tailStaged[Tail[this.type]]('(this), constValueOpt[BoundedSize[this.type]])
 
   inline def apply(n: Int): Elem[this.type, n.type] =
-    ~applyStaged[this.type, n.type]('(this), constValueOpt[Size[this.type]], '(n), constValueOpt[n.type])
+    ~applyStaged[Elem[this.type, n.type]]('(this), constValueOpt[Size[this.type]], '(n), constValueOpt[n.type])
 
 }
 
diff --git a/tests/run/tuples1.scala b/tests/run/tuples1.scala
diff --git a/tests/run/tuples1a.scala b/tests/run/tuples1a.scala
@@ -0,0 +1,9 @@
+object Test extends App {
+  val t7 = '5' *: 4 *: "C" *: ()
+
+  val t7a = t7.tail
+  val t7b = t7a.tail
+  val t7c: Unit = (t7.tail: (Int, String)).tail
+  val t7d: Unit = (t7.tail: Int *: String *: Unit).tail
+  val t7e: Unit = t7.tail.tail
+}
