Merge pull request #7077 from dotty-staging/factor-out-staging-from-the-core-of-scala.quoted

Factor out staging from the core of scala.quoted

Author: nicolasstucki

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

@@ -8,7 +8,7 @@ import dotty.tools.io.{AbstractFile, Directory, PlainDirectory, VirtualDirectory
 import dotty.tools.repl.AbstractFileClassLoader
 import dotty.tools.dotc.reporting._
 import scala.quoted._
-import scala.quoted.Toolbox
+import scala.quoted.staging.Toolbox
 import java.net.URLClassLoader
 
 /** Driver to compile quoted code

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

@@ -13,7 +13,7 @@ object ToolboxImpl {
     * @param settings toolbox settings
     * @return A new instance of the toolbox
     */
-  def make(settings: scala.quoted.Toolbox.Settings, appClassloader: ClassLoader): scala.quoted.Toolbox = new scala.quoted.Toolbox {
+  def make(settings: scala.quoted.staging.Toolbox.Settings, appClassloader: ClassLoader): scala.quoted.staging.Toolbox = new scala.quoted.staging.Toolbox {
 
     private[this] val driver: QuoteDriver = new QuoteDriver(appClassloader)
 
@@ -22,7 +22,7 @@ object ToolboxImpl {
     def run[T](exprBuilder: QuoteContext => Expr[T]): T = synchronized {
       try {
         if (running) // detected nested run
-          throw new scala.quoted.Toolbox.RunScopeException()
+          throw new scala.quoted.staging.RunScopeException()
         running = true
         driver.run(exprBuilder, settings)
       } finally {
@@ -35,7 +35,7 @@ object ToolboxImpl {
 
   private[dotty] def checkScopeId(id: ScopeId) given Context: Unit = {
     if (id != scopeId)
-      throw new Toolbox.RunScopeException
+      throw new scala.quoted.staging.RunScopeException
   }
 
   // TODO Explore more fine grained scope ids.

compiler/test-resources/repl-macros/i6007

@@ -1,9 +1,10 @@
 scala> import scala.quoted._
-scala> implicit def toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
-def toolbox: quoted.Toolbox
+scala> import scala.quoted.staging._
+scala> implicit def toolbox: Toolbox = Toolbox.make(getClass.getClassLoader)
+def toolbox: quoted.staging.Toolbox
 scala> def v given QuoteContext = '{ (if true then Some(1) else None).map(v => v+1) }
 def v given (x$1: quoted.QuoteContext): quoted.Expr[Option[Int]]
-scala> scala.quoted.withQuoteContext(v.show)
+scala> scala.quoted.staging.withQuoteContext(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)
+scala> scala.quoted.staging.run(v)
 val res1: Option[Int] = Some(2)

compiler/test-resources/repl-macros/i6263

@@ -1,6 +1,7 @@
 scala> import quoted._
-scala> implicit def toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
-def toolbox: quoted.Toolbox
+scala> import quoted.staging._
+scala> implicit def toolbox: Toolbox = Toolbox.make(getClass.getClassLoader)
+def toolbox: quoted.staging.Toolbox
 scala> def fn[T : Type](v : T) = println("ok")
 def fn[T](v: T)(implicit evidence$1: quoted.Type[T]): Unit
 scala> withQuoteContext { fn("foo") }

docs/docs/reference/metaprogramming/macros.md

@@ -471,7 +471,7 @@ you can expand code at runtime with a method `run`. There is also a problem with
 that invokation of `run` in splices. Consider the following expression:
 
 ```scala
-    '{ (x: Int) => ${ ('x).run; 1 } }
+    '{ (x: Int) => ${ run('x); 1 } }
 ```
 This is again phase correct, but will lead us into trouble. Indeed, evaluating
 the splice will reduce the expression `('x).run` to `x`. But then the result

docs/docs/reference/metaprogramming/staging.md

@@ -64,7 +64,7 @@ Run provides a `QuoteContext` that can be used to show the expression in the sco
 On the other hand `withQuoteContext` provides a `QuoteContext` without evauating the expression.
 
 ```scala
-package scala.quoted
+package scala.quoted.staging
 
 def run[T](expr: given QuoteContext => Expr[T]) given (toolbox: Toolbox): T = ...
 
@@ -81,8 +81,10 @@ expression at runtime. Within the scope of `run` we can also invoke `show` on an
 to get a source-like representation of the expression.
 
 ```scala
+import scala.quoted.staging._
+
 // make available the necessary toolbox for runtime code generation
-implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
+delegate for Toolbox = Toolbox.make(getClass.getClassLoader)
 
 val f: Array[Int] => Int = run {
   val stagedSum: Expr[Array[Int] => Int] = '{ (arr: Array[Int]) => ${sum('arr)}}

library/src-bootstrapped/scala/quoted/package.scala

@@ -2,49 +2,6 @@ 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 { // (given qctx: QuoteContext) =>
-   *    expr
-   *  }
-   *  ```
-   *  where `expr: Expr[T]`
-   *
-   *  This method should not be called in a context where there is already has a `QuoteContext`
-   *  such as within a `run` or a `withQuoteContext`.
-   */
-  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 = withQuoteContext { // (given qctx: QuoteContext) =>
-   *    thunk
-   *  }
-   *  ```
-   *  where `thunk: T`
-   *
-   *  This method should not be called in a context where there is already has a `QuoteContext`
-   *  such as within a `run` or a `withQuoteContext`.
-   */
-  def withQuoteContext[T](thunk: given QuoteContext => T) given (toolbox: Toolbox): T = {
-    var result: T = NoResult.asInstanceOf[T]
-    def dummyRun given QuoteContext: Expr[Unit] = {
-      result = thunk
-      Expr.unitExpr
-    }
-    toolbox.run(dummyRun given _)
-    assert(result != NoResult) // toolbox.run should have thrown an exception
-    result
-  }
-
-  private object NoResult
-
   object autolift {
     given autoToExpr[T] as Conversion[T, Expr[T]] given Liftable[T], QuoteContext = _.toExpr
   }

library/src-bootstrapped/scala/quoted/staging/package.scala

@@ -0,0 +1,48 @@
+package scala.quoted
+
+package object staging {
+
+  /** 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 { // (given qctx: QuoteContext) =>
+   *    expr
+   *  }
+   *  ```
+   *  where `expr: Expr[T]`
+   *
+   *  This method should not be called in a context where there is already has a `QuoteContext`
+   *  such as within a `run` or a `withQuoteContext`.
+   */
+  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 = withQuoteContext { // (given qctx: QuoteContext) =>
+   *    thunk
+   *  }
+   *  ```
+   *  where `thunk: T`
+   *
+   *  This method should not be called in a context where there is already has a `QuoteContext`
+   *  such as within a `run` or a `withQuoteContext`.
+   */
+  def withQuoteContext[T](thunk: given QuoteContext => T) given (toolbox: Toolbox): T = {
+    var result: T = NoResult.asInstanceOf[T]
+    def dummyRun given QuoteContext: Expr[Unit] = {
+      result = thunk
+      Expr.unitExpr
+    }
+    toolbox.run(dummyRun given _)
+    assert(result != NoResult) // toolbox.run should have thrown an exception
+    result
+  }
+
+  private object NoResult
+
+}

library/src-non-bootstrapped/scala/quoted/package.scala

@@ -2,49 +2,6 @@ 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 { // (given qctx: QuoteContext) =>
-   *    expr
-   *  }
-   *  ```
-   *  where `expr: Expr[T]`
-   *
-   *  This method should not be called in a context where there is already has a `QuoteContext`
-   *  such as within a `run` or a `withQuoteContext`.
-   */
-  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 = withQuoteContext { // (given qctx: QuoteContext) =>
-   *    thunk
-   *  }
-   *  ```
-   *  where `thunk: T`
-   *
-   *  This method should not be called in a context where there is already has a `QuoteContext`
-   *  such as within a `run` or a `withQuoteContext`.
-   */
-  def withQuoteContext[T](thunk: given QuoteContext => T) given (toolbox: Toolbox): T = {
-    var result: T = NoResult.asInstanceOf[T]
-    def dummyRun given QuoteContext: Expr[Unit] = {
-      result = thunk
-      Expr.unitExpr
-    }
-    toolbox.run(dummyRun given _)
-    assert(result != NoResult) // toolbox.run should have thrown an exception
-    result
-  }
-
-  private object NoResult
-
   object autolift {
     given autoToExpr[T] as Conversion[T, Expr[T]] given Liftable[T], QuoteContext = _.toExpr
   }

library/src/scala/quoted/Expr.scala

@@ -3,6 +3,7 @@ package scala
 package quoted {
 
   import scala.quoted.show.SyntaxHighlight
+  import scala.quoted.staging.Toolbox
 
   sealed trait Expr[+T] {