Refactor direct usages of throw QuoteError

Author: biboudis

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

@@ -45,8 +45,11 @@ class PlainPrinter(_ctx: Context) extends Printer {
   protected def debugPos: Boolean = ctx.settings.YdebugPos.value
 
   def homogenize(tp: Type): Type =
-    if (homogenizedView)
-      tp match {
+    if (homogenizedView) {
+       val a = tp.tryNormalize
+          if (a.exists) {
+            homogenize(a)
+          } else tp match {
         case tp: ThisType if tp.cls.is(Package) && !tp.cls.isEffectiveRoot =>
           ctx.requiredPackage(tp.cls.fullName).termRef
         case tp: TypeVar if tp.isInstantiated =>
@@ -62,9 +65,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
         case AppliedType(tycon, args) =>
           tycon.dealias.appliedTo(args)
         case _ =>
-          tp
+         tp
       }
-    else tp
+    } else tp
 
   private def sameBound(lo: Type, hi: Type): Boolean =
     try lo frozen_=:= hi catch { case NonFatal(ex) => false }

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

@@ -46,7 +46,14 @@ object Splicer {
       }
       catch {
         case ex: scala.quoted.QuoteError =>
-          ctx.error(ex.getMessage, pos)
+          val pos1 = ex.from match {
+            case None => pos
+            case Some(expr) =>
+              val reflect: scala.tasty.Reflection = ReflectionImpl(ctx)
+              import reflect._
+              expr.unseal.underlyingArgument.pos.asInstanceOf[SourcePosition]
+          }
+          ctx.error(ex.getMessage, pos1)
           EmptyTree
         case NonFatal(ex) =>
           val msg =

docs/docs/reference/other-new-features/tasty-reflect.md

@@ -42,10 +42,10 @@ def natConstImpl(x: Expr[Int])(implicit reflection: Reflection): Expr[Int] = {
   xTree match {
     case Term.Literal(Constant.Int(n)) =>
       if (n <= 0)
-        throw new QuoteError("Parameter must be natural number")
+        QuoteError("Parameter must be natural number")
       n.toExpr
     case _ =>
-      throw new QuoteError("Parameter must be a known constant")
+      QuoteError("Parameter must be a known constant")
   }
 }
 ```

library/src-bootstrapped/scala/Tuple.scala

@@ -1,7 +1,6 @@
 package scala
 import annotation.showAsInfix
 import compiletime._
-import scala.StagedTuple
 
 sealed trait Tuple extends Any {
   import Tuple._
@@ -10,7 +9,7 @@ sealed trait Tuple extends Any {
     if (stageIt) toArrayStaged
     else inline constValueOpt[BoundedSize[this.type]] match {
       case Some(0) =>
-        empty$Array
+        scala.runtime.DynamicTuple.empty$Array
       case Some(1) =>
         val t = asInstanceOf[Tuple1[Object]]
         Array(t._1)
@@ -23,12 +22,12 @@ sealed trait Tuple extends Any {
       case Some(4) =>
         val t = asInstanceOf[Tuple4[Object, Object, Object, Object]]
         Array(t._1, t._2, t._3, t._4)
-      case Some(n) if n <= MaxSpecialized =>
+      case Some(n) if n <= scala.runtime.DynamicTuple.MaxSpecialized =>
         to$Array(this, n)
       case Some(n) =>
         asInstanceOf[TupleXXL].elems
       case None =>
-        dynamicToArray(this)
+        runtime.DynamicTuple.dynamicToArray(this)
     }
 
   inline def toArrayStaged: Array[Object] =
@@ -55,7 +54,7 @@ sealed trait Tuple extends Any {
         case Some(n) =>
           fromArray[H *: this.type](cons$Array(x, toArray))
         case _ =>
-          dynamic_*:[This, H](this, x)
+          runtime.DynamicTuple.dynamic_*:[This, H](this, x)
       }
     }
 
@@ -99,7 +98,7 @@ sealed trait Tuple extends Any {
           if (constValue[BoundedSize[that.type]] == 0) this.asInstanceOf[Result]
           else genericConcat[Result](this, that).asInstanceOf[Result]
         case None =>
-          dynamic_++[This, that.type](this, that)
+          runtime.DynamicTuple.dynamic_++[This, that.type](this, that)
       }
     }
 
@@ -116,7 +115,7 @@ sealed trait Tuple extends Any {
       type Result = Size[This]
       inline constValueOpt[BoundedSize[this.type]] match {
         case Some(n) => n.asInstanceOf[Result]
-        case _ => dynamicSize(this)
+        case _ => runtime.DynamicTuple.dynamicSize(this)
       }
     }
 
@@ -125,9 +124,6 @@ sealed trait Tuple extends Any {
 }
 
 object Tuple {
-  inline val MaxSpecialized = 22
-  inline private val XXL = MaxSpecialized + 1
-
   final val stageIt = true
 
   type Head[X <: NonEmptyTuple] = X match {
@@ -167,7 +163,7 @@ object Tuple {
 
   private[scala] type BoundedSize[X] = BoundedSizeRecur[X, 23]
 
-  val empty$Array = Array[Object]()
+  val $emptyArray = Array[Object]()
 
   def to$Array(xs: Tuple, n: Int) = {
     val arr = new Array[Object](n)
@@ -217,99 +213,11 @@ object Tuple {
     }
 
   inline def fromArrayStaged[T <: Tuple](xs: Array[Object]): T =
-    ${ StagedTuple.fromArrayStaged[T]('xs, constValueOpt[BoundedSize[this.type]]) }
-
-  def dynamicFromArray[T <: Tuple](xs: Array[Object]): T = xs.length match {
-    case 0  => ().asInstanceOf[T]
-    case 1  => Tuple1(xs(0)).asInstanceOf[T]
-    case 2  => Tuple2(xs(0), xs(1)).asInstanceOf[T]
-    case 3  => Tuple3(xs(0), xs(1), xs(2)).asInstanceOf[T]
-    case 4  => Tuple4(xs(0), xs(1), xs(2), xs(3)).asInstanceOf[T]
-    case 5  => Tuple5(xs(0), xs(1), xs(2), xs(3), xs(4)).asInstanceOf[T]
-    case 6  => Tuple6(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5)).asInstanceOf[T]
-    case 7  => Tuple7(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6)).asInstanceOf[T]
-    case 8  => Tuple8(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7)).asInstanceOf[T]
-    case 9  => Tuple9(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8)).asInstanceOf[T]
-    case 10 => Tuple10(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9)).asInstanceOf[T]
-    case 11 => Tuple11(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10)).asInstanceOf[T]
-    case 12 => Tuple12(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11)).asInstanceOf[T]
-    case 13 => Tuple13(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12)).asInstanceOf[T]
-    case 14 => Tuple14(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13)).asInstanceOf[T]
-    case 15 => Tuple15(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14)).asInstanceOf[T]
-    case 16 => Tuple16(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15)).asInstanceOf[T]
-    case 17 => Tuple17(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16)).asInstanceOf[T]
-    case 18 => Tuple18(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17)).asInstanceOf[T]
-    case 19 => Tuple19(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18)).asInstanceOf[T]
-    case 20 => Tuple20(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18), xs(19)).asInstanceOf[T]
-    case 21 => Tuple21(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18), xs(19), xs(20)).asInstanceOf[T]
-    case 22 => Tuple22(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18), xs(19), xs(20), xs(21)).asInstanceOf[T]
-    case _ => TupleXXL(xs).asInstanceOf[T]
-  }
-
-  def dynamicToArray(self: Tuple): Array[Object] = (self: Any) match {
-    case self: Unit =>
-      empty$Array
-    case self: Tuple1[_] =>
-      val t = self.asInstanceOf[Tuple1[Object]]
-      Array(t._1)
-    case self: Tuple2[_, _] =>
-      val t = self.asInstanceOf[Tuple2[Object, Object]]
-      Array(t._1, t._2)
-    case self: Tuple3[_, _, _] =>
-      val t = self.asInstanceOf[Tuple3[Object, Object, Object]]
-      Array(t._1, t._2, t._3)
-    case self: Tuple4[_, _, _, _] =>
-      val t = self.asInstanceOf[Tuple4[Object, Object, Object, Object]]
-      Array(t._1, t._2, t._3, t._4)
-    case self: TupleXXL =>
-      self.elems
-    case self: Product =>
-      val arr = new Array[Object](self.productArity)
-      for (i <- 0 until arr.length) arr(i) = self.productElement(i).asInstanceOf[Object]
-      arr
-  }
-
-  def dynamic_*: [This <: Tuple, H] (self: Tuple, x: H): H *: This = {
-    type Result = H *: This
-    (self: Any) match {
-      case Unit =>
-        Tuple1(x).asInstanceOf[Result]
-      case self: Tuple1[_] =>
-        Tuple2(x, self._1).asInstanceOf[Result]
-      case self: Tuple2[_, _] =>
-        Tuple3(x, self._1, self._2).asInstanceOf[Result]
-      case self: Tuple3[_, _, _] =>
-        Tuple4(x, self._1, self._2, self._3).asInstanceOf[Result]
-      case self: Tuple4[_, _, _, _] =>
-        Tuple5(x, self._1, self._2, self._3, self._4).asInstanceOf[Result]
-      case _ =>
-        dynamicFromArray[Result](cons$Array(x, dynamicToArray(self)))
-    }
-  }
-
-  def dynamic_++[This <: Tuple, That <: Tuple](self: This, that: That): Concat[This, That] = {
-    type Result = Concat[This, That]
-    (this: Any) match {
-      case self: Unit => return self.asInstanceOf[Result]
-      case _ =>
-    }
-    (that: Any) match {
-      case that: Unit => return self.asInstanceOf[Result]
-      case _ =>
-    }
-    dynamicFromArray[Result](dynamicToArray(self) ++ dynamicToArray(that))
-  }
-
-  def dynamicSize[This <: Tuple](self: This): Size[This] = (self: Any) match {
-    case self: Unit => 0.asInstanceOf[Size[This]]
-    case self: TupleXXL => self.elems.length.asInstanceOf[Size[This]]
-    case self: Product => self.productArity.asInstanceOf[Size[This]]
-  }
+    ${StagedTuple.fromArrayStaged[T]('xs, constValueOpt[BoundedSize[this.type]])}
 }
 
 sealed trait NonEmptyTuple extends Tuple {
   import Tuple._
-  import NonEmptyTuple._
 
   inline def head[This >: this.type <: NonEmptyTuple]: Head[This] =
     if (stageIt) headStaged.asInstanceOf
@@ -328,13 +236,13 @@ sealed trait NonEmptyTuple extends Tuple {
         case Some(4) =>
           val t = asInstanceOf[Tuple4[_, _, _, _]]
           t._1
-        case Some(n) if n > 4 && n <= MaxSpecialized =>
+        case Some(n) if n > 4 && n <= scala.runtime.DynamicTuple.MaxSpecialized =>
           asInstanceOf[Product].productElement(0)
-        case Some(n) if n > MaxSpecialized =>
+        case Some(n) if n > scala.runtime.DynamicTuple.MaxSpecialized =>
           val t = asInstanceOf[TupleXXL]
           t.elems(0)
         case None =>
-          dynamicHead[this.type](this)
+          scala.runtime.DynamicTuple.dynamicHead[this.type](this)
       }
       resVal.asInstanceOf[Result]
     }
@@ -364,7 +272,7 @@ sealed trait NonEmptyTuple extends Tuple {
         case Some(n) if n > 5 =>
           fromArray[Result](toArray.tail)
         case None =>
-          dynamicTail[This](this)
+          runtime.DynamicTuple.dynamicTail[This](this)
       }
     }
 
@@ -374,7 +282,7 @@ sealed trait NonEmptyTuple extends Tuple {
   inline def fallbackApply(n: Int) =
     inline constValueOpt[n.type] match {
       case Some(n: Int) => error("index out of bounds: ", n)
-      case None => dynamicApply[this.type, n.type](this, n)
+      case None => runtime.DynamicTuple.dynamicApply[this.type, n.type](this, n)
     }
 
   inline def apply[This >: this.type <: NonEmptyTuple](n: Int): Elem[This, n.type] =
@@ -412,13 +320,13 @@ sealed trait NonEmptyTuple extends Tuple {
             case Some(3) => t._4.asInstanceOf[Result]
             case _ => fallbackApply(n).asInstanceOf[Result]
           }
-        case Some(s) if s > 4 && s <= MaxSpecialized =>
+        case Some(s) if s > 4 && s <= scala.runtime.DynamicTuple.MaxSpecialized =>
           val t = asInstanceOf[Product]
           inline constValueOpt[n.type] match {
             case Some(n) if n >= 0 && n < s => t.productElement(n).asInstanceOf[Result]
             case _ => fallbackApply(n).asInstanceOf[Result]
           }
-        case Some(s) if s > MaxSpecialized =>
+        case Some(s) if s > scala.runtime.DynamicTuple.MaxSpecialized =>
           val t = asInstanceOf[TupleXXL]
           inline constValueOpt[n.type] match {
             case Some(n) if n >= 0 && n < s => t.elems(n).asInstanceOf[Result]
@@ -429,53 +337,14 @@ sealed trait NonEmptyTuple extends Tuple {
     }
 
   inline def applyStaged(n: Int): Elem[this.type, n.type] =
-    ${ StagedTuple.applyStaged[this.type, n.type](
-       'this, constValueOpt[Size[this.type]],
-       'n, constValueOpt[n.type]) }
-}
-
-object NonEmptyTuple {
-  import Tuple._
-
-  def dynamicHead[This <: NonEmptyTuple] (self: This): Head[This] = {
-    type Result = Head[This]
-    val res = (self: Any) match {
-      case self: Tuple1[_] => self._1
-      case self: Tuple2[_, _] => self._1
-      case self: Tuple3[_, _, _] => self._1
-      case self: Tuple4[_, _, _, _] => self._1
-      case self: TupleXXL => self.elems(0)
-      case self: Product => self.productElement(0)
-    }
-    res.asInstanceOf[Result]
-  }
-
-  def dynamicTail[This <: NonEmptyTuple] (self: This): Tail[This] = {
-    type Result = Tail[This]
-    val res = (self: Any) match {
-      case self: Tuple1[_] => ()
-      case self: Tuple2[_, _] => Tuple1(self._2)
-      case self: Tuple3[_, _, _] => Tuple2(self._2, self._3)
-      case self: Tuple4[_, _, _, _] => Tuple3(self._2, self._3, self._4)
-      case _ => dynamicFromArray[Result](dynamicToArray(self).tail)
-    }
-    res.asInstanceOf[Result]
-  }
-
-  def dynamicApply[This <: NonEmptyTuple, N <: Int] (self: This, n: N): Elem[This, N] = {
-    type Result = Elem[This, N]
-    val res = (self: Any) match {
-      case self: TupleXXL => self.elems(n)
-      case self: Product => self.productElement(n)
-    }
-    res.asInstanceOf[Result]
-  }
+    ${StagedTuple.applyStaged[this.type, n.type](
+      'this, constValueOpt[Size[this.type]], 'n, constValueOpt[n.type])}
 }
 
 @showAsInfix
 sealed class *:[+H, +T <: Tuple] extends NonEmptyTuple
 
 object *: {
   inline def unapply[H, T <: Tuple](x: H *: T) =
-    (NonEmptyTuple.dynamicHead(x), NonEmptyTuple.dynamicTail(x))
+    (scala.runtime.DynamicTuple.dynamicHead(x), scala.runtime.DynamicTuple.dynamicTail(x))
 }

library/src-bootstrapped/scala/StagedTuple.scala renamed to library/src-bootstrapped/scala/compiletime/StagedTuple.scala

@@ -1,18 +1,22 @@
-package scala
+package scala.compiletime
 
 import scala.quoted._
 
 object StagedTuple {
-  import Tuple._
-  import NonEmptyTuple._
+  import Tuple.Concat
+  import Tuple.Head
+  import Tuple.Tail
+  import Tuple.Size
+  import Tuple.Elem
+  import scala.runtime.DynamicTuple._
 
   private final val specialize = true
 
   def toArrayStaged(tup: Expr[Tuple], size: Option[Int]): Expr[Array[Object]] = {
     if (!specialize) '{dynamicToArray($tup)}
     else size match {
       case Some(0) =>
-        '{empty$Array}
+        '{scala.runtime.DynamicTuple.empty$Array}
       case Some(1) =>
         tup.as[Tuple1[Object]].bind(t => '{Array($t._1)})
       case Some(2) =>
@@ -121,11 +125,15 @@ object StagedTuple {
     }
   }
 
-  def applyStaged[Tup <: NonEmptyTuple : Type, N <: Int : Type](tup: Expr[Tup], size: Option[Int], n: Expr[N], nValue: Option[Int]): Expr[Elem[Tup, N]] = {
+  implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
+
+  def applyStaged[Tup <: NonEmptyTuple : Type, N <: Int : Type](tup: Expr[Tup], size: Option[Int], n: Expr[N], nValue: Option[Int])(implicit reflect: tasty.Reflection): Expr[Elem[Tup, N]] = {
+    import reflect._
+
     if (!specialize) '{dynamicApply($tup, $n)}
     else {
       def fallbackApply(): Expr[Elem[Tup, N]] = nValue match {
-        case Some(n) => quoted.QuoteError("index out of bounds: " + n)
+        case Some(n) => quoted.QuoteError("index out of bounds: " + n, tup)
         case None => '{dynamicApply($tup, $n)}
       }
       val res = size match {
@@ -256,7 +264,5 @@ object StagedTuple {
       val t: U = $expr
       ${in('t)}
     }
-
   }
-
 }