use string names for runsAfter

Quote @sjrd:

For inter-plugin dependencies, it will be impossible for a plugin A to
get hold of the `Class[_]` value for a plugin B coming from a different
jar (hence in a different `ClassLoader`, so not even reflectively available).

#3438 (comment)

Author: liufengyun

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

@@ -82,7 +82,7 @@ object Phases {
     final def squashPhases(phasess: List[List[Phase]],
                              phasesToSkip: List[String], stopBeforePhases: List[String], stopAfterPhases: List[String], YCheckAfter: List[String]): List[Phase] = {
       val squashedPhases = ListBuffer[Phase]()
-      var prevPhases: Set[Class[_ <: Phase]] = Set.empty
+      var prevPhases: Set[String] = Set.empty
       val YCheckAll = YCheckAfter.contains("all")
 
       var stop = false
@@ -99,7 +99,6 @@ object Phases {
           val filteredPhaseBlock = filteredPhases(i)
           val phaseToAdd =
             if (filteredPhaseBlock.length > 1) {
-              val phasesInBlock: Set[String] = filteredPhaseBlock.map(_.phaseName).toSet
               for (phase <- filteredPhaseBlock) {
                 phase match {
                   case p: MiniPhase =>
@@ -112,11 +111,11 @@ object Phases {
                 }
               }
               val superPhase = new MegaPhase(filteredPhaseBlock.asInstanceOf[List[MiniPhase]].toArray)
-              prevPhases ++= filteredPhaseBlock.map(_.getClazz)
+              prevPhases ++= filteredPhaseBlock.map(_.phaseName)
               superPhase
             } else { // block of a single phase, no squashing
               val phase = filteredPhaseBlock.head
-              prevPhases += phase.getClazz
+              prevPhases += phase.phaseName
               phase
             }
           squashedPhases += phaseToAdd
@@ -147,7 +146,7 @@ object Phases {
 
       phases = (NoPhase :: flatPhases.toList ::: new TerminalPhase :: Nil).toArray
       setSpecificPhases()
-      var phasesAfter:Set[Class[_ <: Phase]] = Set.empty
+      var phasesAfter: Set[String] = Set.empty
       nextDenotTransformerId = new Array[Int](phases.length)
       denotTransformers = new Array[DenotTransformer](phases.length)
 
@@ -161,7 +160,7 @@ object Phases {
         val unmetPrecedeRequirements = p.runsAfter -- phasesAfter
         assert(unmetPrecedeRequirements.isEmpty,
           s"phase ${p} has unmet requirement: ${unmetPrecedeRequirements.mkString(", ")} should precede this phase")
-        phasesAfter += p.getClazz
+        phasesAfter += p.phaseName
 
       }
       var i = 0
@@ -281,7 +280,7 @@ object Phases {
     def allowsImplicitSearch: Boolean = false
 
      /** List of names of phases that should precede this phase */
-    def runsAfter: Set[Class[_ <: Phase]] = Set.empty
+    def runsAfter: Set[String] = Set.empty
 
     /** @pre `isRunnable` returns true */
     def run(implicit ctx: Context): Unit
@@ -393,12 +392,4 @@ object Phases {
   def replace(oldPhaseClass: Class[_ <: Phase], newPhases: Phase => List[Phase], current: List[List[Phase]]): List[List[Phase]] =
     current.map(_.flatMap(phase =>
       if (oldPhaseClass.isInstance(phase)) newPhases(phase) else phase :: Nil))
-
-  /** Dotty deviation: getClass yields Class[_], instead of [Class <: <type of receiver>].
-   *  We can get back the old behavior using this decorator. We should also use the same
-   *  trick for standard getClass.
-   */
-  private implicit class getClassDeco[T](val x: T) extends AnyVal {
-    def getClazz: Class[_ <: T] = x.getClass.asInstanceOf[Class[_ <: T]]
-  }
 }

compiler/src/dotty/tools/dotc/plugins/Plugin.scala

@@ -13,7 +13,7 @@ import scala.collection.mutable
 import scala.util.{ Try, Success, Failure }
 
 trait PluginPhase extends MiniPhase {
-  def runsBefore: Set[Class[_ <: Phase]] = Set.empty
+  def runsBefore: Set[String] = Set.empty
 }
 
 sealed trait Plugin {

compiler/src/dotty/tools/dotc/plugins/Plugins.scala

@@ -146,9 +146,9 @@ object Plugins {
    */
   def schedule(plan: List[List[Phase]], pluginPhases: List[PluginPhase]): List[List[Phase]] = {
     import scala.collection.mutable.{ Map => MMap }
-    type OrderingReq = (Set[Class[_]], Set[Class[_]])
+    type OrderingReq = (Set[String], Set[String])
 
-    val orderRequirements = MMap[Class[_], OrderingReq]()
+    val orderRequirements = MMap[String, OrderingReq]()
 
     // 1. already inserted phases don't need constraints themselves.
     // 2. no need to propagate beyond boundary of inserted phases, as the information
@@ -158,13 +158,13 @@ object Plugins {
     //    of primitive phases (`plan`) are used to check `runAfter` and `runBefore`, thus
     //    there is no need to propagate the primitive phases.
 
-    var insertedPhase   = plan.flatMap(ps => ps.map(_.getClass : Class[_])).toSet
-    def isInserted(phase: Class[_]): Boolean = insertedPhase.contains(phase)
+    var insertedPhase   = plan.flatMap(ps => ps.map(_.phaseName)).toSet
+    def isInserted(phase: String): Boolean = insertedPhase.contains(phase)
 
     var updatedPlan = plan
 
     def constraintConflict(phase: Phase): String = {
-      val (runsAfter, runsBefore) = orderRequirements(phase.getClass)
+      val (runsAfter, runsBefore) = orderRequirements(phase.phaseName)
       s"""
          |Ordering conflict for phase ${phase.phaseName}
          |after: ${runsAfter.mkString("[", ", ", "]")}
@@ -174,26 +174,26 @@ object Plugins {
 
     // init ordering map, no propagation
     pluginPhases.foreach { phase =>
-      val runsAfter  : Set[Class[_]] = phase.runsAfter.asInstanceOf[Set[Class[_]]]
-      val runsBefore : Set[Class[_]] = phase.runsBefore.asInstanceOf[Set[Class[_]]]
+      val runsAfter  = phase.runsAfter
+      val runsBefore = phase.runsBefore
 
-      orderRequirements.update(phase.getClass, (runsAfter, runsBefore))
+      orderRequirements.update(phase.phaseName, (runsAfter, runsBefore))
     }
 
     // propagate ordering constraint : reflexivity
     pluginPhases.foreach { phase =>
 
-      var (runsAfter, runsBefore) = orderRequirements(phase.getClass)
+      var (runsAfter, runsBefore) = orderRequirements(phase.phaseName)
 
       // propagate transitive constraints to related phases
-      runsAfter.filter(!isInserted(_)).foreach { phaseClass =>
-        val (runsAfter1, runsBefore1) = orderRequirements(phaseClass)
-        orderRequirements.update(phaseClass, (runsAfter1, runsBefore1 + phase.getClass))
+      runsAfter.filter(!isInserted(_)).foreach { phaseName =>
+        val (runsAfter1, runsBefore1) = orderRequirements(phaseName)
+        orderRequirements.update(phaseName, (runsAfter1, runsBefore1 + phase.phaseName))
       }
 
-      runsBefore.filter(!isInserted(_)).foreach { phaseClass =>
-        val (runsAfter1, runsBefore1) = orderRequirements(phaseClass)
-        orderRequirements.update(phaseClass, (runsAfter1 + phase.getClass, runsBefore1))
+      runsBefore.filter(!isInserted(_)).foreach { phaseName =>
+        val (runsAfter1, runsBefore1) = orderRequirements(phaseName)
+        orderRequirements.update(phaseName, (runsAfter1 + phase.phaseName, runsBefore1))
       }
 
     }
@@ -206,8 +206,8 @@ object Plugins {
 
     // propagate constraints from related phases to current phase: transitivity
     def propagate(phase: Phase): OrderingReq = {
-      def propagateRunsBefore(beforePhase: Class[_]): Set[Class[_]] =
-        if (beforePhase == phase.getClass)
+      def propagateRunsBefore(beforePhase: String): Set[String] =
+        if (beforePhase == phase.phaseName)
           throw new Exception(constraintConflict(phase))
         else if (isInserted(beforePhase))
           Set(beforePhase)
@@ -216,8 +216,8 @@ object Plugins {
           runsBefore.flatMap(propagateRunsBefore) + beforePhase
         }
 
-      def propagateRunsAfter(afterPhase: Class[_]): Set[Class[_]] =
-        if (afterPhase == phase.getClass)
+      def propagateRunsAfter(afterPhase: String): Set[String] =
+        if (afterPhase == phase.phaseName)
           throw new Exception(constraintConflict(phase))
         else if (isInserted(afterPhase))
           Set(afterPhase)
@@ -226,7 +226,7 @@ object Plugins {
           runsAfter.flatMap(propagateRunsAfter) + afterPhase
         }
 
-      var (runsAfter, runsBefore) = orderRequirements(phase.getClass)
+      var (runsAfter, runsBefore) = orderRequirements(phase.phaseName)
 
       runsAfter  = runsAfter.flatMap(propagateRunsAfter)
       runsBefore = runsBefore.flatMap(propagateRunsBefore)
@@ -249,25 +249,25 @@ object Plugins {
 
       // runsBefore met after the split
       val (before, after) = updatedPlan.span { ps =>
-        val classes = ps.map(_.getClass)
+        val phases = ps.map(_.phaseName)
         val runsAfterSat = runsAfter.isEmpty
-        runsAfter = runsAfter -- classes
+        runsAfter = runsAfter -- phases
         // Prefer the point immediately before the first runsBefore.
         // If runsBefore not specified, insert at the point immediately
         // after the last afterPhases.
-        !classes.exists(runsBefore.contains) &&
+        !phases.exists(runsBefore.contains) &&
           !(runsBefore.isEmpty && runsAfterSat)
       }
 
       // check runsAfter
       // error can occur if: a < b, b < c, c < a
       after.foreach { ps =>
-        val classes = ps.map(_.getClass)
-        if (classes.exists(runsAfter)) // afterReq satisfied
+        val phases = ps.map(_.phaseName)
+        if (phases.exists(runsAfter)) // afterReq satisfied
           throw new Exception(s"Ordering conflict for phase ${phase.phaseName}")
       }
 
-      insertedPhase = insertedPhase + phase.getClass
+      insertedPhase = insertedPhase + phase.phaseName
       updatedPlan = before ++ (List(phase) :: after)
     }
 

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -38,7 +38,7 @@ class ExtractAPI extends Phase {
   // after `PostTyper` (unlike `ExtractDependencies`, the simplication to trees
   // done by `PostTyper` do not affect this phase because it only cares about
   // definitions, and `PostTyper` does not change definitions).
-  override def runsAfter = Set(classOf[transform.PostTyper])
+  override def runsAfter = Set(transform.PostTyper.name)
 
   override def run(implicit ctx: Context): Unit = {
     val unit = ctx.compilationUnit

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

@@ -17,6 +17,10 @@ import NameOps._
 import NameKinds.{ExpandedName, TraitSetterName}
 import ast.Trees._
 
+object AugmentScala2Traits {
+  val name = "augmentScala2Traits"
+}
+
 /** This phase augments Scala2 traits with implementation classes and with additional members
  *  needed for mixin composition.
  *  These symbols would have been added between Unpickling and Mixin in the Scala2 pipeline.
@@ -33,7 +37,7 @@ class AugmentScala2Traits extends MiniPhase with IdentityDenotTransformer with F
 
   override def changesMembers = true
 
-  override def phaseName: String = "augmentScala2Traits"
+  override def phaseName: String = AugmentScala2Traits.name
 
   override def rewiredTarget(referenced: Symbol, derived: Symbol)(implicit ctx: Context) = NoSymbol
 

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

@@ -26,11 +26,15 @@ import core.StdNames.nme
 class ByNameClosures extends TransformByNameApply with IdentityDenotTransformer { thisPhase =>
   import ast.tpd._
 
-  override def phaseName: String = "byNameClosures"
+  override def phaseName: String = ByNameClosures.name
 
   override def mkByNameClosure(arg: Tree, argType: Type)(implicit ctx: Context): Tree = {
     val meth = ctx.newSymbol(
       ctx.owner, nme.ANON_FUN, Synthetic | Method, MethodType(Nil, Nil, argType))
     Closure(meth, _ => arg.changeOwnerAfter(ctx.owner, meth, thisPhase))
   }
 }
+
+object ByNameClosures {
+  val name = "byNameClosures"
+}

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

@@ -20,6 +20,10 @@ import util.Positions._
 import Constants.Constant
 import collection.mutable
 
+object Constructors {
+  val name = "constructors"
+}
+
 /** This transform
  *   - moves initializers from body to constructor.
  *   - makes all supercalls explicit
@@ -29,9 +33,9 @@ import collection.mutable
 class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =>
   import tpd._
 
-  override def phaseName: String = "constructors"
-  override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[HoistSuperArgs])
-  override def runsAfterGroupsOf: Set[Class[_ <: Phase]] = Set(classOf[Memoize])
+  override def phaseName: String = Constructors.name
+  override def runsAfter = Set(HoistSuperArgs.name)
+  override def runsAfterGroupsOf = Set(Memoize.name)
     // Memoized needs to be finished because we depend on the ownerchain after Memoize
     // when checking whether an ident is an access in a constructor or outside it.
     // This test is done in the right-hand side of a value definition. If Memoize

compiler/src/dotty/tools/dotc/transform/DropEmptyCompanions.scala.disabled

@@ -31,7 +31,7 @@ import dotty.tools.dotc.transform.MegaPhase.TransformerInfo
 class DropEmptyCompanions extends MiniPhase { thisTransform =>
   import ast.tpd._
   override def phaseName = "dropEmptyCompanions"
-  override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[Flatten])
+  override def runsAfter = Set(Flatten.name)
 
   override def transformPackageDef(pdef: PackageDef)(implicit ctx: Context) = {
 

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

@@ -40,9 +40,9 @@ import ast.Trees._
 class ElimByName extends TransformByNameApply with InfoTransformer {
   import ast.tpd._
 
-  override def phaseName: String = "elimByName"
+  override def phaseName: String = ElimByName.name
 
-  override def runsAfterGroupsOf = Set(classOf[Splitter])
+  override def runsAfterGroupsOf = Set(Splitter.name)
     // I got errors running this phase in an earlier group, but I did not track them down.
 
   /** Map `tree` to `tree.apply()` is `ftree` was of ExprType and becomes now a function */
@@ -79,3 +79,7 @@ class ElimByName extends TransformByNameApply with InfoTransformer {
 
   override def mayChange(sym: Symbol)(implicit ctx: Context): Boolean = sym.isTerm
 }
+
+object ElimByName {
+  val name = "elimByName"
+}

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

@@ -8,6 +8,10 @@ import Types._, Contexts._, Constants._, Names._, NameOps._, Flags._, DenotTrans
 import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._, Scopes._, Denotations._
 import TypeErasure.ErasedValueType, ValueClasses._
 
+object ElimErasedValueType {
+  val name = "elimErasedValueType"
+}
+
 /** This phase erases ErasedValueType to their underlying type.
  *  It also removes the synthetic cast methods u2evt$ and evt2u$ which are
  *  no longer needed afterwards.
@@ -19,9 +23,9 @@ class ElimErasedValueType extends MiniPhase with InfoTransformer {
 
   import tpd._
 
-  override def phaseName: String = "elimErasedValueType"
+  override def phaseName: String = ElimErasedValueType.name
 
-  override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[Erasure])
+  override def runsAfter = Set(Erasure.name)
 
   def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = sym match {
     case sym: ClassSymbol if sym is ModuleClass =>