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

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)
       }