Merge pull request #6723 from dotty-staging/move-reflection-inside-quote-context

Move reflection inside QuoteContext

Author: nicolasstucki

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

@@ -759,6 +759,12 @@ class Definitions {
   @threadUnsafe lazy val QuotedExprType: TypeRef = ctx.requiredClassRef("scala.quoted.Expr")
   def QuotedExprClass(implicit ctx: Context): ClassSymbol = QuotedExprType.symbol.asClass
 
+  @threadUnsafe lazy val QuoteContextType: TypeRef = ctx.requiredClassRef("scala.quoted.QuoteContext")
+  def QuoteContextClass(implicit ctx: Context): ClassSymbol = QuoteContextType.symbol.asClass
+
+  @threadUnsafe lazy val QuoteContextModule: TermSymbol = ctx.requiredModule("scala.quoted.QuoteContext")
+    @threadUnsafe lazy val QuoteContext_macroContext: TermSymbol = QuoteContextModule.requiredMethod("macroContext")
+
   @threadUnsafe lazy val InternalQuotedModuleRef: TermRef = ctx.requiredModuleRef("scala.internal.Quoted")
   def InternalQuotedModule: Symbol = InternalQuotedModuleRef.symbol
     @threadUnsafe lazy val InternalQuoted_exprQuoteR: TermRef = InternalQuotedModule.requiredMethodRef("exprQuote")

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

@@ -166,6 +166,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
       l == level ||
         level == -1 && (
           sym == defn.TastyReflection_macroContext ||
+          sym == defn.QuoteContext_macroContext ||
             // here we assume that Splicer.canBeSpliced was true before going to level -1,
             // this implies that all non-inline arguments are quoted and that the following two cases are checked
             // on inline parameters or type parameters.

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

@@ -114,6 +114,8 @@ object Splicer {
       args.toSeq
 
     protected def interpretTastyContext()(implicit env: Env): Object = ReflectionImpl(ctx, pos)
+    protected def interpretQuoteContext()(implicit env: Env): Object =
+      new scala.quoted.QuoteContext(ReflectionImpl(ctx, pos))
 
     protected def interpretStaticMethodCall(moduleClass: Symbol, fn: Symbol, args: => List[Object])(implicit env: Env): Object = {
       val (inst, clazz) =
@@ -308,6 +310,7 @@ object Splicer {
     protected def interpretLiteral(value: Any)(implicit env: Env): Result
     protected def interpretVarargs(args: List[Result])(implicit env: Env): Result
     protected def interpretTastyContext()(implicit env: Env): Result
+    protected def interpretQuoteContext()(implicit env: Env): Result
     protected def interpretStaticMethodCall(module: Symbol, fn: Symbol, args: => List[Result])(implicit env: Env): Result
     protected def interpretModuleAccess(fn: Symbol)(implicit env: Env): Result
     protected def interpretNew(fn: Symbol, args: => List[Result])(implicit env: Env): Result
@@ -333,6 +336,9 @@ object Splicer {
       case _ if tree.symbol == defn.TastyReflection_macroContext =>
         interpretTastyContext()
 
+      case _ if tree.symbol == defn.QuoteContext_macroContext =>
+        interpretQuoteContext()
+
       case Call(fn, args) =>
         if (fn.symbol.isConstructor && fn.symbol.owner.owner.is(Package)) {
           interpretNew(fn.symbol, args.map(interpretTree))

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

@@ -707,6 +707,11 @@ trait Implicits { self: Typer =>
       if (ctx.inInlineMethod || enclosingInlineds.nonEmpty) ref(defn.TastyReflection_macroContext)
       else EmptyTree
 
+  lazy val synthesizedQuoteContext: SpecialHandler =
+    (formal, span) => implicit ctx =>
+      if (ctx.inInlineMethod || enclosingInlineds.nonEmpty) ref(defn.QuoteContext_macroContext)
+      else EmptyTree
+
   lazy val synthesizedTupleFunction: SpecialHandler =
     (formal, span) => implicit ctx => formal match {
       case AppliedType(_, funArgs @ fun :: tupled :: Nil) =>
@@ -1033,9 +1038,10 @@ trait Implicits { self: Typer =>
       mySpecialHandlers = List(
         defn.ClassTagClass        -> synthesizedClassTag,
         defn.QuotedTypeClass      -> synthesizedTypeTag,
+        defn.QuoteContextClass    -> synthesizedQuoteContext,
         defn.TastyReflectionClass -> synthesizedTastyContext,
         defn.EqlClass             -> synthesizedEq,
-        defn.TupledFunctionClass -> synthesizedTupleFunction,
+        defn.TupledFunctionClass  -> synthesizedTupleFunction,
         defn.ValueOfClass         -> synthesizedValueOf,
         defn.Mirror_ProductClass  -> synthesizedProductMirror,
         defn.Mirror_SumClass      -> synthesizedSumMirror,

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

@@ -1978,7 +1978,7 @@ class Typer extends Namer
             fun = ref(defn.InternalQuotedMatcher_unapplyR).appliedToType(patType),
             implicits =
               ref(defn.InternalQuoted_exprQuoteR).appliedToType(shape.tpe).appliedTo(shape) ::
-              implicitArgTree(defn.TastyReflectionType, tree.span) :: Nil,
+              implicitArgTree(defn.QuoteContextType, tree.span) :: Nil,
             patterns = splicePat :: Nil,
             proto = pt)
         }

docs/docs/reference/metaprogramming/tasty-reflect.md

@@ -20,7 +20,7 @@ guarantees and may fail at macro expansion time, hence additional explicit
 checks must be done.
 
 To provide reflection capabilities in macros we need to add an implicit
-parameter of type `scala.tasty.Reflection` and import it in the scope where it
+parameter of type `scala.quoted.QuoteContext` and import `tasty._` from it in the scope where it
 is used.
 
 ```scala
@@ -29,23 +29,23 @@ import scala.tasty._
 
 inline def natConst(x: => Int): Int = ${natConstImpl('{x})}
 
-def natConstImpl(x: Expr[Int])(implicit reflection: Reflection): Expr[Int] = {
-  import reflection._
+def natConstImpl(x: Expr[Int]) given (qctx: QuoteContext): Expr[Int] = {
+  import qctx.tasty._
   ...
 }
 ```
 
 ### Sealing and Unsealing
 
-`import reflection._` will provide an `unseal` extension method on `quoted.Expr`
-and `quoted.Type` which returns a `reflection.Term` that represents the tree of
-the expression and `reflection.TypeTree` that represents the tree of the type
+`import qctx.tasty._` will provide an `unseal` extension method on `quoted.Expr`
+and `quoted.Type` which returns a `qctx.tasty.Term` that represents the tree of
+the expression and `qctx.tasty.TypeTree` that represents the tree of the type
 respectively. It will also import all extractors and methods on TASTy Reflect
 trees. For example the `Literal(_)` extractor used below.
 
 ```scala
-def natConstImpl(x: Expr[Int])(implicit reflection: Reflection): Expr[Int] = {
-  import reflection._
+def natConstImpl(x: Expr[Int]) given (qctx: QuoteContext): Expr[Int] = {
+  import qctx.tasty._
   val xTree: Term = x.unseal
   xTree match {
     case Term.Literal(Constant.Int(n)) =>
@@ -58,10 +58,10 @@ def natConstImpl(x: Expr[Int])(implicit reflection: Reflection): Expr[Int] = {
 }
 ```
 
-To easily know which extractors are needed, the `reflection.Term.show` method
+To easily know which extractors are needed, the `qctx.tasty.Term.show` method
 returns the string representation of the extractors.
 
-The method `reflection.Term.seal[T]` provides a way to go back to a
+The method `qctx.tasty.Term.seal[T]` provides a way to go back to a
 `quoted.Expr[Any]`. Note that the type is `Expr[Any]`. Consequently, the type
 must be set explicitly with a checked `cast` call. If the type does not conform
 to it an exception will be thrown. In the code above, we could have replaced
@@ -77,8 +77,8 @@ operation expression passed while calling the `macro` below.
 ```scala
 inline def macro(param: => Boolean): Unit = ${ macroImpl('param) }
 
-def macroImpl(param: Expr[Boolean])(implicit refl: Reflection): Expr[Unit] = {
-  import refl._
+def macroImpl(param: Expr[Boolean]) given (qctx: QuoteContext): Expr[Unit] = {
+  import qctx.tasty._
   import util._
 
   param.unseal.underlyingArgument match {
@@ -99,8 +99,8 @@ such as the start line, the end line or even the source code at the expansion
 point.
 
 ```scala
-def macroImpl()(reflect: Reflection): Expr[Unit] = {
-  import reflect.{Position => _, _}
+def macroImpl()(qctx: QuoteContext): Expr[Unit] = {
+  import qctx.tasty._
   val pos = rootPosition
 
   val path = pos.sourceFile.jpath.toString

library/src-3.x/scala/internal/quoted/Matcher.scala

@@ -4,7 +4,6 @@ import scala.annotation.internal.sharable
 
 import scala.quoted._
 import scala.quoted.matching.Bind
-import scala.tasty._
 
 object Matcher {
 
@@ -27,12 +26,11 @@ object Matcher {
    *
    *  @param scrutineeExpr `Expr[_]` on which we are pattern matching
    *  @param patternExpr `Expr[_]` containing the pattern tree
-   *  @param reflection instance of the reflection API (implicitly provided by the macro)
+   *  @param qctx the current QuoteContext
    *  @return None if it did not match, `Some(tup)` if it matched where `tup` contains `Expr[Ti]``
    */
-  def unapply[Tup <: Tuple](scrutineeExpr: Expr[_])(implicit patternExpr: Expr[_], reflection: Reflection): Option[Tup] = {
-    // TODO improve performance
-    import reflection.{Bind => BindPattern, _}
+  def unapply[Tup <: Tuple](scrutineeExpr: Expr[_])(implicit patternExpr: Expr[_], qctx: QuoteContext): Option[Tup] = {
+    import qctx.tasty.{Bind => BindPattern, _}
     import Matching._
 
     type Env = Set[(Symbol, Symbol)]

library/src-3.x/scala/quoted/Expr.scala

@@ -48,8 +48,8 @@ package quoted {
      *  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[_]], expr: Expr[T])(implicit refl: tasty.Reflection): Expr[T] = {
-      import refl._
+    def block[T](statements: List[Expr[_]], expr: Expr[T])(implicit qctx: QuoteContext): Expr[T] = {
+      import qctx.tasty._
       Block(statements.map(_.unseal), expr.unseal).seal.asInstanceOf[Expr[T]]
     }
 

library/src-3.x/scala/quoted/matching/Bind.scala

@@ -1,8 +1,6 @@
 package scala.quoted
 package matching
 
-import scala.tasty.Reflection // TODO do not depend on reflection directly
-
 /** Bind of an Expr[T] used to know if some Expr[T] is a reference to the binding
  *
  *  @param name string name of this binding
@@ -21,8 +19,8 @@ class Bind[T <: AnyKind] private[scala](val name: String, private[Bind] val id:
 
 object Bind {
 
-  def unapply[T](expr: Expr[T])(implicit reflect: Reflection): Option[Bind[T]] = {
-    import reflect.{Bind => BindPattern, _}
+  def unapply[T](expr: Expr[T]) given (qctx: QuoteContext): Option[Bind[T]] = {
+    import qctx.tasty.{Bind => BindPattern, _}
     expr.unseal match {
       case IsIdent(ref) =>
         val sym = ref.symbol

library/src-3.x/scala/quoted/matching/Const.scala

@@ -1,8 +1,5 @@
-package scala.quoted.matching
-
-import scala.quoted.Expr
-
-import scala.tasty.Reflection // TODO do not depend on reflection directly
+package scala.quoted
+package matching
 
 /** Matches expressions containing literal constant values and extracts the value.
  *  It may match expressions of type Boolean, Byte, Short, Int, Long,
@@ -17,8 +14,8 @@ import scala.tasty.Reflection // TODO do not depend on reflection directly
  */
 object Const {
 
-  def unapply[T](expr: Expr[T])(implicit reflect: Reflection): Option[T] = {
-    import reflect._
+  def unapply[T](expr: Expr[T]) given (qctx: QuoteContext): Option[T] = {
+    import qctx.tasty._
     def rec(tree: Term): Option[T] = tree match {
       case Literal(c) => Some(c.value.asInstanceOf[T])
       case Block(Nil, e) => rec(e)