Add QuoteScope

Author: nicolasstucki

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

@@ -675,8 +675,10 @@ class Definitions {
   @tu lazy val QuotedExprModule: Symbol = QuotedExprClass.companionModule
     @tu lazy val QuotedExprModule_nullExpr: Symbol = QuotedExprModule.requiredMethod(nme.nullExpr)
     @tu lazy val QuotedExprModule_unitExpr: Symbol = QuotedExprModule.requiredMethod(nme.unitExpr)
+    @tu lazy val QuotedExprModule_unsafeExpr: Symbol = QuotedExprModule.requiredMethod("unsafeExpr")
 
   @tu lazy val QuoteContextClass: ClassSymbol = ctx.requiredClass("scala.quoted.QuoteContext")
+  @tu lazy val QuoteScopeClass: ClassSymbol = ctx.requiredClass("scala.quoted.QuoteScope")
 
   @tu lazy val LiftableModule: Symbol = ctx.requiredModule("scala.quoted.Liftable")
     @tu lazy val LiftableModule_BooleanIsLiftable: Symbol = LiftableModule.requiredMethod("BooleanIsLiftable")
@@ -713,6 +715,7 @@ class Definitions {
     @tu lazy val QuotedType_splice: Symbol = QuotedTypeClass.requiredType(tpnme.splice)
 
   @tu lazy val QuotedTypeModule: Symbol = QuotedTypeClass.companionModule
+    @tu lazy val QuotedTypeModule_unsafeType: Symbol = QuotedTypeModule.requiredMethod("unsafeType")
 
   @tu lazy val TastyReflectionClass: ClassSymbol = ctx.requiredClass("scala.tasty.Reflection")
 

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

@@ -248,7 +248,7 @@ class ReifyQuotes extends MacroTransform {
                 assert(tpw.isInstanceOf[ValueType])
                 val argTpe =
                   if (tree.isType) defn.QuotedTypeClass.typeRef.appliedTo(tpw)
-                  else defn.FunctionType(1, isContextual = true).appliedTo(defn.QuoteContextClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpw))
+                  else defn.FunctionType(1, isContextual = true).appliedTo(defn.QuoteScopeClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpw))
                 val selectArg = arg.select(nme.apply).appliedTo(Literal(Constant(i))).cast(argTpe)
                 val capturedArg = SyntheticValDef(UniqueName.fresh(tree.symbol.name.toTermName).toTermName, selectArg)
                 i += 1

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

@@ -189,6 +189,13 @@ object Splicer {
             ctx.error("Macro cannot be implemented with an `inline` method", fn.sourcePos)
           args.flatten.foreach(checkIfValidArgument)
 
+        case TypeApply(aio @ Select(expr, _), _) if aio.symbol == defn.Any_typeCast =>
+          checkIfValidStaticCall(expr)
+
+        case Apply(Select(Apply(unsafe, _), nme.apply), List(expr))
+            if unsafe.symbol == defn.QuotedExprModule_unsafeExpr || unsafe.symbol == defn.QuotedTypeModule_unsafeType =>
+          checkIfValidStaticCall(expr)
+
         case _ =>
           ctx.error(
             """Malformed macro.
@@ -231,6 +238,13 @@ object Splicer {
       case Apply(Select(TypeApply(fn, quoted :: Nil), _), _) if fn.symbol == defn.InternalQuoted_typeQuote =>
         interpretTypeQuote(quoted)
 
+      case Apply(Select(Apply(unsafe, _), nme.apply), List(expr))
+          if unsafe.symbol == defn.QuotedExprModule_unsafeExpr || unsafe.symbol == defn.QuotedTypeModule_unsafeType =>
+        interpretTree(expr)
+
+      case TypeApply(aio @ Select(expr, _), _) if aio.symbol == defn.Any_typeCast =>
+        interpretTree(expr)
+
       case Literal(Constant(value)) =>
         interpretLiteral(value)
 

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

@@ -46,10 +46,10 @@ trait QuotesAndSplices {
         ctx.warning("Canceled splice directly inside a quote. '[ ${ XYZ } ] is equivalent to XYZ.", tree.sourcePos)
       case _ =>
     }
-    val qctx = inferImplicitArg(defn.QuoteContextClass.typeRef, tree.span)
+    val qctx = inferImplicitArg(defn.QuoteScopeClass.typeRef, tree.span)
 
     if qctx.tpe.isInstanceOf[SearchFailureType] then
-      ctx.error(missingArgMsg(qctx, defn.QuoteContextClass.typeRef, ""), ctx.source.atSpan(tree.span))
+      ctx.error(missingArgMsg(qctx, defn.QuoteScopeClass.typeRef, ""), ctx.source.atSpan(tree.span))
     else if !qctx.tpe.isStable then
       ctx.error(em"Quotes require stable QuoteContext, but found non stable $qctx", qctx.sourcePos)
 

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

@@ -55,7 +55,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
     def quotedType(t: Type) =
       if StagingContext.level == 0 then
         ctx.compilationUnit.needsStaging = true // We will need to run ReifyQuotes
-      val qctx = ctx.typer.inferImplicitArg(defn.QuoteContextClass.typeRef, span)
+      val qctx = ctx.typer.inferImplicitArg(defn.QuoteScopeClass.typeRef, span)
       qctx.tpe match
         case tpe: Implicits.SearchFailureType => ctx.error(tpe.msg, ctx.source.atSpan(span))
         case _ =>

library/src-bootstrapped/scala/internal/quoted/CompileTime.scala

@@ -8,21 +8,21 @@ object CompileTime {
 
   /** A term quote is desugared by the compiler into a call to this method */
   @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.exprQuote`")
-  def exprQuote[T](x: T): QuoteContext ?=> Expr[T] = ???
+  def exprQuote[T](x: T): (s: QuoteScope) ?=> s.Expr[T] = ???
 
   /** A term splice is desugared by the compiler into a call to this method */
   @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.exprSplice`")
-  def exprSplice[T](x: QuoteContext ?=> Expr[T]): T = ???
+  def exprSplice[T](x: (s: QuoteScope) ?=> s.Expr[T]): T = ???
 
   /** A term splice nested within a quote is desugared by the compiler into a call to this method.
-   *  `ctx` is the `QuoteContext` that the quote of this splice uses.
+   *  `ctx` is the `QuoteScope` that the quote of this splice uses.
    */
   @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.exprNestedSplice`")
-  def exprNestedSplice[T](ctx: QuoteContext)(x: ctx.Nested ?=> Expr[T]): T = ???
+  def exprNestedSplice[T](s0: QuoteScope)(x: (s: s0.Nested) ?=> s.Expr[T]): T = ???
 
   /** A type quote is desugared by the compiler into a call to this method */
   @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.typeQuote`")
-  def typeQuote[T <: AnyKind]: QuoteContext ?=> Type[T] = ???
+  def typeQuote[T <: AnyKind]: (s: QuoteScope) ?=> s.Type[T] = ???
 
   /** Artifact of pickled type splices
    *

library/src-bootstrapped/scala/internal/quoted/Unpickler.scala

@@ -0,0 +1,25 @@
+package scala.internal.quoted
+
+import scala.quoted.{Expr, QuoteScope, Type}
+
+/** Provides methods to unpickle `Expr` and `Type` trees. */
+object Unpickler {
+
+  type PickledQuote = List[String]
+  type PickledArgs = Seq[Seq[Any] => Any/*(([QCtx <: QuoteContext] =>> QCtx ?=> Expr[Any]) | Type[_])*/]
+
+  /** Unpickle `repr` which represents a pickled `Expr` tree,
+   *  replacing splice nodes with `args`
+   */
+  def unpickleExpr[T](repr: PickledQuote, args: PickledArgs): (s: QuoteScope) ?=> s.Expr[T] = (using s) =>
+    val tree = s.tasty.internal.unpickleExpr(repr, args)
+    new scala.internal.quoted.Expr(tree, s.tasty.internal.compilerId).asInstanceOf[s.Expr[T]]
+
+  /** Unpickle `repr` which represents a pickled `Type` tree,
+   *  replacing splice nodes with `args`
+   */
+  def unpickleType[T](repr: PickledQuote, args: PickledArgs): (s: QuoteScope) ?=> s.Type[T] = (using s) =>
+    val tree = s.tasty.internal.unpickleType(repr, args)
+    new scala.internal.quoted.Type(tree, s.tasty.internal.compilerId).asInstanceOf[s.Type[T]]
+
+}

library/src-bootstrapped/scala/quoted/Const.scala

@@ -14,7 +14,7 @@ object Const {
    *  }
    *  ```
    */
-  def unapply[T](expr: Expr[T])(using qctx: QuoteContext): Option[T] = {
+  def unapply[T](using s: QuoteScope)(expr: s.Expr[T]): Option[T] = {
     import qctx.tasty._
     def rec(tree: Term): Option[T] = tree match {
       case Literal(c) => Some(c.value.asInstanceOf[T])

library/src-bootstrapped/scala/quoted/Consts.scala

@@ -15,7 +15,7 @@ object Consts {
    *  }
    *  ```
    */
-  def unapply[T](exprs: Seq[Expr[T]])(using qctx: QuoteContext): Option[Seq[T]] =
+  def unapply[T](using s: QuoteScope)(exprs: Seq[s.Expr[T]]): Option[Seq[T]] =
     exprs.foldRight(Option(List.empty[T])) { (elem, acc) =>
       (elem, acc) match {
         case (Const(value), Some(lst)) => Some(value :: lst)

library/src-bootstrapped/scala/quoted/Expr.scala

@@ -45,13 +45,16 @@ class Expr[+T] private[scala] {
     qctx.tasty.internal.QuotedExpr_cast[U](this)(using tp, qctx.tasty.rootContext)
 
   /** View this expression `quoted.Expr[T]` as a `Term` */
-  def unseal(using qctx: QuoteContext): qctx.tasty.Term =
+  def unseal(using qctx: QuoteScope): qctx.tasty.Term =
     qctx.tasty.internal.QuotedExpr_unseal(this)(using qctx.tasty.rootContext)
 
 }
 
 object Expr {
 
+  given unsafeExpr[T](using s: QuoteScope) as Conversion[scala.quoted.Expr[T], s.Expr[T]] = _.asInstanceOf
+
+
   /** Converts a tuple `(T1, ..., Tn)` to `(Expr[T1], ..., Expr[Tn])` */
   type TupleOfExpr[Tup <: Tuple] = Tuple.Map[Tup, [X] =>> QuoteContext ?=> Expr[X]]
 
@@ -78,28 +81,28 @@ object Expr {
     tg.untupled(args => qctx.tasty.internal.betaReduce(f.unseal, args.toArray.toList.map(_.asInstanceOf[QuoteContext => Expr[Any]](qctx).unseal)).seal.asInstanceOf[Expr[R]])
 
   /** Returns a null expresssion equivalent to `'{null}` */
-  def nullExpr: QuoteContext ?=> Expr[Null] = qctx ?=> {
+  def nullExpr: (s: QuoteScope) ?=> s.Expr[Null] = {
     import qctx.tasty._
-    Literal(Constant(null)).seal.asInstanceOf[Expr[Null]]
+    Literal(Constant(null)).seal.asInstanceOf[qctx.Expr[Null]]
   }
 
   /** Returns a unit expresssion equivalent to `'{}` or `'{()}` */
-  def unitExpr: QuoteContext ?=> Expr[Unit] = qctx ?=> {
+  def unitExpr: (s: QuoteScope) ?=> s.Expr[Unit] = {
     import qctx.tasty._
-    Literal(Constant(())).seal.asInstanceOf[Expr[Unit]]
+    Literal(Constant(())).seal.asInstanceOf[qctx.Expr[Unit]]
   }
 
   /** Returns an expression containing a block with the given statements and ending with the expresion
    *  Given list of statements `s1 :: s2 :: ... :: Nil` and an expression `e` the resulting expression
    *  will be equivalent to `'{ $s1; $s2; ...; $e }`.
    */
-  def block[T](statements: List[Expr[Any]], expr: Expr[T])(using qctx: QuoteContext): Expr[T] = {
-    import qctx.tasty._
-    Block(statements.map(_.unseal), expr.unseal).seal.asInstanceOf[Expr[T]]
+  def block[T](using s: QuoteScope)(statements: List[s.Expr[Any]], expr: s.Expr[T]): s.Expr[T] = {
+    import s.tasty._
+    Block(statements.map(_.unseal), expr.unseal).seal.asInstanceOf[s.Expr[T]]
   }
 
   /** Lift a value into an expression containing the construction of that value */
-  def apply[T](x: T)(using qctx: QuoteContext, lift: Liftable[T]): Expr[T] = lift.toExpr(x)
+  def apply[T](x: T)(using s: QuoteScope, lift: Liftable[T]): s.Expr[T] = lift.toExpr(x)
 
   /** Lifts this sequence of expressions into an expression of a sequence
    *
@@ -182,9 +185,9 @@ object Expr {
   }
 
   /** Given a tuple of the form `(Expr[A1], ..., Expr[An])`, outputs a tuple `Expr[(A1, ..., An)]`. */
-  def ofTuple[T <: Tuple: Tuple.IsMappedBy[Expr]: Type](tup: T)(using qctx: QuoteContext): Expr[Tuple.InverseMap[T, Expr]] = {
-    val elems: Seq[Expr[Any]] = tup.asInstanceOf[Product].productIterator.toSeq.asInstanceOf[Seq[Expr[Any]]]
-    ofTupleFromSeq(elems).cast[Tuple.InverseMap[T, Expr]]
+  def ofTuple[T <: Tuple](tup: T)(using s: QuoteScope)(using s.Type[T], Tuple.IsMappedBy[s.Expr][T]): s.Expr[Tuple.InverseMap[T, s.Expr]] = {
+    val elems: Seq[s.Expr[Any]] = tup.asInstanceOf[Product].productIterator.toSeq.asInstanceOf[Seq[s.Expr[Any]]]
+    ofTupleFromSeq(elems).asInstanceOf[s.Expr[Tuple.InverseMap[T, s.Expr]]]
   }
 
   /** Find an implicit of type `T` in the current scope given by `qctx`.
@@ -195,10 +198,10 @@ object Expr {
    *  @param tpe quoted type of the implicit parameter
    *  @param qctx current context
    */
-  def summon[T](using tpe: Type[T])(using qctx: QuoteContext): Option[Expr[T]] = {
-    import qctx.tasty._
+  def summon[T](using s: QuoteScope)(using tpe: s.Type[T]): Option[s.Expr[T]] = {
+    import s.tasty._
     searchImplicit(tpe.unseal.tpe) match {
-      case iss: ImplicitSearchSuccess => Some(iss.tree.seal.asInstanceOf[Expr[T]])
+      case iss: ImplicitSearchSuccess => Some(iss.tree.seal.asInstanceOf[s.Expr[T]])
       case isf: ImplicitSearchFailure => None
     }
   }

library/src-bootstrapped/scala/quoted/Lambda.scala

@@ -15,13 +15,13 @@ object Lambda {
    *       body('{3}) // returns '{ println(3) }
    *   ```
    */
-  def unapply[F, Args <: Tuple, Res, G](expr: Expr[F])(using qctx: QuoteContext, tf: TupledFunction[F, Args => Res], tg: TupledFunction[G, Tuple.Map[Args, Expr] => Expr[Res]], functionType: Type[F]): Option[/*QuoteContext ?=>*/ G] = {
+  def unapply[F, Args <: Tuple, Res, G](using s: QuoteScope)(expr: s.Expr[F])(using tf: TupledFunction[F, Args => Res], tg: TupledFunction[G, Tuple.Map[Args, s.Expr] => Expr[Res]], functionType: Type[F]): Option[/*QuoteContext ?=>*/ G] = {
     import qctx.tasty._
     val argTypes = functionType.unseal.tpe match
       case AppliedType(_, functionArguments) => functionArguments.init.asInstanceOf[List[Type]]
     qctx.tasty.internal.lambdaExtractor(expr.unseal, argTypes).map { fn =>
-      def f(args: Tuple.Map[Args, Expr]): Expr[Res] =
-        fn(args.toArray.toList.map(_.asInstanceOf[Expr[Any]].unseal)).seal.asInstanceOf[Expr[Res]]
+      def f(args: Tuple.Map[Args, s.Expr]): s.Expr[Res] =
+        fn(args.toArray.toList.map(_.asInstanceOf[s.Expr[Any]].unseal)).seal.asInstanceOf[s.Expr[Res]]
       tg.untupled(f)
     }