wip

Author: nicolasstucki

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

@@ -2,20 +2,21 @@ package dotty.tools.dotc.quoted
 
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.Driver
-import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Contexts.{Context, ContextBase}
 import dotty.tools.io.{AbstractFile, Directory, PlainDirectory, VirtualDirectory}
 import dotty.tools.repl.AbstractFileClassLoader
 
 import scala.quoted.{Expr, Type}
 import java.net.URLClassLoader
 
-import Toolbox.{Run, Settings, Show}
 import dotty.tools.dotc.tastyreflect.TastyImpl
 
 class QuoteDriver extends Driver {
   import tpd._
 
-  def run[T](expr: Expr[T], settings: Settings[Run]): T = {
+  private[this] val contextBase: ContextBase = new ContextBase
+
+  def run[T](expr: Expr[T], settings: ToolboxSettings): T = {
     val (_, ctx: Context) = setup(settings.compilerArgs.toArray :+ "dummy.scala", initCtx.fresh)
 
     val outDir: AbstractFile = settings.outDir match {
@@ -39,15 +40,15 @@ class QuoteDriver extends Driver {
     method.invoke(instance).asInstanceOf[T]
   }
 
-  def show(expr: Expr[_], settings: Settings[Show]): String = {
+  def show(expr: Expr[_], settings: ToolboxSettings): String = {
     def show(tree: Tree, ctx: Context): String = {
       val tree1 = if (settings.rawTree) tree else (new TreeCleaner).transform(tree)(ctx)
       TastyImpl.showSourceCode.showTree(tree1)(ctx)
     }
     withTree(expr, show, settings)
   }
 
-  def withTree[T](expr: Expr[_], f: (Tree, Context) => T, settings: Settings[_]): T = {
+  def withTree[T](expr: Expr[_], f: (Tree, Context) => T, settings: ToolboxSettings): T = {
     val (_, ctx: Context) = setup(settings.compilerArgs.toArray :+ "dummy.scala", initCtx.fresh)
 
     var output: Option[T] = None
@@ -59,7 +60,7 @@ class QuoteDriver extends Driver {
     output.getOrElse(throw new Exception("Could not extract " + expr))
   }
 
-  def withTypeTree[T](tpe: Type[_], f: (TypTree, Context) => T, settings: Settings[_]): T = {
+  def withTypeTree[T](tpe: Type[_], f: (TypTree, Context) => T, settings: ToolboxSettings): T = {
     val (_, ctx: Context) = setup(settings.compilerArgs.toArray :+ "dummy.scala", initCtx.fresh)
 
     var output: Option[T] = None
@@ -72,7 +73,7 @@ class QuoteDriver extends Driver {
   }
 
   override def initCtx: Context = {
-    val ictx = super.initCtx.fresh
+    val ictx = contextBase.initialCtx
     var classpath = System.getProperty("java.class.path")
     this.getClass.getClassLoader match {
       case cl: URLClassLoader =>

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

@@ -10,61 +10,20 @@ import scala.runtime.quoted._
 object Toolbox {
   import tpd._
 
-  type Run
-  type Show
+  implicit def make(implicit settings: ToolboxSettings): Toolbox = new Toolbox {
 
-  implicit def toolbox[T](implicit
-      runSettings: Settings[Run] = Settings.run(),
-      showSettings: Settings[Show] = Settings.show()
-    ): Toolbox[T] = new Toolbox[T] {
+    private[this] val driver: QuoteDriver = new QuoteDriver()
 
-    def run(expr: Expr[T]): T = expr match {
+    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 an inline macro argument.")
       case _ =>
-        new QuoteDriver().run(expr, runSettings)
+        driver.run(expr, settings)
     }
 
-    def show(expr: Expr[T]): String = new QuoteDriver().show(expr, showSettings)
+    def show[T](expr: Expr[T]): String = driver.show(expr, settings)
 
   }
-
-  class Settings[T] private (val outDir: Option[String], val rawTree: Boolean, val compilerArgs: List[String])
-
-  object Settings {
-
-    /** Quote run settings
-     *  @param optimise Enable optimisation when compiling the quoted code
-     *  @param outDir Output directory for the compiled quote. If set to None the output will be in memory
-     *  @param compilerArgs Compiler arguments. Use only if you know what you are doing.
-     */
-    def run(
-        optimise: Boolean = false,
-        outDir: Option[String] = None,
-        compilerArgs: List[String] = Nil
-        ): Settings[Run] = {
-      var compilerArgs1 = compilerArgs
-      if (optimise) compilerArgs1 = "-optimise" :: compilerArgs1
-      new Settings(outDir, false, compilerArgs1)
-    }
-
-    /** Quote show settings
-     *  @param color Print output with colors
-     *  @param rawTree Do not remove quote tree artifacts
-     *  @param compilerArgs Compiler arguments. Use only if you know what you are doing.
-     */
-    def show(
-        color: Boolean = false,
-        rawTree: Boolean = false,
-        compilerArgs: List[String] = Nil
-        ): Settings[Show] = {
-      var compilerArgs1 = compilerArgs
-      compilerArgs1 = s"-color:${if (color) "always" else "never"}" :: compilerArgs1
-      new Settings(None, rawTree, compilerArgs1)
-    }
-
-  }
-
 }

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

@@ -0,0 +1,29 @@
+package dotty.tools.dotc.quoted
+
+class ToolboxSettings private (val outDir: Option[String], val rawTree: Boolean, val compilerArgs: List[String])
+
+object ToolboxSettings {
+
+  implicit def default: ToolboxSettings = make()
+
+  /** Make toolbox settings
+    *  @param optimise Enable optimisation when compiling the quoted code
+    *  @param outDir Output directory for the compiled quote. If set to None the output will be in memory
+    *  @param color Print output with colors
+    *  @param rawTree Do not remove quote tree artifacts
+    *  @param compilerArgs Compiler arguments. Use only if you know what you are doing.
+    */
+  def make(
+            optimise: Boolean = false,
+            color: Boolean = false,
+            rawTree: Boolean = false,
+            outDir: Option[String] = None,
+            compilerArgs: List[String] = Nil
+          ): ToolboxSettings = {
+    var compilerArgs1 = compilerArgs
+    if (optimise) compilerArgs1 = "-optimise" :: compilerArgs1
+    compilerArgs1 = s"-color:${if (color) "always" else "never"}" :: compilerArgs1
+    new ToolboxSettings(outDir, rawTree, compilerArgs1)
+  }
+
+}

library/src/scala/quoted/Expr.scala

@@ -10,10 +10,10 @@ sealed abstract class Expr[T] {
    *
    *  May throw a FreeVariableError on expressions that came from an inline macro.
    */
-  final def run(implicit toolbox: Toolbox[T]): T = toolbox.run(this)
+  final def run(implicit toolbox: Toolbox): T = toolbox.run(this)
 
   /** Show a source code like representation of this expression */
-  final def show(implicit toolbox: Toolbox[T]): String = toolbox.show(this)
+  final def show(implicit toolbox: Toolbox): String = toolbox.show(this)
 }
 
 object Expr {

library/src/scala/runtime/quoted/Toolbox.scala

@@ -4,7 +4,7 @@ import scala.annotation.implicitNotFound
 import scala.quoted.Expr
 
 @implicitNotFound("Could not find implicit quoted.Toolbox. Default toolbox can be imported with `import dotty.tools.dotc.quoted.Toolbox._`")
-trait Toolbox[T] {
-  def run(expr: Expr[T]): T
-  def show(expr: Expr[T]): String
+trait Toolbox {
+  def run[T](expr: Expr[T]): T
+  def show[T](expr: Expr[T]): String
 }

tests/run-with-compiler/quote-run-many.scala

@@ -0,0 +1,17 @@
+import scala.quoted._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    implicit val toolbox: scala.runtime.quoted.Toolbox = dotty.tools.dotc.quoted.Toolbox.make
+    def expr(i: Int) = '{
+      val a = 3 + ~i.toExpr
+      2 + a
+    }
+    for (i <- 0 to 200) {
+      val t0 = System.nanoTime()
+      val res = expr(i).run
+      val t = (System.nanoTime() - t0) / 1000000
+      println(s"$i = $res in ${t}ms")
+    }
+  }
+}

tests/run-with-compiler/quote-run-with-settings.scala

@@ -2,6 +2,7 @@
 import java.nio.file.{Files, Paths}
 
 import dotty.tools.dotc.quoted.Toolbox._
+import dotty.tools.dotc.quoted.ToolboxSettings
 
 import scala.quoted._
 
@@ -22,7 +23,7 @@ object Test {
     Files.deleteIfExists(classFile)
 
     {
-      implicit val settings = Settings.run(optimise = true, outDir = Some(outDir.toString))
+      implicit val settings = ToolboxSettings.make(optimise = true, outDir = Some(outDir.toString))
       println(expr.run)
       assert(Files.exists(classFile))
     }

tests/run-with-compiler/quote-show-blocks-raw.scala

@@ -1,11 +1,12 @@
 
 import dotty.tools.dotc.quoted.Toolbox._
+import dotty.tools.dotc.quoted.ToolboxSettings
 
 import scala.quoted._
 
 object Test {
   def main(args: Array[String]): Unit = {
-    implicit val settings = Settings.show(rawTree = true)
+    implicit val settings = ToolboxSettings.make(rawTree = true)
 
     def a(n: Int, x: Expr[Unit]): Expr[Unit] =
       if (n == 0) x