Implement extractors for TASTY trees

* Define TASTY data types in scala.tasty
* Add method get a TASTY term from a quoted.Expr[T]
* Implement TASTY tree extractors

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -667,6 +667,12 @@ class Definitions {
   def Unpickler_liftedExpr = ctx.requiredMethod("scala.runtime.quoted.Unpickler.liftedExpr")
   def Unpickler_unpickleType = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleType")
 
+  lazy val TastyContextModule = ctx.requiredModule("scala.tasty.Context")
+  def TastyContextModuleClass(implicit ctx: Context) = TastyContextModule.symbol.asClass
+
+    lazy val TastyContext_compilationContextR = TastyContextModule.requiredMethod("compilationContext")
+    def TastyContext_compilationContext(implicit ctx: Context) = TastyContext_compilationContextR.symbol
+
   lazy val EqType = ctx.requiredClassRef("scala.Eq")
   def EqClass(implicit ctx: Context) = EqType.symbol.asClass
   def EqModule(implicit ctx: Context) = EqClass.companionModule

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

@@ -39,7 +39,7 @@ object PickledQuotes {
     case expr: LiftedExpr[T] =>
       expr.value match {
         case value: Class[_] => ref(defn.Predef_classOf).appliedToType(classToType(value))
-        case value=> Literal(Constant(value))
+        case value => Literal(Constant(value))
       }
     case expr: TreeExpr[Tree] @unchecked => expr.tree
     case expr: FunctionAppliedTo[_, _] =>
@@ -50,7 +50,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[Tree] @unchecked => expr.typeTree
   }
 
   /** Unpickle the tree contained in the TastyExpr */

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

@@ -1142,7 +1142,10 @@ class TreeUnpickler(reader: TastyReader,
       val idx = readNat()
       val args = until(end)(readTerm())
       val splice = splices(idx)
-      val reifiedArgs = args.map(arg => if (arg.isTerm) new TreeExpr(arg) else new TreeType(arg))
+      def wrap(arg: Tree) =
+        if (arg.isTerm) new TreeExpr(arg)
+        else new TreeType(arg)
+      val reifiedArgs = args.map(wrap)
       if (isType) {
         val quotedType = splice.asInstanceOf[Seq[Any] => quoted.Type[_]](reifiedArgs)
         PickledQuotes.quotedTypeToTree(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,14 +1,18 @@
 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.Context
 import dotty.tools.dotc.printing.RefinedPrinter
+import dotty.tools.dotc.tasty.internal
+import dotty.tools.dotc.tasty.internal.TastyContext
 
-import scala.quoted.Expr
+import scala.quoted.{Expr, Type}
+import scala.quoted.Exprs.{LiftedExpr, TreeExpr}
+import scala.quoted.Types.TreeType
 import scala.runtime.BoxedUnit
-import scala.quoted.Exprs.LiftedExpr
 import scala.runtime.quoted._
+import scala.tasty.trees
 
 /** Default runners for quoted expressions */
 object Toolbox {
@@ -42,19 +46,6 @@ object Toolbox {
       case _ => new QuoteDriver().show(expr, showSettings)
     }
 
-    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: LiftedExpr[T] => Some(expr.value)
-        case _ => new QuoteDriver().withTree(expr, (tree, _) => toConstantOpt(tree), 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/AnnotationModifier.scala

@@ -0,0 +1,20 @@
+package dotty.tools.dotc.tasty
+package internal
+
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Annotations.Annotation
+
+import scala.tasty.modifiers
+
+object AnnotationModifier {
+
+  def apply(tree: Annotation): modifiers.Annotation = new Impl(tree)
+
+  def unapplyAnnotation(arg: Impl)(implicit ctx: Context): Option[modifiers.Annotation.Data] = {
+    Some(Term(arg.annot.tree))
+  }
+
+  private[tasty] class Impl(val annot: Annotation) extends modifiers.Annotation {
+    override def toString: String = "Annotation"
+  }
+}

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

@@ -0,0 +1,22 @@
+package dotty.tools.dotc.tasty
+package internal
+
+import dotty.tools.dotc.ast.Trees
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts.Context
+
+import scala.tasty.trees
+
+object CaseDef {
+
+  def apply(tree: tpd.CaseDef): trees.CaseDef = new Impl(tree)
+
+  def unapplyCaseDef(arg: Impl)(implicit ctx: Context): Option[trees.CaseDef.Data] = {
+    val Trees.CaseDef(pat, guard, body) = arg.tree
+    Some(Pattern(pat), if (guard.isEmpty) None else Some(Term(guard)), Term(body))
+  }
+
+  private[tasty] class Impl(val tree: tpd.CaseDef) extends trees.CaseDef with Positioned {
+    override def toString: String = "CaseDef"
+  }
+}

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

@@ -0,0 +1,48 @@
+package dotty.tools.dotc.tasty
+package internal
+
+import dotty.tools.dotc.ast.{Trees, tpd}
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Symbols.ClassSymbol
+
+import scala.tasty.modifiers
+import scala.tasty.trees
+import scala.tasty.types
+
+object ClassDef {
+
+  def apply(tree: tpd.TypeDef): trees.ClassDef = new Impl(tree)
+
+  def apply(sym: ClassSymbol)(implicit ctx: Context): trees.ClassDef = {
+    def toTree(sym: ClassSymbol): tpd.TypeDef = {
+      val constr = tpd.DefDef(sym.unforcedDecls.find(_.isPrimaryConstructor).asTerm)
+      val body = sym.unforcedDecls.filter(!_.isPrimaryConstructor).map(s =>
+        if (s.isClass) toTree(s.asClass)
+        else if (s.isType) tpd.TypeDef(s.asType)
+        else if (s.is(Method)) tpd.DefDef(s.asTerm)
+        else tpd.ValDef(s.asTerm)
+      )
+      val superArgs = Nil // TODO
+      tpd.ClassDef(sym, constr, body, superArgs)
+    }
+    new Impl(toTree(sym))
+  }
+
+  def unapplyClassDef(arg: Impl)(implicit ctx: Context): Option[trees.ClassDef.Data] = {
+    val Trees.TypeDef(name, impl@Trees.Template(constr, parents, self, _)) = arg.tree
+    val className = TypeName(name)
+    val constructor = DefDef(constr)
+    val classParents = parents.map(p => if (!p.isType) Term(p) else TypeTree(p))
+    val selfVal = if (self.isEmpty) None else Some(ValDef(self))
+    val body = impl.body.map(Statement(_))
+    Some((className, constructor, classParents, selfVal, body))
+  }
+
+  private[tasty] class Impl(val tree: tpd.TypeDef) extends trees.ClassDef with Definition with Positioned {
+    def tpe: types.Type = Type(tree.tpe)
+    def mods(implicit ctx: scala.tasty.Context): List[modifiers.Modifier] = Modifiers(tree)
+    override def toString: String = "ClassDef"
+  }
+
+}

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

@@ -0,0 +1,58 @@
+package dotty.tools.dotc.tasty
+package internal
+
+import dotty.tools.dotc.core.Constants
+
+import scala.tasty.constants
+
+object Constant {
+
+  def apply(constant: Constants.Constant): constants.Constant = new Impl(constant)
+
+  def unapplyUnit(arg: Impl): Boolean = arg.const.tag == Constants.UnitTag
+
+  def unapplyNull(arg: Impl): Boolean = arg.const.tag == Constants.NullTag
+
+  def unapplyBoolean(arg: Impl): Option[Boolean] =
+    if (arg.const.tag == Constants.BooleanTag) Some(arg.const.booleanValue)
+    else None
+
+  def unapplyByte(arg: Impl): Option[Byte] =
+    if (arg.const.tag == Constants.ByteTag) Some(arg.const.byteValue)
+    else None
+
+  def unapplyChar(arg: Impl): Option[Char] =
+    if (arg.const.tag == Constants.CharTag) Some(arg.const.charValue)
+    else None
+
+  def unapplyShort(arg: Impl): Option[Short] =
+    if (arg.const.tag == Constants.ShortTag) Some(arg.const.shortValue)
+    else None
+
+  def unapplyInt(arg: Impl): Option[Int] =
+    if (arg.const.tag == Constants.IntTag) Some(arg.const.intValue)
+    else None
+
+  def unapplyLong(arg: Impl): Option[Long] =
+    if (arg.const.tag == Constants.LongTag) Some(arg.const.longValue)
+    else None
+
+  def unapplyFloat(arg: Impl): Option[Float] =
+    if (arg.const.tag == Constants.FloatTag) Some(arg.const.floatValue)
+    else None
+
+  def unapplyDouble(arg: Impl): Option[Double] =
+    if (arg.const.tag == Constants.DoubleTag) Some(arg.const.doubleValue)
+    else None
+
+  def unapplyString(arg: Impl): Option[String] =
+    if (arg.const.tag == Constants.StringTag) Some(arg.const.stringValue)
+    else None
+
+  private[tasty] class Impl(val const: Constants.Constant) extends constants.Constant {
+
+    def value: Any = const.value
+
+    override def toString: String = "Constant"
+  }
+}

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

@@ -0,0 +1,29 @@
+package dotty.tools.dotc.tasty
+package internal
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Symbols.TermSymbol
+
+import scala.tasty.modifiers
+import scala.tasty.trees
+import scala.tasty.types
+
+object DefDef {
+
+  def apply(tree: tpd.DefDef): trees.DefDef = new Impl(tree)
+
+  def apply(sym: TermSymbol)(implicit ctx: Context): trees.DefDef = new Impl(tpd.DefDef(sym))
+
+  def unapplyDefDef(arg: Impl)(implicit ctx: Context): Option[trees.DefDef.Data] = {
+    val ddef = arg.tree
+    Some((TermName(ddef.name), ddef.tparams.map(TypeDef(_)), ddef.vparamss.map(_.map(ValDef(_))), TypeTree(ddef.tpt), if (ddef.rhs.isEmpty) None else Some(Term(ddef.rhs))))
+  }
+
+  private[tasty] class Impl(val tree: tpd.DefDef) extends trees.DefDef with Definition with Positioned {
+    def tpe: types.Type = Type(tree.tpe)
+    def mods(implicit ctx: scala.tasty.Context): List[modifiers.Modifier] = Modifiers(tree)
+    override def toString: String = "DefDef"
+  }
+
+}