Use -from-tasty flag to enable/disable some phases

Also some classes were extending FrontEnd when they only needed to
extends Phase

Author: allanrenucci

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

@@ -262,7 +262,7 @@ object Phases {
     final def isAfterTyper(phase: Phase): Boolean = phase.id > typerPhase.id
   }
 
-  trait Phase {
+  abstract class Phase {
 
     /** A name given to the `Phase` that can be used to debug the compiler. For
      *  instance, it is possible to print trees after a given phase using:

compiler/src/dotty/tools/dotc/fromtasty/ReadTastyTreesFromClasses.scala

@@ -7,14 +7,17 @@ import Decorators._
 import Contexts.Context
 import Symbols.{Symbol, ClassSymbol}
 import SymDenotations.ClassDenotation
-import typer.FrontEnd
 import NameOps._
 import ast.Trees.Tree
 import CompilationUnit.mkCompilationUnit
+import Phases.Phase
 
-class ReadTastyTreesFromClasses extends FrontEnd {
+class ReadTastyTreesFromClasses extends Phase {
 
-  override def isTyper: Boolean = false
+  def phaseName: String = "tastyFrontend"
+
+  override def isRunnable(implicit ctx: Context): Boolean =
+    ctx.settings.fromTasty.value
 
   override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] =
     units.flatMap(readTASTY(_)(ctx.addMode(Mode.ReadPositions)))
@@ -71,4 +74,6 @@ class ReadTastyTreesFromClasses extends FrontEnd {
     case unit =>
      Some(unit)
   }
+
+  def run(implicit ctx: Context): Unit = unsupported("run")
 }

compiler/src/dotty/tools/dotc/fromtasty/TASTYCompiler.scala

@@ -12,9 +12,6 @@ class TASTYCompiler extends Compiler {
   override protected def frontendPhases: List[List[Phase]] =
     List(new ReadTastyTreesFromClasses) :: Nil
 
-  override protected def picklerPhases: List[List[Phase]] =
-    super.picklerPhases.map(_.filterNot(_.isInstanceOf[Pickler])) // No need to repickle
-
   override def newRun(implicit ctx: Context): Run = {
     reset()
     new TASTYRun(this, ctx.addMode(Mode.ReadPositions))

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

@@ -1,4 +1,5 @@
-package dotty.tools.dotc
+package dotty.tools
+package dotc
 package quoted
 
 import dotty.tools.dotc.ast.tpd
@@ -14,7 +15,6 @@ 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.Staging
-import dotty.tools.dotc.typer.FrontEnd
 import dotty.tools.dotc.util.Positions.Position
 import dotty.tools.dotc.util.SourceFile
 import dotty.tools.io.{Path, VirtualFile}
@@ -40,10 +40,10 @@ class QuoteCompiler extends Compiler {
   def outputClassName: TypeName = "Quoted".toTypeName
 
   /** Frontend that receives a scala.quoted.Expr or scala.quoted.Type as input */
-  class QuotedFrontend(putInClass: Boolean) extends FrontEnd {
+  class QuotedFrontend(putInClass: Boolean) extends Phase {
     import tpd._
 
-    override def isTyper: Boolean = false
+    def phaseName: String = "quoteFrontend"
 
     override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] = {
       units.map {
@@ -80,6 +80,8 @@ class QuoteCompiler extends Compiler {
       val classTree = ClassDef(cls, DefDef(cls.primaryConstructor.asTerm), run :: Nil)
       PackageDef(ref(defn.RootPackage).asInstanceOf[Ident], classTree :: Nil).withPos(pos)
     }
+
+    def run(implicit ctx: Context): Unit = unsupported("run")
   }
 
   class ExprRun(comp: Compiler, ictx: Context) extends Run(comp, ictx) {
@@ -92,5 +94,4 @@ class QuoteCompiler extends Compiler {
       compileUnits(units)
     }
   }
-
 }

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

@@ -24,6 +24,10 @@ class Pickler extends Phase {
 
   override def phaseName: String = Pickler.name
 
+  // No need to repickle trees comming from TASTY
+  override def isRunnable(implicit ctx: Context): Boolean =
+    super.isRunnable && !ctx.settings.fromTasty.value
+
   private def output(name: String, msg: String) = {
     val s = new PrintStream(name)
     s.print(msg)

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

@@ -90,7 +90,7 @@ class TreeChecker extends Phase with SymTransformer {
   def run(implicit ctx: Context): Unit = {
     if (ctx.settings.YtestPickler.value && ctx.phase.prev.isInstanceOf[Pickler])
       ctx.echo("Skipping Ycheck after pickling with -Ytest-pickler, the returned tree contains stale symbols")
-    else
+    else if (ctx.phase.prev.isCheckable)
       check(ctx.base.allPhases, ctx)
   }
 

compiler/src/dotty/tools/dotc/typer/FrontEnd.scala

@@ -1,4 +1,5 @@
-package dotty.tools.dotc
+package dotty.tools
+package dotc
 package typer
 
 import core._
@@ -90,11 +91,7 @@ class FrontEnd extends Phase {
     unitContexts.map(_.compilationUnit).filterNot(discardAfterTyper)
   }
 
-  override def run(implicit ctx: Context): Unit = {
-    parse
-    enterSyms
-    typeCheck
-  }
+  def run(implicit ctx: Context): Unit = unsupported("run")
 }
 
 object FrontEnd {

doc-tool/src/dotty/tools/dottydoc/DocCompiler.scala

@@ -6,7 +6,8 @@ import core.transform._
 import dotc.core.Contexts.Context
 import dotc.core.Phases.Phase
 import dotc.core.Mode
-import dotc.{Compiler, Run}
+import dotc.{Compiler, CompilationUnit, Run}
+import dotc.typer.FrontEnd
 
 import dotty.tools.dotc.fromtasty.{ReadTastyTreesFromClasses, TASTYRun}
 import dotty.tools.dotc.transform.CookComments
@@ -29,36 +30,48 @@ class DocCompiler extends Compiler {
     if (ctx.settings.fromTasty.value) {
       reset()
       new TASTYRun(this, ctx.addMode(Mode.ReadPositions).addMode(Mode.ReadComments))
-    } else {
-      super.newRun
     }
+    else
+      super.newRun
   }
 
-  override protected def frontendPhases: List[List[Phase]] =
-    List(new ReadTastyTreesFromClasses) ::
-    List(new DocFrontEnd) ::  Nil
-
-  override protected def picklerPhases: List[List[Phase]] =
-    Nil
+  /** `DocFrontEnd` uses the Dotty `FrontEnd` without discarding the AnyVal
+   *  interfaces for Boolean, Int, Char, Long, Byte etc.
+   *
+   *  If `-from-tasty` is set, then the trees and documentation will be loaded
+   *  from TASTY. The comments will be cooked after being unpickled.
+   *
+   *  It currently still throws away Java sources by overriding
+   *  `discardAfterTyper`.
+   */
+  private class DocFrontEnd extends FrontEnd {
+    override protected def discardAfterTyper(unit: CompilationUnit)(implicit ctx: Context) =
+      unit.isJava
 
-  override protected def transformPhases: List[List[Phase]] =
-    List(new CookComments) ::
-    List(new DocImplicitsPhase) ::
-    List(new DocASTPhase) ::
-    List(DocMiniTransformations(new UsecasePhase,
-                                new DocstringPhase)) ::
-    List(DocMiniTransformations(new PackageObjectsPhase,
-                                new LinkReturnTypes,
-                                new LinkParamListTypes,
-                                new LinkImplicitlyAddedTypes,
-                                new LinkSuperTypes,
-                                new LinkCompanions,
-                                new AlternateConstructors,
-                                new SortMembers)) ::
-    List(DocMiniTransformations(new RemoveEmptyPackages)) ::
-    Nil
-
-  override protected def backendPhases: List[List[Phase]] =
-    List(new StatisticsPhase) :: Nil
+    override def isRunnable(implicit ctx: Context): Boolean =
+      super.isRunnable && !ctx.settings.fromTasty.value
+  }
 
+  override def phases: List[List[Phase]] = List(
+    List(new ReadTastyTreesFromClasses),
+    List(new DocFrontEnd),
+    List(new CookComments),
+    List(new DocImplicitsPhase),
+    List(new DocASTPhase),
+    List(DocMiniTransformations(
+      new UsecasePhase,
+      new DocstringPhase)),
+    List(DocMiniTransformations(
+      new PackageObjectsPhase,
+      new LinkReturnTypes,
+      new LinkParamListTypes,
+      new LinkImplicitlyAddedTypes,
+      new LinkSuperTypes,
+      new LinkCompanions,
+      new AlternateConstructors,
+      new SortMembers)),
+    List(DocMiniTransformations(
+      new RemoveEmptyPackages)),
+    List(new StatisticsPhase)
+  )
 }

doc-tool/src/dotty/tools/dottydoc/DocFrontEnd.scala

@@ -44,7 +44,7 @@ object transform {
    * -------------------------
    * To delete a node in the AST, simply return an empty list from transforming method
    */
-  trait DocMiniTransformations extends Phase {
+  abstract class DocMiniTransformations extends Phase {
     def transformations: List[DocMiniPhase]
 
     override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] = {

doc-tool/src/dotty/tools/dottydoc/core/transform.scala

@@ -45,10 +45,10 @@ trait DottyDocTest extends MessageRendering {
   implicit val ctx: FreshContext = freshCtx(Nil)
 
   private def compilerWithChecker(assertion: (Context, Map[String, Package]) => Unit) = new DocCompiler {
-    private[this] val assertionPhase: List[List[Phase]] =
-      List(new Phase {
+    override def phases = {
+      val assertionPhase = new Phase {
         def phaseName = "assertionPhase"
-        override def run(implicit ctx: Context): Unit =
+        override def run(implicit ctx: Context): Unit = {
           assertion(ctx, ctx.docbase.packages)
           if (ctx.reporter.hasErrors) {
             System.err.println("reporter had errors:")
@@ -58,10 +58,10 @@ trait DottyDocTest extends MessageRendering {
               }
             }
           }
-      }) :: Nil
-
-    override protected def backendPhases: List[List[Phase]] =
-      super.backendPhases ++ assertionPhase
+        }
+      }
+      super.phases :+ List(assertionPhase)
+    }
   }
 
   private def callingMethod: String =