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 {

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

@@ -5,6 +5,9 @@ object Test {
       val z: $t = $x
     }
     implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
-    println(f('{2})(Type.IntTag).show)
+    run {
+      println(f('{2})(Type.IntTag).show)
+      '{}
+    }
   }
-}
+}

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

@@ -5,7 +5,9 @@ object Test {
       val z = $x
     }
     implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
-    println(f('{2})(Type.IntTag).show)
+    run {
+      println(f('{2})(Type.IntTag).show)
+      '{}
+    }
   }
 }
-

tests/run-with-compiler/i3823.scala

@@ -5,6 +5,9 @@ object Test {
       val z: $t = $x
     }
     implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
-    println(f('{2})('[Int]).show)
+    run {
+      println(f('{2})('[Int]).show)
+      '{}
+    }
   }
 }

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

@@ -18,6 +18,6 @@ object Test {
     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(arr.show)
+    println(run(arr.show.toExpr))
   }
 }

tests/run-with-compiler/i3847.scala

@@ -18,6 +18,6 @@ object Test {
     import Arrays._
     implicit val ct: Expr[ClassTag[Int]] = '{ClassTag.Int}
     val arr: Expr[Array[Int]] = Array[Int](1, 2, 3).toExpr
-    println(arr.show)
+    println(run(arr.show.toExpr))
   }
-}
+}

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

@@ -9,7 +9,13 @@ object Test {
       def f(x: Int): Int = x + x
       f
     }
-    println(run(f2(x)))
-    println(f2(x).show)
+
+    run {
+      val y = f2(x)
+      '{
+        println($y)
+        println(${y.show.toExpr})
+      }
+    }
   }
 }

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

@@ -9,7 +9,13 @@ object Test {
       val f: (x: Int) => Int = x => x + x
       f
     }
-    println(run(f3(x)))
-    println(f3(x).show) // TODO improve printer
+
+    run {
+      val y = f3(x)
+      '{
+        println($y)
+        println(${y.show.toExpr})
+      }
+    }
   }
 }

tests/run-with-compiler/i3876-d.scala

@@ -8,8 +8,14 @@ object Test {
     val f4: Expr[Int => Int] = '{
       inlineLambda
     }
-    println(run(f4(x)))
-    println(f4(x).show)
+
+    run {
+      val y = f4(x)
+      '{
+        println($y)
+        println(${y.show.toExpr})
+      }
+    }
   }
 
   inline def inlineLambda <: Int => Int = x => x + x

tests/run-with-compiler/i3876-e.check

@@ -1,9 +1,9 @@
 
 6
 {
-  val x$1: scala.Int = {
+  val x$2: scala.Int = {
     scala.Predef.println()
     3
   }
-  x$1.+(x$1)
+  x$2.+(x$2)
 }

tests/run-with-compiler/i3876-e.scala

@@ -8,8 +8,14 @@ object Test {
     val f4: Expr[Int => Int] = '{
       inlineLambda
     }
-    println(run(f4(x)))
-    println(f4(x).show)
+
+    run {
+      val y = f4(x)
+      '{
+        println($y)
+        println(${y.show.toExpr})
+      }
+    }
   }
 
   inline def inlineLambda <: Int => Int = x => x + x

tests/run-with-compiler/i3876.scala

@@ -6,7 +6,13 @@ object Test {
     val x: Expr[Int] = '{3}
 
     val f: Expr[Int => Int] = '{ (x: Int) => x + x }
-    println(run(f(x)))
-    println(f(x).show)
+
+    run {
+      val y = f(x)
+      '{
+        println($y)
+        println(${y.show.toExpr})
+      }
+    }
   }
 }

tests/run-with-compiler/i3946.scala

@@ -2,8 +2,10 @@ import scala.quoted._
 object Test {
   def main(args: Array[String]): Unit = {
     implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
-    val u: Expr[Unit] = '{}
-    println(u.show)
-    println(run(u))
+    run {
+      val u: Expr[Unit] = '{}
+      println(u.show)
+      '{ println($u) }
+    }
   }
 }

tests/run-with-compiler/i3947.scala

@@ -5,12 +5,12 @@ object Test {
 
   def main(args: Array[String]): Unit = {
     implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
-    def test[T: Type](clazz: java.lang.Class[T]): Unit = {
+    def test[T: Type](clazz: java.lang.Class[T]): Unit = run {
       val lclazz = clazz.toExpr
       val name = '{ ($lclazz).getCanonicalName }
       println()
       println(name.show)
-      println(run(name))
+      '{ println($name) }
     }
 
     // classOf[Object]