Add scala.quoted.withNewQuoteContext

This provides a way to materialize a QuoteContext without calling `run` and hence performing the full compilation.
It is useful if some user only wants to show or inspect an expression without evaluating it.

Added a general optimization where if the expression passed to `run` is a known literal, the literal is returned directly without compiling the code.

Author: nicolasstucki

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

@@ -20,13 +20,18 @@ import dotty.tools.dotc.util.Spans.Span
 import dotty.tools.dotc.util.SourceFile
 import dotty.tools.io.{Path, VirtualFile}
 
-import scala.quoted.{Expr, Type, QuoteContext}
+import scala.annotation.tailrec
+import scala.concurrent.Promise
+import scala.quoted.{Expr, QuoteContext, Type}
 
 /** Compiler that takes the contents of a quoted expression `expr` and produces
  *  a class file with `class ' { def apply: Object = expr }`.
  */
 class QuoteCompiler extends Compiler {
 
+  /** Either `Left` with name of the classfile generated or `Right` with the value contained in the expression */
+  private[this] var result: Either[String, Any] = null
+
   override protected def frontendPhases: List[List[Phase]] =
     List(List(new QuotedFrontend))
 
@@ -44,14 +49,36 @@ class QuoteCompiler extends Compiler {
   class QuotedFrontend extends Phase {
     import tpd._
 
+
     def phaseName: String = "quotedFrontend"
 
     override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] = {
-      units.map {
+      units.flatMap {
         case exprUnit: ExprCompilationUnit =>
-          val tree = inClass(exprUnit.exprBuilder)
-          val source = SourceFile.virtual("<quoted.Expr>", "")
-          CompilationUnit(source, tree, forceTrees = true)
+          val pos = Span(0)
+          val assocFile = new VirtualFile("<quote>")
+
+          // Places the contents of expr in a compilable tree for a class with the following format.
+          // `package __root__ { class ' { def apply: Any = <expr> } }`
+          val cls = ctx.newCompleteClassSymbol(defn.RootClass, outputClassName, EmptyFlags,
+            defn.ObjectType :: Nil, newScope, coord = pos, assocFile = assocFile).entered.asClass
+          cls.enter(ctx.newDefaultConstructor(cls), EmptyScope)
+          val meth = ctx.newSymbol(cls, nme.apply, Method, ExprType(defn.AnyType), coord = pos).entered
+
+          val quoted = PickledQuotes.quotedExprToTree(checkValidRunExpr(exprUnit.exprBuilder.apply(new QuoteContext(ReflectionImpl(ctx)))))(ctx.withOwner(meth))
+
+          getLiteral(quoted) match {
+            case Some(value) =>
+              result = Right(value)
+              None // Stop copilation here we already have the result
+            case None =>
+              val run = DefDef(meth, quoted)
+              val classTree = ClassDef(cls, DefDef(cls.primaryConstructor.asTerm), run :: Nil)
+              val tree = PackageDef(ref(defn.RootPackage).asInstanceOf[Ident], classTree :: Nil).withSpan(pos)
+              val source = SourceFile.virtual("<quoted.Expr>", "")
+              result = Left(outputClassName.toString)
+              Some(CompilationUnit(source, tree, forceTrees = true))
+          }
       }
     }
 
@@ -61,33 +88,25 @@ class QuoteCompiler extends Compiler {
       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(exprBuilder: QuoteContext => Expr[_])(implicit ctx: Context): Tree = {
-      val pos = Span(0)
-      val assocFile = new VirtualFile("<quote>")
-
-      val cls = ctx.newCompleteClassSymbol(defn.RootClass, outputClassName, EmptyFlags,
-        defn.ObjectType :: Nil, newScope, coord = pos, assocFile = assocFile).entered.asClass
-      cls.enter(ctx.newDefaultConstructor(cls), EmptyScope)
-      val meth = ctx.newSymbol(cls, nme.apply, Method, ExprType(defn.AnyType), coord = pos).entered
-
-      val quoted = PickledQuotes.quotedExprToTree(checkValidRunExpr(exprBuilder.apply(new QuoteContext(ReflectionImpl(ctx)))))(ctx.withOwner(meth))
-
-      val run = DefDef(meth, quoted)
-      val classTree = ClassDef(cls, DefDef(cls.primaryConstructor.asTerm), run :: Nil)
-      PackageDef(ref(defn.RootPackage).asInstanceOf[Ident], classTree :: Nil).withSpan(pos)
+    /** Get the literal value if this tree only contains a literal tree */
+    @tailrec private def getLiteral(tree: Tree): Option[Any] = tree match {
+      case Literal(lit) => Some(lit.value)
+      case Block(Nil, expr) => getLiteral(expr)
+      case Inlined(_, Nil, expr) => getLiteral(expr)
+      case _ => None
     }
 
     def run(implicit ctx: Context): Unit = unsupported("run")
   }
 
-  class ExprRun(comp: Compiler, ictx: Context) extends Run(comp, ictx) {
-    def compileExpr(exprBuilder:  QuoteContext => Expr[_]): Unit = {
+  class ExprRun(comp: QuoteCompiler, ictx: Context) extends Run(comp, ictx) {
+    /** Unpickle and optionally compile the expression.
+     *  Returns either `Left` with name of the classfile generated or `Right` with the value contained in the expression.
+     */
+    def compileExpr(exprBuilder:  QuoteContext => Expr[_]): Either[String, Any] = {
       val units = new ExprCompilationUnit(exprBuilder) :: Nil
       compileUnits(units)
+      result
     }
   }
 }

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

@@ -33,18 +33,21 @@ class QuoteDriver(appClassloader: ClassLoader) extends Driver {
     val (_, ctx0: Context) = setup(settings.compilerArgs.toArray :+ "dummy.scala", initCtx.fresh)
     val ctx = setToolboxSettings(ctx0.fresh.setSetting(ctx0.settings.outputDir, outDir), settings)
 
-    val driver = new QuoteCompiler
-    driver.newRun(ctx).compileExpr(exprBuilder)
+    new QuoteCompiler().newRun(ctx).compileExpr(exprBuilder) match {
+      case Right(value) =>
+        value.asInstanceOf[T]
 
-    assert(!ctx.reporter.hasErrors)
+      case Left(classname) =>
+        assert(!ctx.reporter.hasErrors)
 
-    val classLoader = new AbstractFileClassLoader(outDir, appClassloader)
+        val classLoader = new AbstractFileClassLoader(outDir, appClassloader)
 
-    val clazz = classLoader.loadClass(driver.outputClassName.toString)
-    val method = clazz.getMethod("apply")
-    val inst = clazz.getConstructor().newInstance()
+        val clazz = classLoader.loadClass(classname)
+        val method = clazz.getMethod("apply")
+        val inst = clazz.getConstructor().newInstance()
 
-    method.invoke(inst).asInstanceOf[T]
+        method.invoke(inst).asInstanceOf[T]
+    }
   }
 
   override def initCtx: Context = {

compiler/test-resources/repl-macros/i6007

@@ -1,9 +1,8 @@
 scala> implicit def toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
 def toolbox: quoted.Toolbox
-scala> import scala.quoted._
 scala> val v = '{ (if true then Some(1) else None).map(v => v+1) }
 val v: quoted.Expr[Option[Int]] = Expr(<pickled tasty>)
-scala> scala.quoted.run(v.show.toExpr)
+scala> scala.quoted.withNewQuoteContext(v.show)
 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)

docs/docs/reference/metaprogramming/staging.md

@@ -60,11 +60,15 @@ The framework as discussed so far allows code to be staged, i.e. be prepared
 to be executed at a later stage. To run that code, there is another method
 in class `Expr` called `run`. Note that `$` and `run` both map from `Expr[T]`
 to `T` but only `$` is subject to the PCP, whereas `run` is just a normal method.
+Run provides a `QuoteContext` that can be used to show the expression in the scope of `run`.
+On the other hand `withNewQuoteContext` provides a `QuoteContext` without evauating the expression.
 
 ```scala
 package scala.quoted
 
 def run[T](expr: given QuoteContext => Expr[T]) given (toolbox: Toolbox): T = ...
+
+def withNewQuoteContext[T](thunk: given QuoteContext => T) given (toolbox: Toolbox): T = ...
 ```
 
 ## Example
@@ -74,10 +78,7 @@ do not want to pass an array statically but generated code at run-time and pass
 the value, also at run-time. Note, how we make a future-stage function of type
 `Expr[Array[Int] => Int]` in line 4 below. Using `run { ... }` we can evaluate an 
 expression at runtime. Within the scope of `run` we can also invoke `show` on an expression
-to get
-
- Invoking the `.show` or `.run` we can
-either show the code or run it respectivelly.
+to get a source-like representation of the expression.
 
 ```scala
 // make available the necessary toolbox for runtime code generation

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

@@ -3,19 +3,48 @@ package scala
 package object quoted {
 
   /** Evaluate the contents of this expression and return the result.
+   *  It provides a new QuoteContext that is only valid within the scope the argument.
    *
    *  Usage:
    *  ```
-   *  val e: T = run {
-   *   expr
+   *  val e: T = run { // (given qctx: QuoteContext) =>
+   *    expr
    *  }
    *  ```
    *  where `expr: Expr[T]`
-    *
+   *
+   *  This method shoul not be called in a context where there is already has a QuoteContext.
+   *
    *  May throw a FreeVariableError on expressions that came from a macro.
    */
   def run[T](expr: given QuoteContext => Expr[T]) given (toolbox: Toolbox): T = toolbox.run(expr given _)
 
+  /** Provide a new quote context within the scope of the argument that is only valid within the scope the argument.
+   *  Return the result of the argument.
+   *
+   *  Usage:
+   *  ```
+   *  val e: T = withNewQuoteContext { // (given qctx: QuoteContext) =>
+   *    thunk
+   *  }
+   *  ```
+   *  where `thunk: T`
+   *
+   *  This method shoul not be called in a context where there is already has a QuoteContext.
+   */
+  def withNewQuoteContext[T](thunk: given QuoteContext => T) given (toolbox: Toolbox): T = {
+    var result: T = NoResult.asInstanceOf[T]
+    def dummyRun given QuoteContext: Expr[Unit] = {
+      result = thunk
+      '{}
+    }
+    toolbox.run(dummyRun given _)
+    assert(result != NoResult) // toolbox.run should have thrown an exception
+    result
+  }
+
+  private object NoResult
+
   object autolift {
     implicit def autoToExpr[T: Liftable](x: T): Expr[T] = x.toExpr
   }

tests/disabled/reflect/run/position-val-def.scala

@@ -10,7 +10,7 @@ object Test {
     def test(expr: String): Unit = {
       val t = toolbox.parse(expr)
       println(expr)
-      println(run(t, printPositions = true.show.toExpr))
+      println(show(t, printPositions = true))
       println()
     }
     val tests = """

tests/run-with-compiler/i3823-b.scala

@@ -1,10 +1,10 @@
 import scala.quoted._
 object Test {
-  def main(args: Array[String]): Unit = {
+  implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
+  def main(args: Array[String]): Unit = withNewQuoteContext {
     def f[T](x: Expr[T])(implicit t: Type[T]) = '{
       val z: $t = $x
     }
-    implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
-    println(run(f('{2})(Type.IntTag).show.toExpr))
+    println(f('{2})(Type.IntTag).show)
   }
 }

tests/run-with-compiler/i3823-c.scala

@@ -1,10 +1,10 @@
 import scala.quoted._
 object Test {
-  def main(args: Array[String]): Unit = {
+  implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
+  def main(args: Array[String]): Unit = withNewQuoteContext {
     def f[T](x: Expr[T])(implicit t: Type[T]) = '{
       val z = $x
     }
-    implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
-    println(run(f('{2})(Type.IntTag).show.toExpr))
+    println(f('{2})(Type.IntTag).show)
   }
 }

tests/run-with-compiler/i3823.scala

@@ -1,10 +1,10 @@
 import scala.quoted._
 object Test {
-  def main(args: Array[String]): Unit = {
+  implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
+  def main(args: Array[String]): Unit = withNewQuoteContext {
     def f[T: Type](x: Expr[T])(t: Type[T]) = '{
       val z: $t = $x
     }
-    implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
-    println(run(f('{2})('[Int]).show.toExpr))
+    println(f('{2})('[Int]).show)
   }
 }

tests/run-with-compiler/i3847-b.scala

@@ -13,11 +13,11 @@ object Arrays {
 }
 
 object Test {
-  def main(args: Array[String]): Unit = {
-    implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
+  implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
+  def main(args: Array[String]): Unit = withNewQuoteContext {
     import Arrays._
     implicit val ct: Expr[ClassTag[Int]] = '{ClassTag.Int}
     val arr: Expr[Array[List[Int]]] = Array[List[Int]](List(1, 2, 3)).toExpr
-    println(run(arr.show.toExpr))
+    println(arr.show)
   }
 }