Add deconstructor for quotes containing constants

Author: nicolasstucki

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

@@ -1,15 +1,13 @@
 package dotty.tools.dotc.quoted
 
-import java.io.PrintStream
-
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Phases.Phase
 
-/** Compiler that takes the contents of a quoted expression `expr` and produces outputs
- *  the pretty printed code.
- */
-class ExprDecompiler(out: PrintStream) extends ExprCompiler(null) {
+/** Compiler that takes the contents of a quoted expression `expr` and outputs it's tree. */
+class ExprDecompiler(output: tpd.Tree => Context => Unit) extends ExprCompiler(null) {
   override def phases: List[List[Phase]] = List(
     List(new ExprFrontend(putInClass = false)), // Create class from Expr
-    List(new QuotePrinter(out)) // Print all loaded classes
+    List(new QuoteTreeOutput(output))
   )
 }

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

@@ -1,19 +1,16 @@
 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.StdNames._
 import dotty.tools.io.VirtualDirectory
-
 import dotty.tools.repl.AbstractFileClassLoader
 
 import scala.quoted.Expr
 
-import java.io.ByteArrayOutputStream
-import java.io.PrintStream
-import java.nio.charset.StandardCharsets
-
 class QuoteDriver extends Driver {
+  import tpd._
 
   def run[T](expr: Expr[T]): T = {
     val ctx: Context = initCtx.fresh
@@ -33,19 +30,16 @@ class QuoteDriver extends Driver {
     method.invoke(instance).asInstanceOf[T]
   }
 
-  def show(expr: Expr[_]): String = {
+  def toTreeWithContext(expr: Expr[_]): (Tree, Context) = {
     val ctx: Context = initCtx.fresh
     ctx.settings.color.update("never")(ctx) // TODO support colored show
-    val baos = new ByteArrayOutputStream
-    var ps: PrintStream = null
-    try {
-      ps = new PrintStream(baos, true, "utf-8")
-
-      new ExprDecompiler(ps).newRun(ctx).compileExpr(expr)
-
-      new String(baos.toByteArray, StandardCharsets.UTF_8)
+    var output: (tpd.Tree, Context) = null
+    def registerTree(tree: tpd.Tree)(ctx: Context): Unit = {
+      assert(output eq null)
+      output = (tree, ctx)
     }
-    finally if (ps != null) ps.close()
+    new ExprDecompiler(registerTree).newRun(ctx).compileExpr(expr)
+    output
   }
 
   override def initCtx: Context = {

compiler/src/dotty/tools/dotc/quoted/QuotePrinter.scala renamed to compiler/src/dotty/tools/dotc/quoted/QuoteTreeOutput.scala

@@ -1,17 +1,11 @@
 package dotty.tools.dotc.quoted
 
-import java.io.PrintStream
-
+import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Phases.Phase
 
 /** Pretty prints the compilation unit to an output stream */
-class QuotePrinter(out: PrintStream) extends Phase {
-
+class QuoteTreeOutput(output: tpd.Tree => Context => Unit) extends Phase {
   override def phaseName: String = "quotePrinter"
-
-  override def run(implicit ctx: Context): Unit = {
-    val unit = ctx.compilationUnit
-    out.print(unit.tpdTree.show)
-  }
+  override def run(implicit ctx: Context): Unit = output(ctx.compilationUnit.tpdTree)(ctx)
 }

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

@@ -1,22 +1,48 @@
 package dotty.tools.dotc.quoted
 
+import dotty.tools.dotc.ast.Trees._
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Constants._
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.interpreter.RawExpr
+
 import scala.quoted.Expr
 import scala.quoted.Liftable.PrimitiveExpr
 import scala.runtime.quoted._
 
 /** Default runners for quoted expressions */
 object Runners {
+  import tpd._
 
   implicit def runner[T]: Runner[T] = new Runner[T] {
 
-    def run(expr: Expr[T]): T = expr match {
+    override def run(expr: Expr[T]): T = expr match {
       case expr: PrimitiveExpr[T] => expr.value
       case _ => new QuoteDriver().run(expr)
     }
 
-    def show(expr: Expr[T]): String = expr match {
+    override def show(expr: Expr[T]): String = expr match {
       case expr: PrimitiveExpr[T] => expr.value.toString
-      case _ => new QuoteDriver().show(expr)
+      case _ =>
+        val (tree, ctx) = toTreeWithContext(expr)
+        tree.show(ctx)
+    }
+
+    override def toConstantOpt(expr: Expr[T]): Option[T] = {
+      def toConstantOpt(tree: Tree): Option[T] = tree match {
+        case Literal(Constant(c)) => Some(c.asInstanceOf[T])
+        case Block(Nil, e) => toConstantOpt(e)
+        case Inlined(_, Nil, e) => toConstantOpt(e)
+        case _ => None
+      }
+      expr match {
+        case expr: PrimitiveExpr[T] => Some(expr.value)
+        case _ => toConstantOpt(toTreeWithContext(expr)._1)
+      }
     }
+
+    private def toTreeWithContext(expr: Expr[T]): (Tree, Context) =
+      new QuoteDriver().toTreeWithContext(expr)
+
   }
 }

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -197,7 +197,8 @@ class CompilationTests extends ParallelTesting {
     compileFilesInDir("../tests/run-no-optimise", defaultOptions) +
     compileFile("../tests/run-special/quote-run.scala", defaultRunWithCompilerOptions) +
     compileFile("../tests/run-special/quote-run-2.scala", defaultRunWithCompilerOptions) +
-    compileFile("../tests/run-special/quote-run-staged-interpreter.scala", defaultRunWithCompilerOptions)
+    compileFile("../tests/run-special/quote-run-staged-interpreter.scala", defaultRunWithCompilerOptions) +
+    compileFile("../tests/run-special/quote-run-constants.scala", defaultRunWithCompilerOptions)
   }.checkRuns()
 
   // Generic java signatures tests ---------------------------------------------

library/src/scala/quoted/Constant.scala

@@ -0,0 +1,7 @@
+package scala.quoted
+
+import scala.runtime.quoted.Runner
+
+object Constant {
+  def unapply[T](expr: Expr[T])(implicit runner: Runner[T]): Option[T] = runner.toConstantOpt(expr)
+}

library/src/scala/quoted/TastyExpr.scala

@@ -3,4 +3,4 @@ package scala.quoted
 import scala.runtime.quoted.Unpickler.Pickled
 
 /** An Expr backed by a pickled TASTY tree */
-final case class TastyExpr[T](tasty: Pickled, args: Seq[Any]) extends Expr[T] with TastyQuoted
+final class TastyExpr[T](val tasty: Pickled, val args: Seq[Any]) extends Expr[T] with TastyQuoted

library/src/scala/quoted/TastyType.scala

@@ -3,4 +3,4 @@ package scala.quoted
 import scala.runtime.quoted.Unpickler.Pickled
 
 /** A Type backed by a pickled TASTY tree */
-final case class TastyType[T](tasty: Pickled, args: Seq[Any]) extends Type[T] with TastyQuoted
+final class TastyType[T](val tasty: Pickled, val args: Seq[Any]) extends Type[T] with TastyQuoted

library/src/scala/runtime/quoted/Runner.scala

@@ -7,4 +7,5 @@ import scala.quoted.Expr
 trait Runner[T] {
   def run(expr: Expr[T]): T
   def show(expr: Expr[T]): String
+  def toConstantOpt(expr: Expr[T]): Option[T]
 }

tests/run-special/quote-run-constants.check

@@ -0,0 +1,5 @@
+3
+4
+abc
+null
+OK

tests/run-special/quote-run-constants.scala

@@ -0,0 +1,15 @@
+import scala.quoted._
+
+import dotty.tools.dotc.quoted.Runners._
+
+object Test {
+
+  def main(args: Array[String]): Unit = {
+    (3: Expr[Int]) match { case Constant(n) => println(n) }
+    '(4) match { case Constant(n) => println(n) }
+    '("abc") match { case Constant(n) => println(n) }
+    '(null) match { case Constant(n) => println(n) }
+
+    '(new Object) match { case Constant(n) => println(n); case _ => println("OK") }
+  }
+}