wip

Author: nicolasstucki

compiler/src/dotty/tools/dotc/decompiler/DecompilationPrinter.scala

@@ -0,0 +1,50 @@
+package dotty.tools.dotc
+package decompiler
+
+import java.io.{OutputStream, PrintStream}
+
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.dotc.core.tasty.TastyPrinter
+import dotty.tools.dotc.printing.DecompilerPrinter
+import dotty.tools.dotc.tasty.TastyImpl
+import dotty.tools.io.{File, Path}
+
+/** Phase that prints the trees in all loaded compilation units.
+ *
+ *  @author Nicolas Stucki
+ */
+class DecompilationPrinter extends Phase {
+
+  override def phaseName: String = "decompilationPrinter"
+
+  override def run(implicit ctx: Context): Unit = {
+    val outputDir = ctx.settings.outputDir.value
+    if (outputDir == ".") printToOutput(System.out)
+    else {
+      var os: OutputStream = null
+      var ps: PrintStream = null
+      try {
+        os = File(outputDir + "/decompiled.scala").outputStream(append = true)
+        ps = new PrintStream(os)
+        printToOutput(ps)
+      } finally {
+        if (os ne null) os.close()
+        if (ps ne null) ps.close()
+      }
+    }
+  }
+
+  private def printToOutput(out: PrintStream)(implicit ctx: Context): Unit = {
+    val unit = ctx.compilationUnit
+
+    out.println(s"/** Decompiled from $unit */")
+    TastyImpl.showSourceCode.showTree(unit.tpdTree)(ctx)
+
+    if (ctx.settings.printTasty.value) {
+      out.println("/*")
+      new TastyPrinter(unit.pickled.head._2).printContents()
+      out.println("*/")
+    }
+  }
+}

compiler/src/dotty/tools/dotc/decompiler/Main.scala

@@ -15,12 +15,7 @@ object Main extends dotc.Driver {
     val outputDir = ctx.settings.outputDir.value
     if (outputDir != ".")
       Files.deleteIfExists(Paths.get(outputDir + "/decompiled.scala"))
-    new TASTYDecompiler(
-      ctx.settings.pageWidth.value,
-      ctx.settings.printLines.value,
-      ctx.settings.printTasty.value,
-      outputDir
-    )
+    new TASTYDecompiler
   }
 
   override def setup(args0: Array[String], rootCtx: Context): (List[String], Context) = {

compiler/src/dotty/tools/dotc/decompiler/TASTYDecompiler.scala

@@ -1,48 +1,23 @@
 package dotty.tools.dotc.decompiler
 
-import java.io.{OutputStream, PrintStream}
-
-import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.core.Contexts
-import dotty.tools.dotc.core.Contexts.Context
-import dotty.tools.dotc.core.tasty.TastyPrinter
-import dotty.tools.dotc.printing.DecompilerPrinter
-import dotty.tools.dotc.tasty.{TASTYReflector, TastyImpl}
-import dotty.tools.io.File
+import dotty.tools.dotc.fromtasty._
+import dotty.tools.dotc.core.Phases.Phase
 
 /** Compiler from tasty to user readable high text representation
  *  of the compiled scala code.
  *
  * @author Nicolas Stucki
  */
-class TASTYDecompiler(pageWidth: Int, printLines: Boolean, printTasty: Boolean, outputDir: String) extends TASTYReflector {
-
-  override def reflect(tree: tpd.Tree)(implicit ctx: Contexts.Context): Unit = {
-    if (outputDir == ".") printToOutput(System.out, tree)
-    else {
-      var os: OutputStream = null
-      var ps: PrintStream = null
-      try {
-        os = File(outputDir + "/decompiled.scala").outputStream(append = true)
-        ps = new PrintStream(os)
-        printToOutput(ps, tree)
-      } finally {
-        if (os ne null) os.close()
-        if (ps ne null) ps.close()
-      }
-    }
-  }
+class TASTYDecompiler extends TASTYCompiler {
 
-  private def printToOutput(out: PrintStream, tree: tpd.Tree)(implicit ctx: Context): Unit = {
-    val unit = ctx.compilationUnit
+  override protected def frontendPhases: List[List[Phase]] =
+    List(new ReadTastyTreesFromClasses) :: // Load classes from tasty
+    Nil
 
-    out.println(s"/** Decompiled from $unit */")
-    out.print(TastyImpl.showSourceCode.showTree(tree))
+  override protected def picklerPhases: List[List[Phase]] = Nil
+  override protected def transformPhases: List[List[Phase]] = Nil
 
-    if (printTasty) { // TODO split decompiler from -print-tasty
-      out.println("/*")
-      new TastyPrinter(unit.pickled.head._2).printContents()
-      out.println("*/")
-    }
-  }
+  override protected def backendPhases: List[List[Phase]] =
+    List(new DecompilationPrinter) ::  // Print all loaded classes
+    Nil
 }

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

@@ -0,0 +1,107 @@
+package dotty.tools.dotc
+package quoted
+
+import dotty.tools.backend.jvm.GenBCode
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Mode
+import dotty.tools.dotc.core.Names.TypeName
+import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.dotc.core.Scopes.{EmptyScope, newScope}
+import dotty.tools.dotc.core.StdNames.nme
+import dotty.tools.dotc.core.Symbols.defn
+import dotty.tools.dotc.core.Types.ExprType
+import dotty.tools.dotc.core.quoted.PickledQuotes
+import dotty.tools.dotc.transform.ReifyQuotes
+import dotty.tools.dotc.typer.FrontEnd
+import dotty.tools.dotc.util.Positions.Position
+import dotty.tools.dotc.util.SourceFile
+import dotty.tools.io.{AbstractFile, Path, PlainFile}
+
+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 QuoteCompiler(directory: AbstractFile) extends Compiler {
+  import tpd._
+
+  /** A GenBCode phase that outputs to a virtual directory */
+  private class ExprGenBCode extends GenBCode {
+    override def phaseName = "genBCode"
+    override def outputDir(implicit ctx: Context) = directory
+  }
+
+  override protected def frontendPhases: List[List[Phase]] =
+    List(List(new QuotedFrontend(putInClass = true)))
+
+  override protected def picklerPhases: List[List[Phase]] =
+    List(List(new ReifyQuotes))
+
+  override protected def backendPhases: List[List[Phase]] =
+    List(List(new ExprGenBCode))
+
+  override def newRun(implicit ctx: Context): ExprRun = {
+    reset()
+    new ExprRun(this, ctx.addMode(Mode.ReadPositions))
+  }
+
+  def outputClassName: TypeName = "Quoted".toTypeName
+
+  /** 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
+
+    override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] = {
+      units.map {
+        case exprUnit: ExprCompilationUnit =>
+          val tree =
+            if (putInClass) inClass(exprUnit.expr)
+            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)
+      }
+    }
+
+    /** Places the contents of expr in a compilable tree for a class
+      *  with the following format.
+      *  `package __root__ { class ' { def apply: Any = <expr> } }`
+      */
+    private def inClass(expr: Expr[_])(implicit ctx: Context): Tree = {
+      val pos = Position(0)
+      val assocFile = new PlainFile(Path("<quote>"))
+
+      val cls = ctx.newCompleteClassSymbol(defn.RootClass, outputClassName, EmptyFlags,
+        defn.ObjectType :: Nil, newScope, coord = pos, assocFile = assocFile).entered.asClass
+      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 run = DefDef(meth, quoted)
+      val classTree = ClassDef(cls, DefDef(cls.primaryConstructor.asTerm), run :: Nil)
+      PackageDef(ref(defn.RootPackage).asInstanceOf[Ident], classTree :: Nil).withPos(pos)
+    }
+  }
+
+  class ExprRun(comp: Compiler, ictx: Context) extends Run(comp, ictx) {
+    def compileExpr(expr: Expr[_]): Unit = {
+      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/ExprCompiler.scala

@@ -0,0 +1,18 @@
+package dotty.tools.dotc.quoted
+
+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 (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 QuotedFrontend(putInClass = false)), // Create class from Expr
+    List(new QuoteTreeOutput(output))
+  )
+
+  class QuoteTreeOutput(output: tpd.Tree => Context => Unit) extends Phase {
+    override def phaseName: String = "quoteOutput"
+    override def run(implicit ctx: Context): Unit = output(ctx.compilationUnit.tpdTree)(ctx)
+  }
+}