Allow phases to give restrictions on pipeline position.

Phases can now specify which phases should it follow.
Tree transforms can additionally specify which TreeTransforms
should have finished their processing of compilation units entirely.

Author: DarkDimius

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

@@ -74,12 +74,24 @@ object Phases {
       */
     private def squashPhases(phasess: List[List[Phase]]): Array[Phase] = {
       val squashedPhases = ListBuffer[Phase]()
+      var prevPhases: Set[String] = Set.empty
       var postTyperEmmited = false
       var i = 0
       while (i < phasess.length) {
         if (phasess(i).length > 1) {
-          assert(phasess(i).forall(x => x.isInstanceOf[TreeTransform]), "Only tree transforms can be squashed")
+          val phasesInBlock: Set[String] = phasess(i).map(_.name).toSet
+          for(phase<-phasess(i)) {
+            phase match {
+              case p: TreeTransform =>
 
+                val unmetRequirements = p.runsAfterGroupsOf &~ prevPhases
+                assert(unmetRequirements.isEmpty,
+                  s"${phase.name} requires ${unmetRequirements.mkString(", ")} to be in different TreeTransformer")
+
+              case _ =>
+                assert(false, s"Only tree transforms can be squashed, ${phase.name} can not be squashed")
+            }
+          }
           val transforms = phasess(i).asInstanceOf[List[TreeTransform]]
           val block =
             if (!postTyperEmmited) {
@@ -93,6 +105,7 @@ object Phases {
               override def transformations: Array[TreeTransform] = transforms.toArray
             }
           squashedPhases += block
+          prevPhases ++= phasess(i).map(_.name)
           block.init(this, phasess(i).head.id, phasess(i).last.id)
         } else squashedPhases += phasess(i).head
         i += 1
@@ -106,11 +119,16 @@ object Phases {
      */
     def usePhases(phasess: List[List[Phase]], squash: Boolean = true) = {
       phases = (NoPhase :: phasess.flatten ::: new TerminalPhase :: Nil).toArray
+      var phasesAfter:Set[String] = Set.empty
       nextDenotTransformerId = new Array[Int](phases.length)
       denotTransformers = new Array[DenotTransformer](phases.length)
       var i = 0
       while (i < phases.length) {
         phases(i).init(this, i)
+        val unmetPreceedeRequirements = phases(i).runsAfter -- phasesAfter
+        assert(unmetPreceedeRequirements.isEmpty,
+          s"phase ${phases(i)} has unmet requirement: ${unmetPreceedeRequirements.mkString(", ")} should precede this phase")
+        phasesAfter += phases(i).name
         i += 1
       }
       var lastTransformerId = i
@@ -170,6 +188,9 @@ object Phases {
 
     def name: String
 
+    /** List of names of phases that should precede this phase */
+    def runsAfter: Set[String] = Set.empty
+
     def run(implicit ctx: Context): Unit
 
     def runOn(units: List[CompilationUnit])(implicit ctx: Context): Unit =

src/dotty/tools/dotc/transform/Erasure.scala

@@ -25,6 +25,9 @@ class Erasure extends Phase with DenotTransformer {
 
   override def name: String = "erasure"
 
+  /** List of names of phases that should precede this phase */
+  override def runsAfter: Set[String] = Set("typeTestsCasts", "intercepted", "splitter")
+
   def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = ref match {
     case ref: SymDenotation =>
       assert(ctx.phase == this, s"transforming $ref at ${ctx.phase}")

src/dotty/tools/dotc/transform/LazyVals.scala

@@ -63,6 +63,17 @@ class LazyValTranformContext {
 
     override def name: String = "LazyVals"
 
+    /** List of names of phases that should have finished their processing of all compilation units
+      * before this phase starts */
+    override def runsAfterGroupsOf: Set[String] = Set("lazyValsModules")
+    /** List of names of phases that should have finished their processing of all compilation units
+      * before this phase starts */
+    override def runsAfter: Set[String] = Set("lazyValsModules")
+
+    /** List of names of phases that should have finished processing of tree
+      * before this phase starts processing same tree */
+    // override def ensureAfter: Set[String] = Set("mixin")
+
     def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = {
       ref match {
         case ref: SymDenotation if ref.symbol.isClass =>

src/dotty/tools/dotc/transform/TreeTransform.scala

@@ -51,6 +51,10 @@ object TreeTransforms {
     /** id of this treeTransform in group */
     var idx: Int = _
 
+    /** List of names of phases that should have finished their processing of all compilation units
+      * before this phase starts */
+    def runsAfterGroupsOf: Set[String] = Set.empty
+
     def prepareForIdent(tree: Ident)(implicit ctx: Context) = this
     def prepareForSelect(tree: Select)(implicit ctx: Context) = this
     def prepareForThis(tree: This)(implicit ctx: Context) = this