Implement toTasty on quoted.Type

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala

@@ -41,7 +41,7 @@ object PickledQuotes {
         case value: Class[_] => ref(defn.Predef_classOf).appliedToType(classToType(value))
         case value=> Literal(Constant(value))
       }
-    case expr: TreeExpr @unchecked =>
+    case expr: TreeExpr =>
       dotty.tools.dotc.tasty.internal.Term.tree(expr.term)
     case expr: FunctionAppliedTo[_, _] =>
       functionAppliedTo(quotedExprToTree(expr.f), quotedExprToTree(expr.x))
@@ -51,7 +51,7 @@ object PickledQuotes {
   def quotedTypeToTree(expr: quoted.Type[_])(implicit ctx: Context): Tree = expr match {
     case expr: TastyType[_] => unpickleType(expr)
     case expr: TaggedType[_] => classTagToTypeTree(expr.ct)
-    case expr: TreeType[Tree] @unchecked => expr.tree
+    case expr: TreeType => dotty.tools.dotc.tasty.internal.TypeTree.tree(expr.tpe)
   }
 
   /** Unpickle the tree contained in the TastyExpr */

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -1142,7 +1142,7 @@ class TreeUnpickler(reader: TastyReader,
       val splice = splices(idx)
       def wrap(arg: Tree) =
         if (arg.isTerm) new TreeExpr(dotty.tools.dotc.tasty.internal.Term(arg))
-        else new TreeType(arg) // TODO use tasty type
+        else new TreeType(dotty.tools.dotc.tasty.internal.TypeTree(arg))
       val reifiedArgs = args.map(wrap)
       if (isType) {
         val quotedType =

compiler/src/dotty/tools/dotc/quoted/ExprCompiler.scala renamed to compiler/src/dotty/tools/dotc/quoted/QuoteCompiler.scala

@@ -20,12 +20,12 @@ import dotty.tools.dotc.util.Positions.Position
 import dotty.tools.dotc.util.SourceFile
 import dotty.tools.io.{AbstractFile, Path, PlainFile}
 
-import scala.quoted.Expr
+import scala.quoted.{Expr, Type}
 
 /** Compiler that takes the contents of a quoted expression `expr` and produces
  *  a class file with `class ' { def apply: Object = expr }`.
  */
-class ExprCompiler(directory: AbstractFile) extends Compiler {
+class QuoteCompiler(directory: AbstractFile) extends Compiler {
   import tpd._
 
   /** A GenBCode phase that outputs to a virtual directory */
@@ -35,7 +35,7 @@ class ExprCompiler(directory: AbstractFile) extends Compiler {
   }
 
   override protected def frontendPhases: List[List[Phase]] =
-    List(List(new ExprFrontend(putInClass = true)))
+    List(List(new QuotedFrontend(putInClass = true)))
 
   override protected def picklerPhases: List[List[Phase]] =
     List(List(new ReifyQuotes))
@@ -50,8 +50,8 @@ class ExprCompiler(directory: AbstractFile) extends Compiler {
 
   def outputClassName: TypeName = "Quoted".toTypeName
 
-  /** Frontend that receives scala.quoted.Expr as input */
-  class ExprFrontend(putInClass: Boolean) extends FrontEnd {
+  /** Frontend that receives a scala.quoted.Expr or scala.quoted.Type as input */
+  class QuotedFrontend(putInClass: Boolean) extends FrontEnd {
     import tpd._
 
     override def isTyper = false
@@ -64,6 +64,11 @@ class ExprCompiler(directory: AbstractFile) extends Compiler {
             else PickledQuotes.quotedExprToTree(exprUnit.expr)
           val source = new SourceFile("", Seq())
           CompilationUnit.mkCompilationUnit(source, tree, forceTrees = true)
+        case typeUnit: TypeCompilationUnit =>
+          assert(!putInClass)
+          val tree = PickledQuotes.quotedTypeToTree(typeUnit.tpe)
+          val source = new SourceFile("", Seq())
+          CompilationUnit.mkCompilationUnit(source, tree, forceTrees = true)
       }
     }
 
@@ -93,6 +98,10 @@ class ExprCompiler(directory: AbstractFile) extends Compiler {
       val units = new ExprCompilationUnit(expr) :: Nil
       compileUnits(units)
     }
+    def compileType(tpe: Type[_]): Unit = {
+      val units = new TypeCompilationUnit(tpe) :: Nil
+      compileUnits(units)
+    }
   }
 
 }

compiler/src/dotty/tools/dotc/quoted/ExprDecompiler.scala renamed to compiler/src/dotty/tools/dotc/quoted/QuoteDecompiler.scala

@@ -4,15 +4,15 @@ 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 outputs it's tree. */
-class ExprDecompiler(output: tpd.Tree => Context => Unit) extends ExprCompiler(null) {
+/** Compiler that takes the contents of a quoted expression (or type) and outputs it's tree. */
+class QuoteDecompiler(output: tpd.Tree => Context => Unit) extends QuoteCompiler(null) {
   override def phases: List[List[Phase]] = List(
-    List(new ExprFrontend(putInClass = false)), // Create class from Expr
+    List(new QuotedFrontend(putInClass = false)), // Create class from Expr
     List(new QuoteTreeOutput(output))
   )
 
   class QuoteTreeOutput(output: tpd.Tree => Context => Unit) extends Phase {
-    override def phaseName: String = "quotePrinter"
+    override def phaseName: String = "quoteOutput"
     override def run(implicit ctx: Context): Unit = output(ctx.compilationUnit.tpdTree)(ctx)
   }
 }

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

@@ -7,7 +7,7 @@ import dotty.tools.io.{AbstractFile, Directory, PlainDirectory, VirtualDirectory
 import dotty.tools.repl.AbstractFileClassLoader
 import dotty.tools.dotc.printing.DecompilerPrinter
 
-import scala.quoted.Expr
+import scala.quoted.{Expr, Type}
 
 import java.net.URLClassLoader
 
@@ -28,7 +28,7 @@ class QuoteDriver extends Driver {
         new VirtualDirectory("(memory)", None)
     }
 
-    val driver = new ExprCompiler(outDir)
+    val driver = new QuoteCompiler(outDir)
     driver.newRun(ctx).compileExpr(expr)
 
     val classLoader = new AbstractFileClassLoader(outDir, this.getClass.getClassLoader)
@@ -58,10 +58,22 @@ class QuoteDriver extends Driver {
       assert(output.isEmpty)
       output = Some(f(tree, ctx))
     }
-    new ExprDecompiler(registerTree).newRun(ctx).compileExpr(expr)
+    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: Settings[_]): T = {
+    val (_, ctx: Context) = setup(settings.compilerArgs.toArray :+ "dummy.scala", initCtx.fresh)
+
+    var output: Option[T] = None
+    def registerTree(tree: tpd.Tree)(ctx: Context): Unit = {
+      assert(output.isEmpty)
+      output = Some(f(tree.asInstanceOf[TypTree], ctx))
+    }
+    new QuoteDecompiler(registerTree).newRun(ctx).compileType(tpe)
+    output.getOrElse(throw new Exception("Could not extract " + tpe))
+  }
+
   override def initCtx: Context = {
     val ictx = super.initCtx.fresh
     var classpath = System.getProperty("java.class.path")

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

@@ -1,17 +1,16 @@
 package dotty.tools.dotc.quoted
 
-import dotty.tools.dotc.ast.Trees
-import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Constants._
 import dotty.tools.dotc.printing.RefinedPrinter
-import dotty.tools.dotc.tasty.internal.Term
+import dotty.tools.dotc.tasty.internal
 
-import scala.quoted.Expr
-import scala.runtime.BoxedUnit
+import scala.quoted.{Expr, Type}
 import scala.quoted.Exprs.{LiftedExpr, TreeExpr}
+import scala.quoted.Types.TreeType
+import scala.runtime.BoxedUnit
 import scala.runtime.quoted._
-import scala.tasty.trees.Term
+import scala.tasty.trees
 
 /** Default runners for quoted expressions */
 object Toolbox {
@@ -45,11 +44,15 @@ object Toolbox {
       case _ => new QuoteDriver().show(expr, showSettings)
     }
 
-    def toTasty(expr: Expr[T]): Term = expr match {
+    def toTasty(expr: Expr[T]): trees.Term = expr match {
       case expr: TreeExpr => expr.term
-      case _ => new QuoteDriver().withTree(expr, (tree, ctx) => Term(tree)(ctx), Settings.run())
+      case _ => new QuoteDriver().withTree(expr, (tree, ctx) => internal.Term(tree)(ctx), Settings.run())
     }
 
+    def toTasty(tpe: Type[T]): trees.TypeTree = tpe match {
+      case expr: TreeType => expr.tpe
+      case _ => new QuoteDriver().withTypeTree(tpe, (tpt, ctx) => internal.TypeTree(tpt)(ctx), Settings.run())
+    }
   }
 
   class Settings[T] private (val outDir: Option[String], val rawTree: Boolean, val compilerArgs: List[String])

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

@@ -0,0 +1,11 @@
+package dotty.tools.dotc.quoted
+
+import dotty.tools.dotc.CompilationUnit
+import dotty.tools.dotc.util.NoSource
+
+import scala.quoted.Type
+
+/* Compilation unit containing the contents of a quoted type */
+class TypeCompilationUnit(val tpe: Type[_]) extends CompilationUnit(NoSource) {
+  override def toString = s"Type($tpe)"
+}

compiler/src/dotty/tools/dotc/tasty/internal/TypeTree.scala

@@ -79,6 +79,8 @@ object TypeTree {
     case _ => None
   }
 
+  def tree(tpe: trees.TypeTree): tpd.Tree = tpe.asInstanceOf[Impl].tree
+
   private[tasty] class Impl(val tree: tpd.Tree)(implicit val ctx: Context) extends trees.TypeTree with Positioned {
 
     assert(!tree.isInstanceOf[Trees.TypeBoundsTree[_]])

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

@@ -65,7 +65,7 @@ object Splicer {
         }
         args1 ::: liftArgs(tp.resType, args.tail)
       case tp: PolyType =>
-        val args1 = args.head.map(tp => new scala.quoted.Types.TreeType(tp))
+        val args1 = args.head.map(tp => new scala.quoted.Types.TreeType(dotty.tools.dotc.tasty.internal.TypeTree(tp)))
         args1 ::: liftArgs(tp.resType, args.tail)
       case _ => Nil
     }

library/src/scala/quoted/Type.scala

@@ -2,10 +2,12 @@ package scala.quoted
 
 import scala.quoted.Types.TaggedType
 import scala.reflect.ClassTag
+import scala.runtime.quoted.Toolbox
 import scala.runtime.quoted.Unpickler.Pickled
 
 sealed abstract class Type[T] {
   type unary_~ = T
+  final def toTasty(implicit toolbox: Toolbox[T]): scala.tasty.trees.TypeTree = toolbox.toTasty(this)
 }
 
 /** Some basic type tags, currently incomplete */
@@ -36,7 +38,7 @@ object Types {
   }
 
   /** An Type backed by a tree */
-  final class TreeType[Tree](val tree: Tree) extends quoted.Type[Any] {
+  final class TreeType(val tpe: scala.tasty.trees.TypeTree) extends quoted.Type[Any] {
     override def toString: String = s"Type(<raw>)"
   }
 }