Fix #5161: Add QuoteContext to handle compiler instance for show

The main idea is to correctly keep track of the current compiler. This is paramount to support correctly `show` and quote patterns. This PR only contains the addition of the `QuoteContext` to the `run` but not the top level `$` (which will come in a second step).

* Add `QuoteContext`
* Define a single `Expr.show` entry point in `QuoteContext`(for `expr.show`)
* Define `show(expr)` which is an alias of `run(expr.show.toExpr)` that provides a `QuoteContext`
* Remove coloring options from the `Reflection.Context` and `Toolbox` settings (`show` never has colors unless a coloring format is given)
* Replace `TreeCleaner` with `@quoteTypeTag` and logic in the printers
* Fix #5161
* Regression local definitions are not renamed in quotes (postponed for future PR). See tests/run-with-compiler/quote-run-2.check.

Author: nicolasstucki

community-build/community-projects/scalatest

@@ -773,6 +773,7 @@ class Definitions {
     @threadUnsafe lazy val InternalQuoted_patternHoleR: TermRef = InternalQuotedModule.requiredMethodRef("patternHole")
     def InternalQuoted_patternHole(implicit ctx: Context): Symbol = InternalQuoted_patternHoleR.symbol
     @threadUnsafe lazy val InternalQuoted_patternBindHoleAnnot: ClassSymbol = InternalQuotedModule.requiredClass("patternBindHole")
+    @threadUnsafe lazy val InternalQuoted_QuoteTypeTagAnnot: ClassSymbol = InternalQuotedModule.requiredClass("quoteTypeTag")
 
   @threadUnsafe lazy val InternalQuotedMatcherModuleRef: TermRef = ctx.requiredModuleRef("scala.internal.quoted.Matcher")
     def InternalQuotedMatcherModule(implicit ctx: Context): Symbol = InternalQuotedMatcherModuleRef.symbol

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

@@ -6,6 +6,4 @@ import dotty.tools.dotc.util.NoSource
 import scala.quoted.Expr
 
 /* Compilation unit containing the contents of a quoted expression */
-class ExprCompilationUnit(val expr: Expr[_]) extends CompilationUnit(NoSource) {
-  override def toString: String = s"Expr($expr)"
-}
+class ExprCompilationUnit(val expr: scala.quoted.QuoteContext => Expr[_]) extends CompilationUnit(NoSource)

compiler/src/dotty/tools/dotc/quoted/ExprCompilationUnit.scala

@@ -14,12 +14,13 @@ import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.core.Symbols.defn
 import dotty.tools.dotc.core.Types.ExprType
 import dotty.tools.dotc.core.quoted.PickledQuotes
+import dotty.tools.dotc.tastyreflect.ReflectionImpl
 import dotty.tools.dotc.transform.Staging
 import dotty.tools.dotc.util.Spans.Span
 import dotty.tools.dotc.util.SourceFile
 import dotty.tools.io.{Path, VirtualFile}
 
-import scala.quoted.{Expr, Type}
+import scala.quoted.{Expr, Type, QuoteContext}
 
 /** Compiler that takes the contents of a quoted expression `expr` and produces
  *  a class file with `class ' { def apply: Object = expr }`.
@@ -50,7 +51,7 @@ class QuoteCompiler extends Compiler {
         case exprUnit: ExprCompilationUnit =>
           val tree =
             if (putInClass) inClass(exprUnit.expr)
-            else PickledQuotes.quotedExprToTree(exprUnit.expr)
+            else PickledQuotes.quotedExprToTree(checkValidRunExpr(exprUnit.expr.apply(new QuoteContext(ReflectionImpl(ctx)))))
           val source = SourceFile.virtual("<quoted.Expr>", "")
           CompilationUnit(source, tree, forceTrees = true)
         case typeUnit: TypeCompilationUnit =>
@@ -61,11 +62,17 @@ class QuoteCompiler extends Compiler {
       }
     }
 
+    private def checkValidRunExpr(expr: Expr[_]): Expr[_] = expr match {
+      case expr: scala.internal.quoted.TastyTreeExpr[Tree] @unchecked =>
+        throw new Exception("Cannot call `Expr.run` on an `Expr` that comes from a macro argument.")
+      case _ => expr
+    }
+
     /** Places the contents of expr in a compilable tree for a class
       *  with the following format.
       *  `package __root__ { class ' { def apply: Any = <expr> } }`
       */
-    private def inClass(expr: Expr[_])(implicit ctx: Context): Tree = {
+    private def inClass(expr: scala.quoted.QuoteContext => Expr[_])(implicit ctx: Context): Tree = {
       val pos = Span(0)
       val assocFile = new VirtualFile("<quote>")
 
@@ -74,7 +81,7 @@ class QuoteCompiler extends Compiler {
       cls.enter(ctx.newDefaultConstructor(cls), EmptyScope)
       val meth = ctx.newSymbol(cls, nme.apply, Method, ExprType(defn.AnyType), coord = pos).entered
 
-      val quoted = PickledQuotes.quotedExprToTree(expr)(ctx.withOwner(meth))
+      val quoted = PickledQuotes.quotedExprToTree(checkValidRunExpr(expr.apply(new QuoteContext(ReflectionImpl(ctx)))))(ctx.withOwner(meth))
 
       val run = DefDef(meth, quoted)
       val classTree = ClassDef(cls, DefDef(cls.primaryConstructor.asTerm), run :: Nil)
@@ -85,7 +92,7 @@ class QuoteCompiler extends Compiler {
   }
 
   class ExprRun(comp: Compiler, ictx: Context) extends Run(comp, ictx) {
-    def compileExpr(expr: Expr[_]): Unit = {
+    def compileExpr(expr:  scala.quoted.QuoteContext => Expr[_]): Unit = {
       val units = new ExprCompilationUnit(expr) :: Nil
       compileUnits(units)
     }

compiler/src/dotty/tools/dotc/quoted/QuoteCompiler.scala

@@ -20,7 +20,7 @@ class QuoteDriver(appClassloader: ClassLoader) extends Driver {
 
   private[this] val contextBase: ContextBase = new ContextBase
 
-  def run[T](expr: Expr[T], settings: Toolbox.Settings): T = {
+  def run[T](expr: scala.quoted.QuoteContext => Expr[T], settings: Toolbox.Settings): T = {
     val outDir: AbstractFile = settings.outDir match {
       case Some(out) =>
         val dir = Directory(out)
@@ -47,52 +47,13 @@ class QuoteDriver(appClassloader: ClassLoader) extends Driver {
     method.invoke(inst).asInstanceOf[T]
   }
 
-  private def doShow(tree: Tree, ctx: Context): String = {
-    implicit val c: Context = ctx
-    val tree1 =
-      if (ctx.settings.YshowRawQuoteTrees.value) tree
-      else (new TreeCleaner).transform(tree)
-    ReflectionImpl.showTree(tree1)
-  }
-
-  def show(expr: Expr[_], settings: Toolbox.Settings): String =
-    withTree(expr, doShow, settings)
-
-  def show(tpe: Type[_], settings: Toolbox.Settings): String =
-    withTypeTree(tpe, doShow, settings)
-
-  def withTree[T](expr: Expr[_], f: (Tree, Context) => T, settings: Toolbox.Settings): T = {
-    val ctx = setToolboxSettings(setup(settings.compilerArgs.toArray :+ "dummy.scala", initCtx.fresh)._2.fresh, settings)
-
-    var output: Option[T] = None
-    def registerTree(tree: tpd.Tree)(ctx: Context): Unit = {
-      assert(output.isEmpty)
-      output = Some(f(tree, ctx))
-    }
-    new QuoteDecompiler(registerTree).newRun(ctx).compileExpr(expr)
-    output.getOrElse(throw new Exception("Could not extract " + expr))
-  }
-
-  def withTypeTree[T](tpe: Type[_], f: (TypTree, Context) => T, settings: Toolbox.Settings): T = {
-    val ctx = setToolboxSettings(setup(settings.compilerArgs.toArray :+ "dummy.scala", initCtx.fresh)._2.fresh, settings)
-
-    var output: Option[T] = None
-    def registerTree(tree: tpd.Tree)(ctx: Context): Unit = {
-      assert(output.isEmpty)
-      output = Some(f(tree.asInstanceOf[TypTree], ctx))
-    }
-    new QuoteDecompiler(registerTree).newRun(ctx).compileType(tpe)
-    output.getOrElse(throw new Exception("Could not extract " + tpe))
-  }
-
   override def initCtx: Context = {
     val ictx = contextBase.initialCtx
     ictx.settings.classpath.update(QuoteDriver.currentClasspath(appClassloader))(ictx)
     ictx
   }
 
   private def setToolboxSettings(ctx: FreshContext, settings: Toolbox.Settings): ctx.type = {
-    ctx.setSetting(ctx.settings.color, if (settings.color) "always" else "never")
     ctx.setSetting(ctx.settings.YshowRawQuoteTrees, settings.showRawTree)
     // An error in the generated code is a bug in the compiler
     // Setting the throwing reporter however will report any exception

compiler/src/dotty/tools/dotc/quoted/QuoteDriver.scala

@@ -19,18 +19,10 @@ object ToolboxImpl {
 
     private[this] val driver: QuoteDriver = new QuoteDriver(appClassloader)
 
-    def run[T](expr: Expr[T]): T = expr match {
-      case expr: LiftedExpr[T] =>
-        expr.value
-      case expr: TastyTreeExpr[Tree] @unchecked =>
-        throw new Exception("Cannot call `Expr.run` on an `Expr` that comes from a macro argument.")
-      case _ =>
-        synchronized(driver.run(expr, settings))
+    def run[T](expr: scala.quoted.QuoteContext => Expr[T]): T = synchronized {
+      driver.run(expr, settings)
     }
 
-    def show[T](expr: Expr[T]): String = synchronized(driver.show(expr, settings))
-
-    def show[T](tpe: Type[T]): String = synchronized(driver.show(tpe, settings))
   }
 
 }

compiler/src/dotty/tools/dotc/quoted/ToolboxImpl.scala

@@ -33,12 +33,6 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
 
   def Context_source(self: Context): java.nio.file.Path = self.compilationUnit.source.file.jpath
 
-  def Context_printColors(self: Context): Boolean = self.settings.color.value(self) == "always"
-
-  def Context_withColors(self: Context): Context = ctx.fresh.setSetting(ctx.settings.color, "always")
-
-  def Context_withoutColors(self: Context): Context = ctx.fresh.setSetting(ctx.settings.color, "never")
-
   //
   // REPORTING
   //

compiler/src/dotty/tools/dotc/quoted/TreeCleaner.scala

@@ -16,7 +16,7 @@ object ReflectionImpl {
     val refl = new scala.tasty.Reflection(new KernelImpl(ctx, tree.sourcePos))
     val reflCtx = ctx.asInstanceOf[refl.Context]
     val reflTree = tree.asInstanceOf[refl.Tree]
-    new refl.SourceCodePrinter().showTree(reflTree)(reflCtx)
+    new refl.SourceCodePrinter(ctx.settings.color.value == "always").showTree(reflTree)(reflCtx)
   }
 
 }

compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala

@@ -19,6 +19,7 @@ import dotty.tools.dotc.ast.tpd
 import typer.Implicits.SearchFailureType
 
 import scala.collection.mutable
+import dotty.tools.dotc.core.Annotations.Annotation
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.quoted._
 import dotty.tools.dotc.transform.TreeMapWithStages._
@@ -115,9 +116,9 @@ class ReifyQuotes extends MacroTransform {
 
     /** Assuming <expr> contains types `${<tag1>}, ..., ${<tagN>}`, the expression
      *
-     *      { type <Type1> = ${<tag1>}
+     *      { @quoteTypeTag type <Type1> = ${<tag1>}
      *        ...
-     *        type <TypeN> = ${<tagN>}
+     *        @quoteTypeTag type <TypeN> = ${<tagN>}
      *        <expr>
      *      }
      *
@@ -137,7 +138,7 @@ class ReifyQuotes extends MacroTransform {
           flags = Synthetic,
           info = TypeAlias(splicedTree.tpe.select(tpnme.splice)),
           coord = spliced.termSymbol.coord).asType
-
+        local.addAnnotation(Annotation(defn.InternalQuoted_QuoteTypeTagAnnot))
         ctx.typeAssigner.assignType(untpd.TypeDef(local.name, alias), local)
       }
 

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionImpl.scala

@@ -2,7 +2,7 @@ scala> implicit def toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(ge
 def toolbox: quoted.Toolbox
 scala> val v = '{ (if true then Some(1) else None).map(v => v+1) }
 val v: quoted.Expr[Option[Int]] = Expr(<pickled tasty>)
-scala> v.show
+scala> scala.quoted.show(v)
 val res0: String = (if (true) scala.Some.apply[scala.Int](1) else scala.None).map[scala.Int](((v: scala.Int) => v.+(1)))
 scala> scala.quoted.run(v)
 val res1: Option[Int] = Some(2)

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

@@ -25,4 +25,6 @@ object Quoted {
   @compileTimeOnly("Illegal reference to `scala.internal.Quoted.patternBindHole`")
   class patternBindHole extends Annotation
 
+  /** Artifact of type splicing */
+  class quoteTypeTag extends Annotation
 }

compiler/test-resources/repl-macros/i6007

@@ -9,7 +9,7 @@ package quoted {
      *  May throw a FreeVariableError on expressions that came from a macro.
      */
     @deprecated("Use scala.quoted.run", "")
-    final def run(implicit toolbox: Toolbox): T = toolbox.run(this)
+    final def run(implicit toolbox: Toolbox): T = toolbox.run(_ => this)
 
   }
 
@@ -19,7 +19,8 @@ package quoted {
 
     implicit class ExprOps[T](expr: Expr[T]) {
       /** Show a source code like representation of this expression */
-      def show(implicit toolbox: Toolbox): String = toolbox.show(expr)
+      def show(implicit qctx: QuoteContext): String = qctx.show(expr, false)
+      def showFormatted(implicit qctx: QuoteContext): String = qctx.show(expr, true)
     }
 
     /** Converts a tuple `(T1, ..., Tn)` to `(Expr[T1], ..., Expr[Tn])` */

library/src-3.x/scala/internal/Quoted.scala

@@ -10,9 +10,10 @@ package quoted {
   /** Some basic type tags, currently incomplete */
   object Type {
 
-    implicit object TypeOps {
-      /** Show a source code like representation of this type */
-      def (tpe: Type[T]) show[T] given Toolbox: String = the[Toolbox].show(tpe.asInstanceOf[Type[Any]])
+    implicit class TypeOps[T](tpe: Type[T]) {
+      /** Show a source code like representation of this expression */
+      def show(implicit qctx: QuoteContext): String = qctx.show(tpe, false)
+      def showFormatted(implicit qctx: QuoteContext): String = qctx.show(tpe, true)
     }
 
     implicit val UnitTag: Type[Unit] = new TaggedType[Unit]

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

@@ -14,7 +14,9 @@ package object quoted {
     *
    *  May throw a FreeVariableError on expressions that came from a macro.
    */
-  def run[T](expr: Expr[T]) given (toolbox: Toolbox): T = toolbox.run(expr)
+  def run[T](expr: given QuoteContext => Expr[T]) given (toolbox: Toolbox): T = toolbox.run(expr given _)
+
+  def show[T](expr: given QuoteContext => Expr[T]) given (toolbox: Toolbox): String = run(expr.show.toExpr)
 
   object autolift {
     implicit def autoToExpr[T: Liftable](x: T): Expr[T] = x.toExpr

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

@@ -11,20 +11,12 @@ trait QuotedOps extends Core { self: Printers =>
     /** Checked cast to a `quoted.Expr[U]` */
     def cast[U: scala.quoted.Type](implicit ctx: Context): scala.quoted.Expr[U] =
       kernel.QuotedExpr_cast[U](expr)
-
-    /** Show a source code like representation of this expression */
-    def show(implicit ctx: Context): String =
-      unseal.show
   }
 
   implicit class QuotedTypeAPI[T <: AnyKind](tpe: scala.quoted.Type[T]) {
     /** View this expression `quoted.Type[T]` as a `TypeTree` */
     def unseal(implicit ctx: Context): TypeTree =
       kernel.QuotedType_unseal(tpe)
-
-    /** Show a source code like representation of this type */
-    def show(implicit ctx: Context): String =
-      unseal.show
   }
 
   implicit class TermToQuotedAPI(term: Term) {

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

@@ -0,0 +1,17 @@
+package scala.quoted
+
+class QuoteContext(reflection: tasty.Reflection) {
+
+  def show[T](expr: Expr[T], formatted: Boolean): String = {
+    import reflection._
+    if (formatted) expr.unseal.showFormatted
+    else expr.unseal.show
+  }
+
+  def show[T](tpe: Type[T], formatted: Boolean): String = {
+    import reflection._
+    if (formatted) tpe.unseal.showFormatted
+    else tpe.unseal.show
+  }
+
+}