refactor ordering algorithm for unit test

Author: liufengyun

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

@@ -30,27 +30,21 @@ trait Plugin {
    */
   def research: Boolean = false
 
- /** Handle any plugin-specific options.
-  *  The user writes `-P:plugname:opt1,opt2`,
-  *  but the plugin sees `List(opt1, opt2)`.
-  */
-  def options(implicit ctx: Context): List[String] = {
-    // Process plugin options of form plugin:option
-    def namec = name + ":"
-    ctx.settings.pluginOptions.value filter (_ startsWith namec) map (_ stripPrefix namec)
-  }
 
   /** Non-research plugins should override this method to return the phases
    *
+   *  @param options: commandline options to the plugin, `-P:plugname:opt1,opt2`
    *  @return a list of phases to be added to the phase plan
    */
-  def init()(implicit ctx: Context): List[PluginPhase] = ???
+  def init(options: List[String]): List[PluginPhase] = ???
 
-   /** Research plugins should override this method to return the new phase plan
-    *
-    *  @return the new phase plan
-    */
-  def init(phases: List[List[Phase]])(implicit ctx: Context): List[List[Phase]] = ???
+  /** Research plugins should override this method to return the new phase plan
+   *
+   *  @param options: commandline options to the plugin, `-P:plugname:opt1,opt2`
+   *  @param plan: the given phase plan
+   *  @return the new phase plan
+   */
+  def init(options: List[String], plan: List[List[Phase]])(implicit ctx: Context): List[List[Phase]] = ???
 
   /** A description of this plugin's options, suitable as a response
    *  to the -help command-line option.  Conventionally, the options

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

@@ -117,6 +117,30 @@ trait Plugins {
 
   /** Add plugin phases to phase plan */
   def addPluginPhases(plan: List[List[Phase]])(implicit ctx: Context): List[List[Phase]] = {
+    // plugin-specific options.
+    // The user writes `-P:plugname:opt1,opt2`, but the plugin sees `List(opt1, opt2)`.
+    def options(plugin: Plugin): List[String] = {
+      def namec = plugin.name + ":"
+      ctx.settings.pluginOptions.value filter (_ startsWith namec) map (_ stripPrefix namec)
+    }
+
+    // schedule plugins according to ordering constraints
+    val updatedPlan = Plugins.schedule(plan, plugins.filter(!_.research), options)
+
+    // add research plugins
+    plugins.filter(_.research).foldRight(updatedPlan) { (plug, plan) => plug.init(options(plug), plan) }
+  }
+}
+
+object Plugins {
+  /** Insert plugin phases in the right place of the phase plan
+   *
+   *  The scheduling makes sure the ordering constraints of plugin phases are satisfied.
+   *  If the ordering constraints are unsatisfiable, an exception is thrown.
+   *
+   *  Note: this algorithm is factored out for unit test.
+   */
+  def schedule(plan: List[List[Phase]], plugins: List[Plugin], optionFn: Plugin => List[String]): List[List[Phase]] = {
     import scala.collection.mutable.{ Set => MSet, Map => MMap }
     type OrderingReq = (MSet[Class[_]], MSet[Class[_]])
 
@@ -145,19 +169,23 @@ trait Plugins {
       }
     }
 
-    // add non-research plugins
     var updatedPlan = plan
-    plugins.filter(!_.research).foreach { plug =>
-      plug.init().foreach { phase =>
+    plugins.foreach { plug =>
+      plug.init(optionFn(plug)).foreach { phase =>
         updateOrdering(phase)
 
         val beforePhases: MSet[Class[_]] = MSet(phase.runsBefore.toSeq: _*)
         val afterPhases: MSet[Class[_]]  = MSet(phase.runsAfter.toSeq: _*)
 
+        // beforeReq met after the split
         val (before, after) = updatedPlan.span { ps =>
           val classes = ps.map(_.getClass)
           afterPhases --= classes
-          !classes.exists(beforePhases.contains)  // beforeReq satisfied
+          // Prefer the point immediately before the first beforePhases.
+          // If beforePhases not specified, insert at the point immediately
+          // after the last afterPhases.
+          !classes.exists(beforePhases.contains) &&
+            !(beforePhases.isEmpty && afterPhases.isEmpty)
         }
 
         // check afterReq
@@ -172,7 +200,6 @@ trait Plugins {
       }
     }
 
-    // add research plugins
-    ctx.plugins.filter(_.research).foldRight(updatedPlan) { (plug, plan) => plug.init(plan) }
+    updatedPlan
   }
 }

tests/plugins/neg/divideZero-research/plugin_1.scala

@@ -17,7 +17,7 @@ class DivideZero extends MiniPhase with Plugin {
 
   val phaseName = name
 
-  override def init(phases: List[List[Phase]])(implicit ctx: Context): List[List[Phase]] = {
+  override def init(options: List[String], phases: List[List[Phase]])(implicit ctx: Context): List[List[Phase]] = {
     val (before, after) = phases.span(ps => !ps.exists(_.phaseName == "pickler"))
     before ++ (List(this) :: after)
   }

tests/plugins/neg/divideZero/plugin_1.scala

@@ -19,7 +19,7 @@ class DivideZero extends PluginPhase with Plugin {
   override val runsAfter = Set(classOf[Pickler])
   override val runsBefore = Set(classOf[LinkAll])
 
-  override def init()(implicit ctx: Context): List[PluginPhase] = this :: Nil
+  override def init(options: List[String]): List[PluginPhase] = this :: Nil
 
   private def isNumericDivide(sym: Symbol)(implicit ctx: Context): Boolean = {
     def test(tpe: String): Boolean =

tests/plugins/pos/divideZero/plugin_1.scala

@@ -17,7 +17,7 @@ class DivideZero extends MiniPhase with Plugin {
 
   override val research = true
 
-  override def init(phases: List[List[Phase]])(implicit ctx: Context): List[List[Phase]] = {
+  override def init(options: List[String], phases: List[List[Phase]])(implicit ctx: Context): List[List[Phase]] = {
     val (before, after) = phases.span(ps => !ps.exists(_.phaseName == "pickler"))
     before ++ (List(this) :: after)
   }