support both ordering and research plugin

Author: liufengyun

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

@@ -112,7 +112,7 @@ class Run(comp: Compiler, ictx: Context) {
       if (ctx.settings.YtestPickler.value) List("pickler")
       else ctx.settings.YstopAfter.value
 
-    val pluginPlan = ctx.plugins.foldRight(ctx.phasePlan) { (plug, plan) => plug.init(plan) }
+    val pluginPlan = ctx.addPluginPhases(ctx.phasePlan)
     val phases = ctx.squashPhases(pluginPlan,
       ctx.settings.Yskip.value, ctx.settings.YstopBefore.value, stopAfter, ctx.settings.Ycheck.value)
     ctx.usePhases(phases)

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

@@ -11,30 +11,47 @@ import java.io.InputStream
 import scala.collection.mutable
 import scala.util.{ Try, Success, Failure }
 
+trait PluginPhase extends Phase {
+  def runsBefore: Set[Class[_ <: Phase]] = Set.empty
+}
+
 trait Plugin {
   /** The name of this plugin */
   def name: String
 
   /** A one-line description of the plugin */
   def description: String
 
+  /** The phases that this plugin defines */
+  def components: List[PluginPhase] = Nil
+
+  /** Is this plugin a research plugin?
+   *
+   *  Research plugin receives a phase plan and return a new phase plan, while
+   *  non-research plugin returns a list of phases to be inserted.
+   */
+  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)
   }
 
-  /** Handle any plugin-specific options.
-   *  The user writes `-P:plugname:opt1,opt2`,
-   *  but the plugin sees `List(opt1, opt2)`.
-   *  The plugin can opt out of further processing
-   *  by returning false.  For example, if the plugin
-   *  has an "enable" flag, now would be a good time
-   *  to sit on the bench.
-   *  @param options plugin arguments
-   *  @param error error function
-   *  @return true to continue, or false to opt out
+  /** Non-research plugins should override this method to return the phases
+   *
+   *  @return a list of phases to be added to the phase plan
    */
+  def init()(implicit ctx: Context): List[Phase] = Nil
+
+   /** 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]] = phases
 
   /** A description of this plugin's options, suitable as a response
@@ -72,11 +89,11 @@ object Plugin {
       else PluginDescription.fromXML(is)
 
     val xmlEntry = new java.util.jar.JarEntry(PluginXML)
-    Try(read(new Jar(jarp.jfile).getEntryStream(xmlEntry)))
+    Try(read(new Jar(jarp.jpath.toFile).getEntryStream(xmlEntry)))
   }
 
   private def loadDescriptionFromFile(f: Path): Try[PluginDescription] =
-    Try(PluginDescription.fromXML(new java.io.FileInputStream(f.jfile)))
+    Try(PluginDescription.fromXML(new java.io.FileInputStream(f.jpath.toFile)))
 
   type AnyClass = Class[_]
 

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

@@ -3,8 +3,9 @@ package plugins
 
 import core._
 import Contexts._
-import dotty.tools.dotc.config.PathResolver
+import config.PathResolver
 import dotty.tools.io._
+import Phases._
 
 /** Support for run-time loading of compiler plugins.
  *
@@ -80,7 +81,7 @@ trait Plugins {
       }
     }
 
-    val plugs = pick(roughPluginsList, Set())
+    val plugs = pick(roughPluginsList, ctx.phasePlan.flatten.map(_.phaseName).toSet)
 
     // Verify required plugins are present.
     for (req <- ctx.settings.require.value ; if !(plugs exists (_.name == req)))
@@ -113,4 +114,65 @@ trait Plugins {
     (for (plug <- roughPluginsList ; help <- plug.optionsHelp) yield {
       "\nOptions for plugin '%s':\n%s\n".format(plug.name, help)
     }).mkString
+
+  /** Add plugin phases to phase plan */
+  def addPluginPhases(plan: List[List[Phase]])(implicit ctx: Context): List[List[Phase]] = {
+    import scala.collection.mutable.{ Set => MSet, Map => MMap }
+    type OrderingReq = (MSet[Class[_]], MSet[Class[_]])
+
+    val orderRequirements = MMap[Class[_], OrderingReq]()
+
+    def updateOrdering(phase: PluginPhase): Unit = {
+      val runsBefore: MSet[Class[_]] = MSet(phase.runsBefore.toSeq: _*)
+      val runsAfter: MSet[Class[_]]  = MSet(phase.runsAfter.toSeq: _*)
+
+      if (!orderRequirements.contains(phase.getClass)) {
+        orderRequirements.update(phase.getClass, (runsBefore, runsAfter) )
+      }
+
+      runsBefore.foreach { phaseClass =>
+        if (!orderRequirements.contains(phaseClass))
+          orderRequirements.update(phaseClass, (MSet.empty, MSet.empty))
+        val (_, runsAfter) = orderRequirements(phaseClass)
+        runsAfter += phase.getClass
+      }
+
+      runsAfter.foreach { phaseClass =>
+        if (!orderRequirements.contains(phaseClass))
+          orderRequirements.update(phaseClass, (MSet.empty, MSet.empty))
+        val (runsBefore, _) = orderRequirements(phaseClass)
+        runsBefore += phase.getClass
+      }
+    }
+
+    // add non-research plugins
+    var updatedPlan = plan
+    plugins.filter(!_.research).foreach { plug =>
+      plug.components.foreach { phase =>
+        updateOrdering(phase)
+
+        val beforePhases: MSet[Class[_]] = MSet(phase.runsBefore.toSeq: _*)
+        val afterPhases: MSet[Class[_]]  = MSet(phase.runsAfter.toSeq: _*)
+
+        val (before, after) = updatedPlan.span { ps =>
+          val classes = ps.map(_.getClass)
+          afterPhases --= classes
+          !classes.exists(beforePhases.contains)  // beforeReq satisfied
+        }
+
+        // check afterReq
+        // error can occur if: a < b, b < c, c < a
+        after.foreach { ps =>
+          val classes = ps.map(_.getClass)
+          if (classes.exists(afterPhases))  // afterReq satisfied
+            throw new Exception(s"Ordering conflict for plugin ${plug.name}")
+        }
+
+        updatedPlan = before ++ (List(phase) :: after)
+      }
+    }
+
+    // add research plugins
+    ctx.plugins.filter(_.research).foldRight(updatedPlan) { (plug, plan) => plug.init(plan) }
+  }
 }

tests/plugins/neg/divideZero/plugin_1.scala

@@ -13,6 +13,8 @@ class DivideZero extends MiniPhase with Plugin {
   val name: String = "divideZero"
   override val description: String = "divide zero check"
 
+  override val research = true
+
   val phaseName = name
 
   override def init(phases: List[List[Phase]])(implicit ctx: Context): List[List[Phase]] = {

tests/plugins/pos/divideZero/plugin_1.scala

@@ -15,6 +15,8 @@ class DivideZero extends MiniPhase with Plugin {
 
   val phaseName = name
 
+  override val research = true
+
   override def init(phases: List[List[Phase]])(implicit ctx: Context): List[List[Phase]] = {
     val (before, after) = phases.span(ps => !ps.exists(_.phaseName == "pickler"))
     before ++ (List(this) :: after)
@@ -35,3 +37,4 @@ class DivideZero extends MiniPhase with Plugin {
       tree
   }
 }
+