wip

Author: nicolasstucki

compiler/src/dotty/tools/dotc/quoted/ExprCompilationUnit.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/QuoteCompiler.scala

@@ -50,7 +50,7 @@ class QuoteCompiler extends Compiler {
         case exprUnit: ExprCompilationUnit =>
           val tree =
             if (putInClass) inClass(exprUnit.expr)
-            else PickledQuotes.quotedExprToTree(exprUnit.expr)
+            else PickledQuotes.quotedExprToTree(exprUnit.expr.apply(new QuoteContext(ctx)))
           val source = SourceFile.virtual("<quoted.Expr>", "")
           CompilationUnit(source, tree, forceTrees = true)
         case typeUnit: TypeCompilationUnit =>
@@ -65,7 +65,7 @@ class QuoteCompiler extends Compiler {
       *  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 +74,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(expr.apply(new QuoteContext(ctx)))(ctx.withOwner(meth))
 
       val run = DefDef(meth, quoted)
       val classTree = ClassDef(cls, DefDef(cls.primaryConstructor.asTerm), run :: Nil)
@@ -85,7 +85,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/QuoteContext.scala

@@ -0,0 +1,26 @@
+package dotty.tools.dotc
+package quoted
+
+import dotty.tools.dotc.ast.tpd._
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.quoted.PickledQuotes
+
+import scala.annotation.implicitNotFound
+
+@implicitNotFound("Could not find implicit scala.quoted.QuoteContext. TODO")
+class QuoteContext(ctx: Context) extends scala.quoted.QuoteContext {
+
+  def show[T](expr: scala.quoted.Expr[T]): String =
+    doShow(PickledQuotes.quotedExprToTree(expr)(ctx), ctx)
+
+  def show[T](tpe: scala.quoted.Type[T]): String =
+    doShow(PickledQuotes.quotedTypeToTree(tpe)(ctx), ctx)
+
+  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)
+    tastyreflect.ReflectionImpl.showTree(tree1)
+  }
+}

compiler/src/dotty/tools/dotc/quoted/QuoteDriver.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)
@@ -55,23 +55,23 @@ class QuoteDriver(appClassloader: ClassLoader) extends Driver {
     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 show(expr: scala.quoted.QuoteContext => 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: scala.quoted.QuoteContext => 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)

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

@@ -19,18 +19,19 @@ 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.")
+    def run[T](expr: scala.quoted.QuoteContext => Expr[T]): T = expr match {
+        // TODO move logic into driver
+//      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 show[T](expr: Expr[T]): String = synchronized(driver.show(expr, settings))
-
-    def show[T](tpe: Type[T]): String = synchronized(driver.show(tpe, 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))
   }
 
 }

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

@@ -9,7 +9,7 @@ package quoted {
      *  May throw a FreeVariableError on expressions that came from a macro.
      */
     @deprecated("Use scala.quoted.run", "")
-    final def run(implicit toolbox: Toolbox): T = toolbox.run(this)
+    final def run(implicit toolbox: Toolbox): T = toolbox.run(_ => this)
 
   }
 
@@ -19,7 +19,7 @@ package quoted {
 
     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 qctx: QuoteContext): String = qctx.show(expr)
     }
 
     /** Converts a tuple `(T1, ..., Tn)` to `(Expr[T1], ..., Expr[Tn])` */

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

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

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

@@ -14,7 +14,9 @@ package object quoted {
     *
    *  May throw a FreeVariableError on expressions that came from a macro.
    */
-  def run[T](expr: Expr[T]) given (toolbox: Toolbox): T = toolbox.run(expr)
+  def run[T](expr: given QuoteContext => Expr[T]) given (toolbox: Toolbox): T = toolbox.run(expr given _)
+
+  def show[T](expr: given QuoteContext => Expr[T]) given (toolbox: Toolbox): String = run(expr.show.toExpr)
 
   object autolift {
     implicit def autoToExpr[T: Liftable](x: T): Expr[T] = x.toExpr

library/src/scala/quoted/QuoteContext.scala

@@ -0,0 +1,9 @@
+package scala.quoted
+
+trait QuoteContext {
+
+  def show[T](expr: Expr[T]): String
+
+  def show[T](tpe: Type[T]): String
+
+}

library/src/scala/quoted/Toolbox.scala

@@ -4,9 +4,13 @@ import scala.annotation.implicitNotFound
 
 @implicitNotFound("Could not find implicit quoted.Toolbox.\n\nDefault toolbox can be instantiated with:\n  `implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)`\n\n")
 trait Toolbox {
-  def run[T](expr: Expr[T]): T
-  def show[T](expr: Expr[T]): String
-  def show[T](tpe: Type[T]): String
+  def run[T](expr: QuoteContext => Expr[T]): T
+
+//  @deprecated("TODO", "")
+//  def show[T](expr: Expr[T]): String
+//
+//  @deprecated("TODO", "")
+//  def show[T](tpe: Type[T]): String
 }
 
 object Toolbox {