WIP fix after rebase

Author: nicolasstucki

community-build/community-projects/scalatest

@@ -165,7 +165,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
     case Some(l) =>
       l == level ||
         level == -1 && (
-          sym == defn.TastyReflection_macroContext ||
+          sym == defn.StagingContext_macroContext ||
             // here we assume that Splicer.canBeSpliced was true before going to level -1,
             // this implies that all non-inline arguments are quoted and that the following two cases are checked
             // on inline parameters or type parameters.

community-build/community-projects/stdLib213

@@ -0,0 +1,25 @@
+package scala.quoted
+
+import scala.tasty.Reflection
+
+import scala.annotation.{implicitAmbiguous, implicitNotFound}
+
+// TODO add @implicitAmbiguous("...")
+// TODO add some fake default and give better error message in `Staging` compiler phase
+@implicitNotFound("Could not find an implicit StagingContext.\nIf this is a method that returns an `Expr[T]` you can use `Staged[T]` instead.\n\nQuotedContex is provided inside of top level splices in `inline` macros or within a call to `Toolbox.run`.\n")
+trait StagingContext extends scala.runtime.quoted.Unpickler {
+  def show[T](expr: Expr[T]): String
+  def show[T](tpe: Type[T]): String
+
+  /** AST reflection API. Provides low level reflection capabilities on the definition of the TASTy trees.
+   *
+   *  Waring: Using this API can break the static type safety of quotes and splices.
+   *          Error will be thrown at reflection time.
+   */
+  val reflection: Reflection
+}
+
+object StagingContext {
+   /** Compiler `StagingContext` available in a top level `~` of an inline macro */
+   implicit def macroContext: StagingContext = throw new Exception("Not in inline macro.")
+}

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

@@ -4,8 +4,8 @@ trait Toolbox {
   def run[T](code: Staged[T]): T = runImpl(code)
   protected def runImpl[T](code: StagingContext => Expr[T]): T // For Scala2 compat in ToolboxImpl
 
-  def show[T](code: Staged[T]): String = runImpl(ctx => { implicit val c: StagingContext = ctx; code(ctx).show.toExpr })
-  def show[T](code: StagedType[T]): String = runImpl(ctx => { implicit val c: StagingContext = ctx; code(ctx).show.toExpr })
+//  def show[T](code: Staged[T]): String = runImpl(ctx => { implicit val c: StagingContext = ctx; code(ctx).show.toExpr })
+//  def show[T](code: StagedType[T]): String = runImpl(ctx => { implicit val c: StagingContext = ctx; code(ctx).show.toExpr })
 }
 
 object Toolbox {

library/src-2.x/scala/quoted/StagingContext.scala

@@ -2,9 +2,9 @@ package scala
 
 package object quoted {
 
-  type Staged[T] = /*implicit*/ StagingContext => Expr[T]
+  type Staged[T] = /*given*/ StagingContext => Expr[T]
 
-  type StagedType[T] = /*implicit*/ StagingContext => Type[T]
+  type StagedType[T] = /*given*/ StagingContext => Type[T]
 
   implicit class LiftExprOps[T](val x: T) extends AnyVal {
     def toExpr(implicit ev: Liftable[T], st: StagingContext): Expr[T] = ev.toExpr(x)

library/src/scala/quoted/Toolbox.scala renamed to library/src-2.x/scala/quoted/Toolbox.scala

@@ -0,0 +1,62 @@
+package scala.quoted
+
+trait Toolbox {
+  def run[T](code: Staged[T]): T = runImpl(sc => code given sc)
+  protected def runImpl[T](code: StagingContext => Expr[T]): T // For Scala2 compat in ToolboxImpl
+
+//  def show[T](code: Staged[T]): String = runImpl(ctx => { implicit val c: StagingContext = ctx; (code given ctx).show.toExpr })
+//  def show[T](code: StagedType[T]): String = runImpl(ctx => { implicit val c: StagingContext = ctx; (code given ctx).show.toExpr })
+}
+
+object Toolbox {
+
+  /** Create a new instance of the toolbox using the the classloader of the application.
+    *
+    * Usuage:
+    * ```
+    * implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
+    * ```
+    *
+    * @param appClassloader classloader of the application that generated the quotes
+    * @param settings toolbox settings
+    * @return A new instance of the toolbox
+    */
+  def make(appClassloader: ClassLoader)(implicit settings: Settings): Toolbox = {
+    try {
+      val toolboxImplCls = appClassloader.loadClass("dotty.tools.dotc.quoted.ToolboxImpl")
+      val makeMeth = toolboxImplCls.getMethod("make", classOf[Settings], classOf[ClassLoader])
+      makeMeth.invoke(null, settings, appClassloader).asInstanceOf[Toolbox]
+    }
+    catch {
+      case ex: ClassNotFoundException =>
+        throw new ToolboxNotFoundException(
+          s"""Could not load the Toolbox class `${ex.getMessage}` from the JVM classpath. Make sure that the compiler is on the JVM classpath.""",
+          ex
+        )
+    }
+  }
+
+  /** Setting of the Toolbox instance. */
+  case class Settings private (outDir: Option[String], showRawTree: Boolean, compilerArgs: List[String], color: Boolean)
+
+  object Settings {
+
+    implicit def default: Settings = make()
+
+    /** Make toolbox settings
+     *  @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 showRawTree Do not remove quote tree artifacts
+     *  @param compilerArgs Compiler arguments. Use only if you know what you are doing.
+     */
+    def make( // TODO avoid using default parameters (for binary compat)
+      color: Boolean = false,
+      showRawTree: Boolean = false,
+      outDir: Option[String] = None,
+      compilerArgs: List[String] = Nil
+    ): Settings =
+      new Settings(outDir, showRawTree, compilerArgs, color)
+  }
+
+  class ToolboxNotFoundException(msg: String, cause: ClassNotFoundException) extends Exception(msg, cause)
+}

library/src-non-bootstrapped/scala/quoted/package.scala renamed to library/src-2.x/scala/quoted/package.scala

@@ -13,7 +13,7 @@ object Type {
 
   implicit class TypeOps[T](tpe: Type[T]) {
     /** Show a source code like representation of this type */
-    def show(implicit toolbox: Toolbox): String = toolbox.show(tpe.asInstanceOf[Type[Any]])
+    def show given StagingContext: String = the[StagingContext].show(tpe)
   }
 
   implicit def UnitTag: Type[Unit] = new TaggedType[Unit]

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

@@ -2,12 +2,12 @@ package scala
 
 package object quoted {
 
-  type Staged[T] = implicit StagingContext => Expr[T]
+  type Staged[T] = given StagingContext => Expr[T]
 
-  type StagedType[T] = implicit StagingContext => Type[T]
+  type StagedType[T] = given StagingContext => Type[T]
 
   object autolift {
-    implicit def autoToExpr[T: Liftable](x: T): Expr[T] = x.toExpr
+    implicit def autoToExpr[T: Liftable](x: T) given StagingContext: Expr[T] = x.toExpr
   }
 
   implicit class LiftExprOps[T](val x: T) extends AnyVal {

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

@@ -5,7 +5,8 @@ import scala.tasty.Reflection
 
 inline def typeChecks(inline code: String): Boolean = ${ typeChecksImpl(code) }
 
-private def typeChecksImpl(code: String)(implicit reflect: Reflection): Expr[Boolean] = {
+private def typeChecksImpl(code: String) given StagingContext: Expr[Boolean] = {
+  val reflect = the[StagingContext].reflection
   import reflect._
   typing.typeChecks(code).toExpr
 }

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

@@ -0,0 +1,25 @@
+package scala.quoted
+
+import scala.tasty.Reflection
+
+import scala.annotation.{implicitAmbiguous, implicitNotFound}
+
+// TODO add @implicitAmbiguous("...")
+// TODO add some fake default and give better error message in `Staging` compiler phase
+@implicitNotFound("Could not find an implicit StagingContext.\nIf this is a method that returns an `Expr[T]` you can use `Staged[T]` instead.\n\nQuotedContex is provided inside of top level splices in `inline` macros or within a call to `Toolbox.run`.\n")
+trait StagingContext extends scala.runtime.quoted.Unpickler {
+  def show[T](expr: Expr[T]): String
+  def show[T](tpe: Type[T]): String
+
+  /** AST reflection API. Provides low level reflection capabilities on the definition of the TASTy trees.
+   *
+   *  Waring: Using this API can break the static type safety of quotes and splices.
+   *          Error will be thrown at reflection time.
+   */
+  val reflection: Reflection
+}
+
+object StagingContext {
+   /** Compiler `StagingContext` available in a top level `~` of an inline macro */
+   def macroContext: StagingContext = throw new Exception("Not in inline macro.")
+}

library/src-3.x/scala/testing/typeChecks.scala

@@ -9,7 +9,7 @@ object Expr {
 
   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 stCtx: StagingContext): String = stCtx.show(expr)
   }
 
   implicit class AsFunction0[R](private val f: Expr[() => R]) extends AnyVal {

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

@@ -42,3 +42,9 @@ class Reflection(val kernel: Kernel)
     val reflect: self.type = self
   }
 }
+
+object Reflection {
+  /** Compiler tasty context available in a top level ~ of an inline macro */
+  @deprecated("use StagingContext.macroContext")
+  def macroContext: Reflection = throw new Exception("Not in inline macro.") // TODO remove when reference compiler is updated
+}