Rename.

Author: adampauls

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -3,8 +3,8 @@ package dotc
 
 import core._
 import Contexts._
-import typer.{FrontEnd, RefChecks}
-import parsing.Parsing
+import typer.{TyperPhase, RefChecks}
+import parsing.Parser
 import Phases.Phase
 import transform._
 import dotty.tools.backend.jvm.{CollectSuperCalls, GenBCode}
@@ -37,8 +37,8 @@ class Compiler {
 
   /** Phases dealing with the frontend up to trees ready for TASTY pickling */
   protected def frontendPhases: List[List[Phase]] =
-    List(new Parsing) ::             // Compiler frontend: scanner, parser
-    List(new FrontEnd) ::           // Compiler frontend: namer, typer
+    List(new Parser) ::             // Compiler frontend: scanner, parser
+    List(new TyperPhase) ::         // Compiler frontend: namer, typer
     List(new YCheckPositions) ::    // YCheck positions
     List(new sbt.ExtractDependencies) :: // Sends information on classes' dependencies to sbt via callbacks
     List(new semanticdb.ExtractSemanticDB) :: // Extract info into .semanticdb files

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -7,7 +7,7 @@ import util.Spans._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags
 import Symbols._, StdNames._, Trees._, Phases._, ContextOps._
 import Decorators._, transform.SymUtils._
 import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName}
-import typer.{FrontEnd, Namer, Checking}
+import typer.{TyperPhase, Namer, Checking}
 import util.{Property, SourceFile, SourcePosition}
 import config.Feature.{sourceVersion, migrateTo3, enabled}
 import config.SourceVersion._
@@ -1412,7 +1412,7 @@ object desugar {
   def makeAnnotated(fullName: String, tree: Tree)(using Context): Annotated = {
     val parts = fullName.split('.')
     val ttree = typerPhase match {
-      case phase: FrontEnd if phase.stillToBeEntered(parts.last) =>
+      case phase: TyperPhase if phase.stillToBeEntered(parts.last) =>
         val prefix =
           parts.init.foldLeft(Ident(nme.ROOTPKG): Tree)((qual, name) =>
             Select(qual, name.toTermName))

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

@@ -388,7 +388,7 @@ object Contexts {
       // to be used as a default value.
       compilationUnit != null && compilationUnit.isJava
 
-    /** Is current phase after FrontEnd? */
+    /** Is current phase after TyperPhase? */
     final def isAfterTyper = base.isAfterTyper(phase)
     final def isTyper = base.isTyper(phase)
 

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

@@ -14,11 +14,11 @@ import dotty.tools.dotc.core.Decorators.*
 import dotty.tools.dotc.core.DenotTransformers.*
 import dotty.tools.dotc.core.Denotations.*
 import dotty.tools.dotc.core.Periods.*
-import dotty.tools.dotc.parsing.Parsing
+import dotty.tools.dotc.parsing.Parser
 import dotty.tools.dotc.transform.*
 import dotty.tools.dotc.transform.MegaPhase.*
 import dotty.tools.dotc.typer.ImportInfo.withRootImports
-import dotty.tools.dotc.typer.{ FrontEnd, RefChecks }
+import dotty.tools.dotc.typer.{ TyperPhase, RefChecks }
 
 object Phases {
 
@@ -242,8 +242,8 @@ object Phases {
     private def setSpecificPhases() = {
       def phaseOfClass(pclass: Class[?]) = phases.find(pclass.isInstance).getOrElse(NoPhase)
 
-      myParserPhase = phaseOfClass(classOf[Parsing])
-      myTyperPhase = phaseOfClass(classOf[FrontEnd])
+      myParserPhase = phaseOfClass(classOf[Parser])
+      myTyperPhase = phaseOfClass(classOf[TyperPhase])
       myPostTyperPhase = phaseOfClass(classOf[PostTyper])
       mySbtExtractDependenciesPhase = phaseOfClass(classOf[sbt.ExtractDependencies])
       myPicklerPhase = phaseOfClass(classOf[Pickler])
@@ -318,8 +318,8 @@ object Phases {
      */
     def checkPostCondition(tree: tpd.Tree)(using Context): Unit = ()
 
-    /** Is this phase the standard typerphase? True for FrontEnd, but
-     *  not for other first phases (such as FromTasty). The predicate
+    /** Is this phase the standard typerphase? True for TyperPhase, but
+     *  not for other first phases (such as FromTasty or Parser). The predicate
      *  is tested in some places that perform checks and corrections. It's
      *  different from ctx.isAfterTyper (and cheaper to test).
      */

compiler/src/dotty/tools/dotc/interactive/InteractiveCompiler.scala

@@ -13,8 +13,8 @@ class InteractiveCompiler extends Compiler {
   // This could be improved by reporting errors back to the IDE
   // after each phase group instead of waiting for the pipeline to finish.
   override def phases: List[List[Phase]] = List(
-    List(new Parsing),
-    List(new FrontEnd),
+    List(new Parser),
+    List(new TyperPhase),
     List(new transform.SetRootTree),
     List(new transform.CookComments)
   )

compiler/src/dotty/tools/dotc/parsing/Parsing.scala renamed to compiler/src/dotty/tools/dotc/parsing/ParserPhase.scala

@@ -6,26 +6,19 @@ import dotty.tools.dotc.config.Printers.{ default, typr }
 import dotty.tools.dotc.core.Contexts.{ Context, ctx }
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.Symbols.defn
-import dotty.tools.dotc.parsing.JavaParsers.JavaParser
-import dotty.tools.dotc.parsing.Parsers.Parser
 import dotty.tools.dotc.typer.ImportInfo.withRootImports
 import dotty.tools.dotc.{ CompilationUnit, ast, report }
 import dotty.tools.dotc.util.{ NoSourcePosition, SourcePosition }
 import dotty.tools.dotc.util.Stats.record
 import dotty.tools.unsupported
 
-class Parsing extends Phase {
+class Parser extends Phase {
 
   override def phaseName: String = "parsing"
 
   // We run TreeChecker only after type checking
   override def isCheckable: Boolean = false
 
-  // TODO bad right?
-  //override def allowsImplicitSearch: Boolean = false
-  // TODO bad right?
-  //override def isTyper: Boolean = true
-
   override def isRunnable(implicit ctx: Context): Boolean = true
 
   /** The position of the first XML literal encountered while parsing,
@@ -36,9 +29,9 @@ class Parsing extends Phase {
   def parse(using Context) = monitor("parsing") {
     val unit = ctx.compilationUnit
     unit.untpdTree =
-      if (unit.isJava) new JavaParser(unit.source).parse()
+      if (unit.isJava) new JavaParsers.JavaParser(unit.source).parse()
       else {
-        val p = new Parser(unit.source)
+        val p = new Parsers.Parser(unit.source)
         //  p.in.debugTokenStream = true
         val tree = p.parse()
         if (p.firstXmlPos.exists && !firstXmlPos.exists)

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

@@ -24,8 +24,6 @@ object Pickler {
    *  only in backend.
    */
   inline val ParallelPickling = true
-
-  private val counter = new java.util.concurrent.atomic.AtomicLong(0L)
 }
 
 /** This phase pickles trees */

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

@@ -795,7 +795,7 @@ trait Checking {
   private def checkLegalImportOrExportPath(path: Tree, kind: String)(using Context): Unit = {
     checkStable(path.tpe, path.srcPos, kind)
     if (!ctx.isAfterTyper) Checking.checkRealizable(path.tpe, path.srcPos)
-    if ((ctx.phase.isTyper && ctx.phase.isCheckable) || ctx.isAfterTyper) && !isIdempotentExpr(path) then
+    if ctx.phase.isCheckable && !isIdempotentExpr(path) then
       report.error(em"import prefix is not a pure expression", path.srcPos)
   }
 

compiler/src/dotty/tools/dotc/typer/FrontEnd.scala renamed to compiler/src/dotty/tools/dotc/typer/TyperPhase.scala

@@ -10,17 +10,17 @@ import Decorators._
 import ImportInfo.withRootImports
 import parsing.JavaParsers.JavaParser
 import parsing.Parsers.Parser
-import parsing.Parsing
+import parsing.{Parser => ParserPhase}
 import config.Config
 import config.Printers.{typr, default}
 import util.Stats._
 import util.{ SourcePosition, NoSourcePosition }
 import scala.util.control.NonFatal
 import ast.Trees._
 
-class FrontEnd extends Phase {
+class TyperPhase extends Phase {
 
-  override def phaseName: String = FrontEnd.name
+  override def phaseName: String = TyperPhase.name
   override def isTyper: Boolean = true
   import ast.tpd
 
@@ -86,7 +86,7 @@ class FrontEnd extends Phase {
       enterSyms(using remaining.head)
       remaining = remaining.tail
     val firstXmlPos = ctx.base.parserPhase match {
-      case p: Parsing =>
+      case p: ParserPhase =>
         if p.firstXmlPos.exists && !defn.ScalaXmlPackageClass.exists then
           report.error(
             """To support XML literals, your project must depend on scala-xml.
@@ -111,6 +111,6 @@ class FrontEnd extends Phase {
   def run(using Context): Unit = unsupported("run")
 }
 
-object FrontEnd {
+object TyperPhase {
   val name: String = "typer"
 }

compiler/src/dotty/tools/repl/ReplCompiler.scala

@@ -14,7 +14,7 @@ import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.reporting.Diagnostic
 import dotty.tools.dotc.transform.{PostTyper, Staging}
 import dotty.tools.dotc.typer.ImportInfo._
-import dotty.tools.dotc.typer.FrontEnd
+import dotty.tools.dotc.typer.TyperPhase
 import dotty.tools.dotc.util.Spans._
 import dotty.tools.dotc.util.{ParsedComment, SourceFile}
 import dotty.tools.dotc.{CompilationUnit, Compiler, Run}
@@ -33,7 +33,7 @@ import scala.collection.mutable
 class ReplCompiler extends Compiler {
 
   override protected def frontendPhases: List[List[Phase]] = List(
-    List(new FrontEnd),
+    List(new TyperPhase),
     List(new CollectTopLevelImports),
     List(new PostTyper),
   )

docs/docs/contributing/testing.md

@@ -169,4 +169,5 @@ control.
 
 Some of the tests depend on temporary state stored in the `out` directory. In rare cases, that directory
 can enter an inconsistent state and cause spurious test failures. If you suspect a spurious test failure,
-you can run `rm -rf out/*` from the root of the repository and run your tests again.
+you can run `rm -rf out/*` from the root of the repository and run your tests again. If that fails, you
+can try `git clean -xfd`.

docs/docs/internals/overall-structure.md

@@ -97,7 +97,8 @@ phases. The current list of phases is specified in class [Compiler] as follows:
 
   /** Phases dealing with the frontend up to trees ready for TASTY pickling */
   protected def frontendPhases: List[List[Phase]] =
-    List(new FrontEnd) ::           // Compiler frontend: scanner, parser, namer, typer
+    List(new Parser) ::             // scanner, parser, namer, typer
+    List(new TyperPhase) ::         // namer, typer
     List(new YCheckPositions) ::    // YCheck positions
     List(new sbt.ExtractDependencies) :: // Sends information on classes' dependencies to sbt via callbacks
     List(new semanticdb.ExtractSemanticDB) :: // Extract info into .semanticdb files