Update QuoteContext to Quotes

Author: nicolasstucki

community-build/community-projects/PPrint

@@ -797,7 +797,7 @@ class Definitions {
   @tu lazy val QuotedExprClass: ClassSymbol = requiredClass("scala.quoted.Expr")
   @tu lazy val QuotedExprModule: Symbol = QuotedExprClass.companionModule
 
-  @tu lazy val QuoteContextClass: ClassSymbol = requiredClass("scala.quoted.Quotes")
+  @tu lazy val QuotesClass: ClassSymbol = requiredClass("scala.quoted.Quotes")
 
   @tu lazy val QuoteUnpicklerClass: ClassSymbol = requiredClass("scala.quoted.runtime.QuoteUnpickler")
     @tu lazy val QuoteUnpickler_unpickleExpr: Symbol = QuoteUnpicklerClass.requiredMethod("unpickleExpr")

community-build/community-projects/dotty-cps-async

@@ -17,9 +17,9 @@ object StagingContext {
   private val QuotationLevel = new Property.Key[Int]
 
   /** A key to be used in a context property that tracks the quoteation stack.
-   *  Stack containing the QuoteContext references recieved by the surrounding quotes.
+   *  Stack containing the Quotes references recieved by the surrounding quotes.
    */
-  private val QuoteContextStack = new Property.Key[List[tpd.Tree]]
+  private val QuotesStack = new Property.Key[List[tpd.Tree]]
 
   private val TaggedTypes = new Property.Key[PCPCheckAndHeal.QuoteTypeTags]
 
@@ -31,11 +31,11 @@ object StagingContext {
   def quoteContext(using Context): Context =
     ctx.fresh.setProperty(QuotationLevel, level + 1)
 
-  /** Context with an incremented quotation level and pushes a refecence to a QuoteContext on the quote context stack */
-  def pushQuoteContext(qctxRef: tpd.Tree)(using Context): Context =
-    val old = ctx.property(QuoteContextStack).getOrElse(List.empty)
+  /** Context with an incremented quotation level and pushes a refecence to a Quotes on the quote context stack */
+  def pushQuotes(qctxRef: tpd.Tree)(using Context): Context =
+    val old = ctx.property(QuotesStack).getOrElse(List.empty)
     ctx.fresh.setProperty(QuotationLevel, level + 1)
-             .setProperty(QuoteContextStack, qctxRef :: old)
+             .setProperty(QuotesStack, qctxRef :: old)
 
   /** Context with a decremented quotation level. */
   def spliceContext(using Context): Context =
@@ -50,12 +50,12 @@ object StagingContext {
   /** Context with a decremented quotation level and pops the Some of top of the quote context stack or None if the stack is empty.
    *  The quotation stack could be empty if we are in a top level splice or an eroneous splice directly witin a top level splice.
    */
-  def popQuoteContext()(using Context): (Option[tpd.Tree], Context) =
+  def popQuotes()(using Context): (Option[tpd.Tree], Context) =
     val ctx1 = ctx.fresh.setProperty(QuotationLevel, level - 1)
     val head =
-      ctx.property(QuoteContextStack) match
+      ctx.property(QuotesStack) match
         case Some(x :: xs) =>
-          ctx1.setProperty(QuoteContextStack, xs)
+          ctx1.setProperty(QuotesStack, xs)
           Some(x)
         case _ =>
           None // Splice at level 0 or lower

community-build/community-projects/intent

@@ -19,7 +19,7 @@ import dotty.tools.dotc.report
 
 import scala.reflect.ClassTag
 
-import scala.quoted.QuoteContext
+import scala.quoted.Quotes
 import scala.quoted.runtime.impl._
 
 import scala.collection.mutable
@@ -53,7 +53,7 @@ object PickledQuotes {
   }
 
   /** Unpickle the tree contained in the TastyExpr */
-  def unpickleTerm(pickled: String | List[String], typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Any], scala.quoted.QuoteContext) => scala.quoted.Expr[?])(using Context): Tree = {
+  def unpickleTerm(pickled: String | List[String], typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Any], scala.quoted.Quotes) => scala.quoted.Expr[?])(using Context): Tree = {
     val unpickled = withMode(Mode.ReadPositions)(unpickle(pickled, isType = false))
     val Inlined(call, Nil, expnasion) = unpickled
     val inlineCtx = inlineContext(call)
@@ -63,18 +63,18 @@ object PickledQuotes {
   }
 
   /** Unpickle the tree contained in the TastyType */
-  def unpickleTypeTree(pickled: String | List[String], typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Any], scala.quoted.QuoteContext) => scala.quoted.Expr[?])(using Context): Tree = {
+  def unpickleTypeTree(pickled: String | List[String], typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Any], scala.quoted.Quotes) => scala.quoted.Expr[?])(using Context): Tree = {
     val unpickled = withMode(Mode.ReadPositions)(unpickle(pickled, isType = true))
     spliceTypes(unpickled, typeHole, termHole)
   }
 
   /** Replace all term holes with the spliced terms */
-  private def spliceTerms(tree: Tree, typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Any], scala.quoted.QuoteContext) => scala.quoted.Expr[?])(using Context): Tree = {
+  private def spliceTerms(tree: Tree, typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Any], scala.quoted.Quotes) => scala.quoted.Expr[?])(using Context): Tree = {
     val evaluateHoles = new TreeMap {
       override def transform(tree: tpd.Tree)(using Context): tpd.Tree = tree match {
         case Hole(isTerm, idx, args) =>
           val reifiedArgs = args.map { arg =>
-            if (arg.isTerm) (using qctx: QuoteContext) => new ExprImpl(arg, QuotesImpl.scopeId)
+            if (arg.isTerm) (using qctx: Quotes) => new ExprImpl(arg, QuotesImpl.scopeId)
             else new TypeImpl(arg, QuotesImpl.scopeId)
           }
           if isTerm then
@@ -123,7 +123,7 @@ object PickledQuotes {
   }
 
   /** Replace all type holes generated with the spliced types */
-  private def spliceTypes(tree: Tree, typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Int], scala.quoted.QuoteContext) => Any)(using Context): Tree = {
+  private def spliceTypes(tree: Tree, typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Int], scala.quoted.Quotes) => Any)(using Context): Tree = {
     tree match
       case Block(stat :: rest, expr1) if stat.symbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
         val typeSpliceMap = (stat :: rest).iterator.map {

community-build/community-projects/minitest

@@ -54,7 +54,7 @@ import scala.annotation.constructorOnly
  *       typeHole = (idx: Int, args: List[Any]) => idx match {
  *         case 0 => ...
  *       },
- *       termHole = (idx: Int, args: List[Any], qctx: QuoteContext) => idx match {
+ *       termHole = (idx: Int, args: List[Any], qctx: Quotes) => idx match {
  *         case 0 => ...
  *         ...
  *         case <i> =>
@@ -159,7 +159,7 @@ class PickleQuotes extends MacroTransform {
        */
       def pickleAsLiteral(lit: Literal) = {
         val exprType = defn.QuotedExprClass.typeRef.appliedTo(body.tpe)
-        val lambdaTpe = MethodType(defn.QuoteContextClass.typeRef :: Nil, exprType)
+        val lambdaTpe = MethodType(defn.QuotesClass.typeRef :: Nil, exprType)
         def mkConst(ts: List[Tree]) = {
           val reflect = ts.head.select("reflect".toTermName)
           val typeName = body.tpe.typeSymbol.name
@@ -239,7 +239,7 @@ class PickleQuotes extends MacroTransform {
           else
             Lambda(
               MethodType(
-                List(defn.IntType, defn.SeqType.appliedTo(defn.AnyType), defn.QuoteContextClass.typeRef),
+                List(defn.IntType, defn.SeqType.appliedTo(defn.AnyType), defn.QuotesClass.typeRef),
                 defn.QuotedExprClass.typeRef.appliedTo(defn.AnyType)),
               args => {
                 val cases = termSplices.map { case (splice, idx) =>
@@ -253,7 +253,7 @@ class PickleQuotes extends MacroTransform {
 
         val quoteClass = if isType then defn.QuotedTypeClass else defn.QuotedExprClass
         val quotedType = quoteClass.typeRef.appliedTo(originalTp)
-        val lambdaTpe = MethodType(defn.QuoteContextClass.typeRef :: Nil, quotedType)
+        val lambdaTpe = MethodType(defn.QuotesClass.typeRef :: Nil, quotedType)
         def callUnpickle(ts: List[Tree]) = {
           val qctx = ts.head.asInstance(defn.QuoteUnpicklerClass.typeRef)
           val unpickleMeth = if isType then defn.QuoteUnpickler_unpickleType else defn.QuoteUnpickler_unpickleExpr
@@ -275,7 +275,7 @@ class PickleQuotes extends MacroTransform {
       def taggedType() =
         val typeType = defn.QuotedTypeClass.typeRef.appliedTo(body.tpe)
         val classTree = TypeApply(ref(defn.Predef_classOf.termRef), body :: Nil)
-        val lambdaTpe = MethodType(defn.QuoteContextClass.typeRef :: Nil, typeType)
+        val lambdaTpe = MethodType(defn.QuotesClass.typeRef :: Nil, typeType)
         def callTypeConstructorOf(ts: List[Tree]) = {
           val reflect = ts.head.select("reflect".toTermName)
           val typeRepr = reflect.select("TypeRepr".toTermName).select("typeConstructorOf".toTermName).appliedTo(classTree)
@@ -370,7 +370,7 @@ class PickleQuotes 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.QuotesClass.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

community-build/community-projects/munit

@@ -26,7 +26,7 @@ import scala.reflect.ClassTag
 
 import dotty.tools.dotc.quoted.{PickledQuotes, QuoteUtils}
 
-import scala.quoted.QuoteContext
+import scala.quoted.Quotes
 import scala.quoted.runtime.impl._
 
 /** Utility class to splice quoted expressions */
@@ -51,7 +51,7 @@ object Splicer {
             val interpreter = new Interpreter(pos, classLoader)
 
             // Some parts of the macro are evaluated during the unpickling performed in quotedExprToTree
-            val interpretedExpr = interpreter.interpret[QuoteContext => scala.quoted.Expr[Any]](tree)
+            val interpretedExpr = interpreter.interpret[Quotes => scala.quoted.Expr[Any]](tree)
             val interpretedTree = interpretedExpr.fold(tree)(macroClosure => PickledQuotes.quotedExprToTree(macroClosure(QuotesImpl())))
 
             checkEscapedVariables(interpretedTree, macroOwner)

community-build/community-projects/scalatest

@@ -109,7 +109,7 @@ abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMap
           try dropEmptyBlocks(quotedTree) match {
             case Spliced(t) =>
               // '{ $x } --> x
-              // and adapt the refinment of `QuoteContext { type tasty: ... } ?=> Expr[T]`
+              // and adapt the refinment of `Quotes { type tasty: ... } ?=> Expr[T]`
               transform(t).asInstance(tree.tpe)
             case _ => transformQuotation(quotedTree, tree)
           }

community-build/community-projects/scodec-bits

@@ -49,12 +49,12 @@ trait QuotesAndSplices {
         report.warning("Canceled splice directly inside a quote. '[ ${ XYZ } ] is equivalent to XYZ.", tree.srcPos)
       case _ =>
     }
-    val qctx = inferImplicitArg(defn.QuoteContextClass.typeRef, tree.span)
+    val qctx = inferImplicitArg(defn.QuotesClass.typeRef, tree.span)
 
     if qctx.tpe.isInstanceOf[SearchFailureType] then
-      report.error(missingArgMsg(qctx, defn.QuoteContextClass.typeRef, ""), ctx.source.atSpan(tree.span))
+      report.error(missingArgMsg(qctx, defn.QuotesClass.typeRef, ""), ctx.source.atSpan(tree.span))
     else if !qctx.tpe.isStable then
-      report.error(em"Quotes require stable QuoteContext, but found non stable $qctx", qctx.srcPos)
+      report.error(em"Quotes require stable Quotes, but found non stable $qctx", qctx.srcPos)
 
     val tree1 =
       if ctx.mode.is(Mode.Pattern) then
@@ -65,7 +65,7 @@ trait QuotesAndSplices {
         else report.warning(msg, tree.srcPos)
         typedTypeApply(untpd.TypeApply(untpd.ref(defn.QuotedTypeModule_of.termRef), tree.quoted :: Nil), pt)(using quoteContext).select(nme.apply).appliedTo(qctx)
       else
-        typedApply(untpd.Apply(untpd.ref(defn.QuotedRuntime_exprQuote.termRef), tree.quoted), pt)(using pushQuoteContext(qctx)).select(nme.apply).appliedTo(qctx)
+        typedApply(untpd.Apply(untpd.ref(defn.QuotedRuntime_exprQuote.termRef), tree.quoted), pt)(using pushQuotes(qctx)).select(nme.apply).appliedTo(qctx)
     tree1.withSpan(tree.span)
   }
 
@@ -103,7 +103,7 @@ trait QuotesAndSplices {
         markAsMacro(ctx)
       }
 
-      val (outerQctx, ctx1) = popQuoteContext()
+      val (outerQctx, ctx1) = popQuotes()
 
       val internalSplice =
         outerQctx match

community-build/community-projects/shapeless

@@ -96,7 +96,7 @@ import scala.annotation.{Annotation, compileTimeOnly}
  */
 object Matcher {
 
-  abstract class QuoteMatcher[QCtx <: QuoteContext & Singleton](val qctx: QCtx) {
+  abstract class QuoteMatcher[QCtx <: Quotes & Singleton](val qctx: QCtx) {
 
     // TODO improve performance
 

community-build/community-projects/sourcecode

@@ -25,7 +25,7 @@ object QuotesImpl {
 
   type ScopeId = Int
 
-  def apply()(using Context): QuoteContext =
+  def apply()(using Context): Quotes =
     new QuotesImpl
 
   def showDecompiledTree(tree: tpd.Tree)(using Context): String = {
@@ -43,7 +43,7 @@ object QuotesImpl {
 
 }
 
-class QuotesImpl private (using val ctx: Context) extends QuoteContext, QuoteUnpickler, QuoteMatching:
+class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler, QuoteMatching:
 
   private val yCheck: Boolean =
     ctx.settings.Ycheck.value(using ctx).exists(x => x == "all" || x == "macros")
@@ -2599,11 +2599,11 @@ class QuotesImpl private (using val ctx: Context) extends QuoteContext, QuoteUnp
 
   end reflect
 
-  def unpickleExpr[T](pickled: String | List[String], typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Any], scala.quoted.QuoteContext) => scala.quoted.Expr[?]): scala.quoted.Expr[T] =
+  def unpickleExpr[T](pickled: String | List[String], typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Any], scala.quoted.Quotes) => scala.quoted.Expr[?]): scala.quoted.Expr[T] =
     val tree = PickledQuotes.unpickleTerm(pickled, typeHole, termHole)
     new ExprImpl(tree, hash).asInstanceOf[scala.quoted.Expr[T]]
 
-  def unpickleType[T <: AnyKind](pickled: String | List[String], typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Any], scala.quoted.QuoteContext) => scala.quoted.Expr[?]): scala.quoted.Type[T] =
+  def unpickleType[T <: AnyKind](pickled: String | List[String], typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Any], scala.quoted.Quotes) => scala.quoted.Expr[?]): scala.quoted.Type[T] =
     val tree = PickledQuotes.unpickleTypeTree(pickled, typeHole, termHole)
     new TypeImpl(tree, hash).asInstanceOf[scala.quoted.Type[T]]
 

community-build/community-projects/upickle

@@ -14,7 +14,7 @@ final class TypeImpl(val typeTree: tpd.Tree, val scopeId: Int) extends Type[?] {
   }
 
   /** View this expression `quoted.Type[T]` as a `TypeTree` */
-  def unseal(using qctx: QuoteContext): qctx.reflect.TypeTree =
+  def unseal(using qctx: Quotes): qctx.reflect.TypeTree =
     checkScopeId(qctx.hashCode)
     typeTree.asInstanceOf[qctx.reflect.TypeTree]
 

community-build/community-projects/utest

@@ -5,19 +5,19 @@ import scala.quoted._
 
 object Extractors {
 
-  def showTree(using QuoteContext)(tree: qctx.reflect.Tree): String =
+  def showTree(using Quotes)(tree: qctx.reflect.Tree): String =
     new ExtractorsPrinter[qctx.type]().visitTree(tree).result()
 
-  def showType(using QuoteContext)(tpe: qctx.reflect.TypeRepr): String =
+  def showType(using Quotes)(tpe: qctx.reflect.TypeRepr): String =
     new ExtractorsPrinter[qctx.type]().visitType(tpe).result()
 
-  def showConstant(using QuoteContext)(const: qctx.reflect.Constant): String =
+  def showConstant(using Quotes)(const: qctx.reflect.Constant): String =
     new ExtractorsPrinter[qctx.type]().visitConstant(const).result()
 
-  def showSymbol(using QuoteContext)(symbol: qctx.reflect.Symbol): String =
+  def showSymbol(using Quotes)(symbol: qctx.reflect.Symbol): String =
     new ExtractorsPrinter[qctx.type]().visitSymbol(symbol).result()
 
-  def showFlags(using QuoteContext)(flags: qctx.reflect.Flags): String = {
+  def showFlags(using Quotes)(flags: qctx.reflect.Flags): String = {
     import qctx.reflect._
     val flagList = List.newBuilder[String]
     if (flags.is(Flags.Abstract)) flagList += "Flags.Abstract"
@@ -57,7 +57,7 @@ object Extractors {
     flagList.result().mkString(" | ")
   }
 
-  private class ExtractorsPrinter[QCtx <: QuoteContext & Singleton](using val qctx: QCtx) { self =>
+  private class ExtractorsPrinter[QCtx <: Quotes & Singleton](using val qctx: QCtx) { self =>
     import qctx.reflect._
 
     private val sb: StringBuilder = new StringBuilder

community-build/community-projects/xml-interpolator

@@ -6,19 +6,19 @@ import scala.annotation.switch
 /** Printer for fully elaborated representation of the source code */
 object SourceCode {
 
-  def showTree(using QuoteContext)(tree: qctx.reflect.Tree)(syntaxHighlight: SyntaxHighlight): String =
+  def showTree(using Quotes)(tree: qctx.reflect.Tree)(syntaxHighlight: SyntaxHighlight): String =
     new SourceCodePrinter[qctx.type](syntaxHighlight).printTree(tree).result()
 
-  def showType(using QuoteContext)(tpe: qctx.reflect.TypeRepr)(syntaxHighlight: SyntaxHighlight): String =
+  def showType(using Quotes)(tpe: qctx.reflect.TypeRepr)(syntaxHighlight: SyntaxHighlight): String =
     new SourceCodePrinter[qctx.type](syntaxHighlight).printType(tpe)(using None).result()
 
-  def showConstant(using QuoteContext)(const: qctx.reflect.Constant)(syntaxHighlight: SyntaxHighlight): String =
+  def showConstant(using Quotes)(const: qctx.reflect.Constant)(syntaxHighlight: SyntaxHighlight): String =
     new SourceCodePrinter[qctx.type](syntaxHighlight).printConstant(const).result()
 
-  def showSymbol(using QuoteContext)(symbol: qctx.reflect.Symbol)(syntaxHighlight: SyntaxHighlight): String =
+  def showSymbol(using Quotes)(symbol: qctx.reflect.Symbol)(syntaxHighlight: SyntaxHighlight): String =
     symbol.fullName
 
-  def showFlags(using QuoteContext)(flags: qctx.reflect.Flags)(syntaxHighlight: SyntaxHighlight): String = {
+  def showFlags(using Quotes)(flags: qctx.reflect.Flags)(syntaxHighlight: SyntaxHighlight): String = {
     import qctx.reflect._
     val flagList = List.newBuilder[String]
     if (flags.is(Flags.Abstract)) flagList += "abstract"
@@ -58,7 +58,7 @@ object SourceCode {
     flagList.result().mkString("/*", " ", "*/")
   }
 
-  private class SourceCodePrinter[QCtx <: QuoteContext & Singleton](syntaxHighlight: SyntaxHighlight)(using val qctx: QCtx) {
+  private class SourceCodePrinter[QCtx <: Quotes & Singleton](syntaxHighlight: SyntaxHighlight)(using val qctx: QCtx) {
     import syntaxHighlight._
     import qctx.reflect._