Merge pull request #2859 from som-snytt/issue/7622-phaser

SI-7622 Clean Up Phase Assembly

13 files changed, 268 insertions, 197 deletions

diff --git a/src/compiler/scala/tools/nsc/CompilerCommand.scala b/src/compiler/scala/tools/nsc/CompilerCommand.scala
index f1f5130fb8..bab0768ca9 100644
--- a/src/compiler/scala/tools/nsc/CompilerCommand.scala
+++ b/src/compiler/scala/tools/nsc/CompilerCommand.scala
@@ -27,7 +27,7 @@ class CompilerCommand(arguments: List[String], val settings: Settings) {
     |-- Notes on option parsing --
     |Boolean settings are always false unless set.
     |Where multiple values are accepted, they should be comma-separated.
-    |  example: -Xplugin:plugin1,plugin2
+    |  example: -Xplugin:option1,option2
     |<phases> means one or a comma-separated list of:
     |  (partial) phase names, phase ids, phase id ranges, or the string "all".
     |  example: -Xprint:all prints all phases.
@@ -80,23 +80,23 @@ class CompilerCommand(arguments: List[String], val settings: Settings) {
   def xusageMsg   = createUsageMsg("Possible advanced", shouldExplain = true, _.isAdvanced)
   def yusageMsg   = createUsageMsg("Possible private", shouldExplain = true, _.isPrivate)
 
-  // If any of these settings is set, the compiler shouldn't start;
-  // an informative message of some sort should be printed instead.
-  def shouldStopWithInfo = {
-    import settings.{ Setting => _, _ }
-    Set[BooleanSetting](help, Xhelp, Yhelp, showPlugins, showPhases) exists (_.value)
-  }
+  /** For info settings, compiler should just print a message and quit. */
+  def shouldStopWithInfo = settings.isInfo
 
   def getInfoMessage(global: Global): String = {
     import settings._
-    if (help.value)               usageMsg + global.pluginOptionsHelp
-    else if (Xhelp.value)         xusageMsg
-    else if (Yhelp.value)         yusageMsg
-    else if (showPlugins.value)   global.pluginDescriptions
-    else if (showPhases.value)    global.phaseDescriptions + (
-      if (debug.value) "\n" + global.phaseFlagDescriptions else ""
+    if (help)               usageMsg + global.pluginOptionsHelp
+    else if (Xhelp)         xusageMsg
+    else if (Yhelp)         yusageMsg
+    else if (showPlugins)   global.pluginDescriptions
+    else if (showPhases)    global.phaseDescriptions + (
+      if (debug) "\n" + global.phaseFlagDescriptions else ""
     )
-    else                          ""
+    else if (genPhaseGraph.isSetByUser) {
+      val components = global.phaseNames  // global.phaseDescriptors // one initializes
+      s"Phase graph of ${components.size} components output to ${genPhaseGraph.value}*.dot."
+    }
+    else                    ""
   }
 
   /**
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index 0e3b2993c7..f6d4b26cda 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -47,7 +47,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
   // the mirror --------------------------------------------------
 
   override def isCompilerUniverse = true
-  override val useOffsetPositions = !currentSettings.Yrangepos.value
+  override val useOffsetPositions = !currentSettings.Yrangepos
 
   class GlobalMirror extends Roots(NoSymbol) {
     val universe: self.type = self
@@ -428,9 +428,11 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
   // phaseName = "parser"
   lazy val syntaxAnalyzer = new {
     val global: Global.this.type = Global.this
+  } with SyntaxAnalyzer {
     val runsAfter = List[String]()
     val runsRightAfter = None
-  } with SyntaxAnalyzer
+    override val initial = true
+  }
 
   import syntaxAnalyzer.{ UnitScanner, UnitParser }
 
@@ -450,9 +452,9 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
   object patmat extends {
     val global: Global.this.type = Global.this
     val runsAfter = List("typer")
-    // patmat doesn't need to be right after typer, as long as we run before supperaccesors
-    // (sbt does need to run right after typer, so don't conflict)
     val runsRightAfter = None
+    // patmat doesn't need to be right after typer, as long as we run before superaccessors
+    // (sbt does need to run right after typer, so don't conflict)
   } with PatternMatching
 
   // phaseName = "superaccessors"
@@ -626,18 +628,17 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
   // phaseName = "terminal"
   object terminal extends {
     val global: Global.this.type = Global.this
-    val phaseName = "terminal"
+  } with SubComponent {
+    final val phaseName = "terminal"
     val runsAfter = List("jvm")
     val runsRightAfter = None
-  } with SubComponent {
-    private var cache: Option[GlobalPhase] = None
-    def reset(): Unit = cache = None
+    override val terminal = true
 
-    def newPhase(prev: Phase): GlobalPhase =
-      cache getOrElse returning(new TerminalPhase(prev))(x => cache = Some(x))
-
-    class TerminalPhase(prev: Phase) extends GlobalPhase(prev) {
-      def name = "terminal"
+    def newPhase(prev: Phase): GlobalPhase = {
+      new TerminalPhase(prev)
+    }
+    private class TerminalPhase(prev: Phase) extends GlobalPhase(prev) {
+      def name = phaseName
       def apply(unit: CompilationUnit) {}
     }
   }
@@ -665,7 +666,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
   /** Add the internal compiler phases to the phases set.
    *  This implementation creates a description map at the same time.
    */
-  protected def computeInternalPhases() {
+  protected def computeInternalPhases(): Unit = {
     // Note: this fits -Xshow-phases into 80 column width, which it is
     // desirable to preserve.
     val phs = List(
@@ -695,7 +696,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
       closureElimination      -> "optimization: eliminate uncalled closures",
       constantOptimization    -> "optimization: optimize null and other constants",
       deadCode                -> "optimization: eliminate dead code",
-      terminal                -> "The last phase in the compiler chain"
+      terminal                -> "the last phase during a compilation run"
     )
 
     phs foreach (addToPhasesSet _).tupled
@@ -713,13 +714,21 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
 
   // sequences the phase assembly
   protected def computePhaseDescriptors: List[SubComponent] = {
-    computeInternalPhases()       // Global.scala
-    computePlatformPhases()       // backend/Platform.scala
-    computePluginPhases()         // plugins/Plugins.scala
-    buildCompilerFromPhasesSet()  // PhaseAssembly.scala
+    /** Allow phases to opt out of the phase assembly. */
+    def cullPhases(phases: List[SubComponent]) = {
+      val enabled = if (settings.debug && settings.isInfo) phases else phases filter (_.enabled)
+      def isEnabled(q: String) = enabled exists (_.phaseName == q)
+      val (satisfied, unhappy) = enabled partition (_.requires forall isEnabled)
+      unhappy foreach (u => globalError(s"Phase '${u.phaseName}' requires: ${u.requires filterNot isEnabled}"))
+      satisfied   // they're happy now, but they may need an unhappy phase that was booted
+    }
+    computeInternalPhases()             // Global.scala
+    computePlatformPhases()             // backend/Platform.scala
+    computePluginPhases()               // plugins/Plugins.scala
+    cullPhases(computePhaseAssembly())  // PhaseAssembly.scala
   }
 
-  /* The phase descriptor list */
+  /* The phase descriptor list. Components that are phase factories. */
   lazy val phaseDescriptors: List[SubComponent] = computePhaseDescriptors
 
   /* The set of phase objects that is the basis for the compiler phase chain */
@@ -737,22 +746,50 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
     phaseDescriptors map (_.phaseName)
   }
 
-  /** A description of the phases that will run */
-  def phaseDescriptions: String = {
+  /** A description of the phases that will run in this configuration, or all if -Ydebug. */
+  def phaseDescriptions: String = phaseHelp("description", elliptically = true, phasesDescMap)
+
+  /** Summary of the per-phase values of nextFlags and newFlags, shown under -Xshow-phases -Ydebug. */
+  def phaseFlagDescriptions: String = {
+    def fmt(ph: SubComponent) = {
+      def fstr1 = if (ph.phaseNewFlags == 0L) "" else "[START] " + Flags.flagsToString(ph.phaseNewFlags)
+      def fstr2 = if (ph.phaseNextFlags == 0L) "" else "[END] " + Flags.flagsToString(ph.phaseNextFlags)
+      if (ph.initial) Flags.flagsToString(Flags.InitialFlags)
+      else if (ph.phaseNewFlags != 0L && ph.phaseNextFlags != 0L) fstr1 + " " + fstr2
+      else fstr1 + fstr2
+    }
+    phaseHelp("new flags", elliptically = false, fmt)
+  }
+
+  /** Emit a verbose phase table.
+   *  The table includes the phase id in the current assembly,
+   *  or "oo" to indicate a skipped phase, or "xx" to indicate
+   *  a disabled phase.
+   *
+   *  @param title descriptive header
+   *  @param elliptically whether to truncate the description with an ellipsis (...)
+   *  @param describe how to describe a component
+   */
+  def phaseHelp(title: String, elliptically: Boolean, describe: SubComponent => String) = {
     val Limit   = 16    // phase names should not be absurdly long
     val MaxCol  = 80    // because some of us edit on green screens
-    val maxName = (0 /: phaseNames)(_ max _.length)
+    val maxName = phaseNames map (_.length) max
     val width   = maxName min Limit
     val maxDesc = MaxCol - (width + 6)  // descriptions not novels
-    val fmt     = if (settings.verbose) s"%${maxName}s  %2s  %s%n"
+    val fmt     = if (settings.verbose || !elliptically) s"%${maxName}s  %2s  %s%n"
                   else s"%${width}.${width}s  %2s  %.${maxDesc}s%n"
 
-    val line1 = fmt.format("phase name", "id", "description")
-    val line2 = fmt.format("----------", "--", "-----------")
+    val line1 = fmt.format("phase name", "id", title)
+    val line2 = fmt.format("----------", "--", "-" * title.length)
 
     // built-in string precision merely truncates
     import java.util.{ Formattable, FormattableFlags, Formatter }
-    def fmtable(s: String) = new Formattable {
+    def dotfmt(s: String) = new Formattable {
+      def elliptically(s: String, max: Int) = (
+        if (max < 0 || s.length <= max) s
+        else if (max < 4) s.take(max)
+        else s.take(max - 3) + "..."
+      )
       override def formatTo(formatter: Formatter, flags: Int, width: Int, precision: Int) {
         val p = elliptically(s, precision)
         val w = if (width > 0 && p.length < width) {
@@ -768,36 +805,19 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
         formatter.out.append(w)
       }
     }
-    def elliptically(s: String, max: Int) =
-      if (max < 0 || s.length <= max) s
-      else if (max < 4) s.take(max)
-      else s.take(max - 3) + "..."
-    val descs = phaseDescriptors.zipWithIndex map {
-      case (ph, idx) => fmt.format(fmtable(ph.phaseName), idx + 1, fmtable(phasesDescMap(ph)))
-    }
-    line1 :: line2 :: descs mkString
-  }
-  /** Summary of the per-phase values of nextFlags and newFlags, shown
-   *  with -Xshow-phases if -Ydebug also given.
-   */
-  def phaseFlagDescriptions: String = {
-    val width = phaseNames map (_.length) max
-    val fmt   = "%" + width + "s  %2s  %s\n"
-
-    val line1 = fmt.format("phase name", "id", "new flags")
-    val line2 = fmt.format("----------", "--", "---------")
-    val descs = phaseDescriptors.zipWithIndex map {
-      case (ph, idx) =>
-        def fstr1 = if (ph.phaseNewFlags == 0L) "" else "[START] " + Flags.flagsToString(ph.phaseNewFlags)
-        def fstr2 = if (ph.phaseNextFlags == 0L) "" else "[END] " + Flags.flagsToString(ph.phaseNextFlags)
-        val fstr = (
-          if (ph.ownPhase.id == 1) Flags.flagsToString(Flags.InitialFlags)
-          else if (ph.phaseNewFlags != 0L && ph.phaseNextFlags != 0L) fstr1 + " " + fstr2
-          else fstr1 + fstr2
-        )
-        fmt.format(ph.phaseName, idx + 1, fstr)
+
+    // phase id in run, or suitable icon
+    def idOf(p: SubComponent) = (
+      if (settings.skip contains p.phaseName) "oo"   // (currentRun skipPhase p.phaseName)
+      else if (!p.enabled) "xx"
+      else p.ownPhase.id.toString
+    )
+    def mkText(p: SubComponent) = {
+      val (name, text) = if (elliptically) (dotfmt(p.phaseName), dotfmt(describe(p)))
+                         else (p.phaseName, describe(p))
+      fmt.format(name, idOf(p), text)
     }
-    line1 :: line2 :: descs mkString
+    line1 :: line2 :: (phaseDescriptors map mkText) mkString
   }
 
   /** Returns List of (phase, value) pairs, including only those
@@ -1145,7 +1165,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
   def newUnitParser(unit: CompilationUnit): UnitParser   = new UnitParser(unit)
   def newUnitParser(code: String): UnitParser            = newUnitParser(newCompilationUnit(code))
 
-  /** A Run is a single execution of the compiler on a sets of units
+  /** A Run is a single execution of the compiler on a set of units.
    */
   class Run extends RunContextApi {
     /** Have been running into too many init order issues with Run
@@ -1184,64 +1204,100 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
     /** A map from compiled top-level symbols to their picklers */
     val symData = new mutable.HashMap[Symbol, PickleBuffer]
 
-    private var phasec: Int       = 0   // phases completed
-    private var unitc: Int        = 0   // units completed this phase
+    private var phasec: Int  = 0   // phases completed
+    private var unitc: Int   = 0   // units completed this phase
     private var _unitbufSize = 0
 
     def size = _unitbufSize
     override def toString = "scalac Run for:\n  " + compiledFiles.toList.sorted.mkString("\n  ")
 
     // Calculate where to stop based on settings -Ystop-before or -Ystop-after.
-    // Slightly complicated logic due to wanting -Ystop-before:parser to fail rather
-    // than mysteriously running to completion.
+    // The result is the phase to stop at BEFORE running it.
     private lazy val stopPhaseSetting = {
-      val result = phaseDescriptors sliding 2 collectFirst {
-        case xs if xs exists (settings.stopBefore contains _.phaseName) => if (settings.stopBefore contains xs.head.phaseName) xs.head else xs.last
-        case xs if settings.stopAfter contains xs.head.phaseName        => xs.last
+      def isBefore(pd: SubComponent) = settings.stopBefore contains pd.phaseName
+      phaseDescriptors sliding 2 collectFirst {
+        case xs if xs exists isBefore
+                => (xs find isBefore).get
+        case xs if settings.stopAfter contains xs.head.phaseName
+                => xs.last
       }
-      if (result exists (_.phaseName == "parser"))
-        globalError("Cannot stop before parser phase.")
-
-      result
     }
-    // The phase to stop BEFORE running.
+    /** Should we stop right before entering the given phase? */
     protected def stopPhase(name: String) = stopPhaseSetting exists (_.phaseName == name)
+    /** Should we skip the given phase? */
     protected def skipPhase(name: String) = settings.skip contains name
 
-    /** As definitions.init requires phase != NoPhase, and calling phaseDescriptors.head
-     *  will force init, there is some jockeying herein regarding init order: instead of
-     *  taking the head descriptor we create a parser phase directly.
-     */
     private val firstPhase = {
-      /** Initialization. */
+      // Initialization.  definitions.init requires phase != NoPhase
+      import scala.reflect.internal.SomePhase
       curRunId += 1
       curRun = this
-
-      /* Set phase to a newly created syntaxAnalyzer and call definitions.init. */
-      val parserPhase: Phase = syntaxAnalyzer.newPhase(NoPhase)
-      phase = parserPhase
+      phase = SomePhase
+      phaseWithId(phase.id) = phase
       definitions.init()
 
-      // Flush the cache in the terminal phase: the chain could have been built
-      // before without being used. (This happens in the interpreter.)
-      terminal.reset()
-
-      // Each subcomponent supplies a phase, which are chained together.
-      //   If -Ystop:phase is given, neither that phase nor any beyond it is added.
-      //   If -Yskip:phase is given, that phase will be skipped.
-      val phaseLinks = {
-        val phs = (
-          phaseDescriptors.tail
-            takeWhile (pd => !stopPhase(pd.phaseName))
-            filterNot (pd =>  skipPhase(pd.phaseName))
-        )
+      // the components to use, omitting those named by -Yskip and stopping at the -Ystop phase
+      val components = {
+        // stop on a dime, but this test fails if pd is after the stop phase
+        def unstoppable(pd: SubComponent) = {
+          val stoppable = stopPhase(pd.phaseName)
+          if (stoppable && pd.initial) {
+            globalError(s"Cannot stop before initial phase '${pd.phaseName}'.")
+            true
+          } else
+            !stoppable
+        }
+        // skip a component for -Yskip or if not enabled
+        def skippable(pd: SubComponent) = {
+          val skippable = skipPhase(pd.phaseName)
+          if (skippable && (pd.initial || pd.terminal)) {
+            globalError(s"Cannot skip an initial or terminal phase '${pd.phaseName}'.")
+            false
+          } else
+            skippable || !pd.enabled
+        }
+        val phs = phaseDescriptors takeWhile unstoppable filterNot skippable
         // Ensure there is a terminal phase at the end, since -Ystop may have limited the phases.
-        if (phs.isEmpty || (phs.last ne terminal)) phs :+ terminal
-        else phs
+        if (phs.isEmpty || !phs.last.terminal) {
+          val t = if (phaseDescriptors.last.terminal) phaseDescriptors.last else terminal
+          phs :+ t
+        } else phs
       }
-      // Link them together.
-      phaseLinks.foldLeft(parserPhase)((chain, ph) => ph newPhase chain)
-      parserPhase
+      // Create phases and link them together. We supply the previous, and the ctor sets prev.next.
+      val last  = components.foldLeft(NoPhase: Phase)((prev, c) => c newPhase prev)
+      // rewind (Iterator.iterate(last)(_.prev) dropWhile (_.prev ne NoPhase)).next
+      val first = { var p = last ; while (p.prev ne NoPhase) p = p.prev ; p }
+      val ss    = settings
+
+      // As a final courtesy, see if the settings make any sense at all.
+      // If a setting selects no phase, it's a mistake. If a name prefix
+      // doesn't select a unique phase, that might be surprising too.
+      def checkPhaseSettings(including: Boolean, specs: Seq[String]*) = {
+        def isRange(s: String) = s.forall(c => c.isDigit || c == '-')
+        def isSpecial(s: String) = (s == "all" || isRange(s))
+        val setting = new ss.PhasesSetting("fake","fake")
+        for (p <- specs.flatten.to[Set]) {
+          setting.value = List(p)
+          val count = (
+            if (including) first.iterator count (setting containsPhase _)
+            else phaseDescriptors count (setting contains _.phaseName)
+          )
+          if (count == 0) warning(s"'$p' specifies no phase")
+          if (count > 1 && !isSpecial(p)) warning(s"'$p' selects $count phases")
+          if (!including && isSpecial(p)) globalError(s"-Yskip and -Ystop values must name phases: '$p'")
+          setting.clear()
+        }
+      }
+      // phases that are excluded; for historical reasons, these settings only select by phase name
+      val exclusions = List(ss.stopBefore, ss.stopAfter, ss.skip)
+      val inclusions = ss.visibleSettings collect {
+        case s: ss.PhasesSetting if !(exclusions contains s) => s.value
+      }
+      checkPhaseSettings(including = true, inclusions.toSeq: _*)
+      checkPhaseSettings(including = false, exclusions map (_.value): _*)
+
+      phase = first   //parserPhase
+      first
     }
 
     /** Reset all classes contained in current project, as determined by
diff --git a/src/compiler/scala/tools/nsc/PhaseAssembly.scala b/src/compiler/scala/tools/nsc/PhaseAssembly.scala
index ae71eb7255..996f6efe55 100644
--- a/src/compiler/scala/tools/nsc/PhaseAssembly.scala
+++ b/src/compiler/scala/tools/nsc/PhaseAssembly.scala
@@ -6,15 +6,12 @@
 
 package scala.tools.nsc
 
-import java.io.{ BufferedWriter, FileWriter }
 import scala.collection.mutable
 import scala.language.postfixOps
 
-/**
- * PhaseAssembly
- * Trait made to separate the constraint solving of the phase order from
- * the rest of the compiler. See SIP 00002
- *
+/** Converts an unordered morass of components into an order that
+ *  satisfies their mutual constraints.
+ *  @see SIP 00002. You have read SIP 00002?
  */
 trait PhaseAssembly {
   self: Global =>
@@ -23,18 +20,16 @@ trait PhaseAssembly {
    * Aux datastructure for solving the constraint system
    * The depency graph container with helper methods for node and edge creation
    */
-  class DependencyGraph {
+  private class DependencyGraph {
 
-    /**
-     * Simple edge with to and from refs
-     */
-    class Edge(var frm: Node, var to: Node, var hard: Boolean)
+    /** Simple edge with to and from refs */
+    case class Edge(var frm: Node, var to: Node, var hard: Boolean)
 
     /**
      * Simple node with name and object ref for the phase object,
      * also sets of in and out going dependencies
      */
-    class Node(name: String) {
+    case class Node(name: String) {
       val phasename = name
       var phaseobj: Option[List[SubComponent]] = None
       val after = new mutable.HashSet[Edge]()
@@ -51,8 +46,8 @@ trait PhaseAssembly {
     val nodes = new mutable.HashMap[String,Node]()
     val edges = new mutable.HashSet[Edge]()
 
-    /* Given a phase object, get the node for this phase object. If the
-     * node object does not exist, then create it.
+    /** Given a phase object, get the node for this phase object. If the
+     *  node object does not exist, then create it.
      */
     def getNodeByPhase(phs: SubComponent): Node = {
       val node: Node = getNodeByPhase(phs.phaseName)
@@ -105,9 +100,8 @@ trait PhaseAssembly {
      */
     def collapseHardLinksAndLevels(node: Node, lvl: Int) {
       if (node.visited) {
-        throw new FatalError(
-          "Cycle in compiler phase dependencies detected, phase " +
-          node.phasename + " reacted twice!")
+        dump("phase-cycle")
+        throw new FatalError(s"Cycle in phase dependencies detected at ${node.phasename}, created phase-cycle.dot")
       }
 
       if (node.level < lvl) node.level = lvl
@@ -140,7 +134,8 @@ trait PhaseAssembly {
       var hardlinks = edges.filter(_.hard)
       for (hl <- hardlinks) {
         if (hl.frm.after.size > 1) {
-          throw new FatalError("phase " + hl.frm.phasename + " want to run right after " + hl.to.phasename + ", but some phase has declared to run before " + hl.frm.phasename + ". Re-run with -Xgenerate-phase-graph <filename> to better see the problem.")
+          dump("phase-order")
+          throw new FatalError(s"Phase ${hl.frm.phasename} can't follow ${hl.to.phasename}, created phase-order.dot")
         }
       }
 
@@ -153,15 +148,9 @@ trait PhaseAssembly {
           if (sanity.length == 0) {
             throw new FatalError("There is no runs right after dependency, where there should be one! This is not supposed to happen!")
           } else if (sanity.length > 1) {
-            var msg = "Multiple phases want to run right after the phase " + sanity.head.to.phasename + "\n"
-            msg += "Phases: "
-            sanity = sanity sortBy (_.frm.phasename)
-            for (edge <- sanity) {
-              msg += edge.frm.phasename + ", "
-            }
-            msg += "\nRe-run with -Xgenerate-phase-graph <filename> to better see the problem."
-            throw new FatalError(msg)
-
+            dump("phase-order")
+            val following = (sanity map (_.frm.phasename)).sorted mkString ","
+            throw new FatalError(s"Multiple phases want to run right after ${sanity.head.to.phasename}; followers: $following; created phase-order.dot")
           } else {
 
             val promote = hl.to.before.filter(e => (!e.hard))
@@ -199,39 +188,38 @@ trait PhaseAssembly {
         }
       }
     }
+
+    def dump(title: String = "phase-assembly") = graphToDotFile(this, s"$title.dot")
   }
 
-  /* Method called from computePhaseDescriptors in class Global
-   */
-  def buildCompilerFromPhasesSet(): List[SubComponent] = {
+
+  /** Called by Global#computePhaseDescriptors to compute phase order. */
+  def computePhaseAssembly(): List[SubComponent] = {
 
     // Add all phases in the set to the graph
     val graph = phasesSetToDepGraph(phasesSet)
 
+    val dot = if (settings.genPhaseGraph.isSetByUser) Some(settings.genPhaseGraph.value) else None
+
     // Output the phase dependency graph at this stage
-    if (settings.genPhaseGraph.value != "")
-      graphToDotFile(graph, settings.genPhaseGraph.value + "1.dot")
+    def dump(stage: Int) = dot foreach (n => graphToDotFile(graph, s"$n-$stage.dot"))
+
+    dump(1)
 
     // Remove nodes without phaseobj
     graph.removeDanglingNodes()
 
-    // Output the phase dependency graph at this stage
-    if (settings.genPhaseGraph.value != "")
-      graphToDotFile(graph, settings.genPhaseGraph.value + "2.dot")
+    dump(2)
 
     // Validate and Enforce hardlinks / runsRightAfter and promote nodes down the tree
     graph.validateAndEnforceHardlinks()
 
-    // Output the phase dependency graph at this stage
-    if (settings.genPhaseGraph.value != "")
-      graphToDotFile(graph, settings.genPhaseGraph.value + "3.dot")
+    dump(3)
 
     // test for cycles, assign levels and collapse hard links into nodes
     graph.collapseHardLinksAndLevels(graph.getNodeByPhase("parser"), 1)
 
-    // Output the phase dependency graph at this stage
-    if (settings.genPhaseGraph.value != "")
-      graphToDotFile(graph, settings.genPhaseGraph.value + "4.dot")
+    dump(4)
 
     // assemble the compiler
     graph.compilerPhaseList()
@@ -288,16 +276,11 @@ trait PhaseAssembly {
     sbuf.append("digraph G {\n")
     for (edge <- graph.edges) {
       sbuf.append("\"" + edge.frm.allPhaseNames + "(" + edge.frm.level + ")" + "\"->\"" + edge.to.allPhaseNames + "(" + edge.to.level + ")" + "\"")
-      if (! edge.frm.phaseobj.get.head.internal) {
-               extnodes += edge.frm
-      }
-      edge.frm.phaseobj match { case None => null case Some(ln) => if(ln.size > 1) fatnodes += edge.frm }
-      edge.to.phaseobj match { case None => null case Some(ln) => if(ln.size > 1) fatnodes += edge.to }
-      if (edge.hard) {
-        sbuf.append(" [color=\"#0000ff\"]\n")
-      } else {
-        sbuf.append(" [color=\"#000000\"]\n")
-      }
+      if (!edge.frm.phaseobj.get.head.internal) extnodes += edge.frm
+      edge.frm.phaseobj foreach (phobjs => if (phobjs.tail.nonEmpty) fatnodes += edge.frm )
+      edge.to.phaseobj foreach (phobjs => if (phobjs.tail.nonEmpty) fatnodes += edge.to )
+      val color = if (edge.hard) "#0000ff" else "#000000"
+      sbuf.append(s""" [color="$color"]\n""")
     }
     for (node <- extnodes) {
       sbuf.append("\"" + node.allPhaseNames + "(" + node.level + ")" + "\" [color=\"#00ff00\"]\n")
@@ -306,10 +289,7 @@ trait PhaseAssembly {
       sbuf.append("\"" + node.allPhaseNames + "(" + node.level + ")" + "\" [color=\"#0000ff\"]\n")
     }
     sbuf.append("}\n")
-    val out = new BufferedWriter(new FileWriter(filename))
-    out.write(sbuf.toString)
-    out.flush()
-    out.close()
+    import reflect.io._
+    for (d <- settings.outputDirs.getSingleOutput if !d.isVirtual) Path(d.file) / File(filename) writeAll sbuf.toString
   }
-
 }
diff --git a/src/compiler/scala/tools/nsc/SubComponent.scala b/src/compiler/scala/tools/nsc/SubComponent.scala
index 9b8582ae02..b21d156145 100644
--- a/src/compiler/scala/tools/nsc/SubComponent.scala
+++ b/src/compiler/scala/tools/nsc/SubComponent.scala
@@ -19,19 +19,30 @@ abstract class SubComponent {
   /** The name of the phase */
   val phaseName: String
 
-  /** List of phase names, this phase should run after  */
+  /** Names of phases that must run before this phase. */
   val runsAfter: List[String]
 
-  /** List of phase names, this phase should run before  */
+  /** Names of phases that must run after this phase. Default is `Nil`. */
   val runsBefore: List[String] = Nil
 
-  /** Phase name this phase will attach itself to, not allowing any phase to come between it
-   * and the phase name declared  */
+  /** Name of the phase that this phase must follow immediately. */
   val runsRightAfter: Option[String]
 
-  /** Internal flag to tell external from internal phases */
+  /** Names of phases required by this component. Default is `Nil`. */
+  val requires: List[String] = Nil
+
+  /** Is this component enabled? Default is true. */
+  def enabled: Boolean = true
+
+  /** True if this phase is not provided by a plug-in. */
   val internal: Boolean = true
 
+  /** True if this phase runs before all other phases. Usually, `parser`. */
+  val initial: Boolean = false
+
+  /** True if this phase runs after all other phases. Usually, `terminal`. */
+  val terminal: Boolean = false
+
   /** SubComponent are added to a HashSet and two phases are the same if they have the same name  */
   override def hashCode() = phaseName.hashCode()
 
diff --git a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala
index bde17b28fc..c49f23852f 100644
--- a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala
+++ b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala
@@ -18,6 +18,8 @@ abstract class ClosureElimination extends SubComponent {
 
   val phaseName = "closelim"
 
+  override val enabled: Boolean = settings.Xcloselim
+
   /** Create a new phase */
   override def newPhase(p: Phase) = new ClosureEliminationPhase(p)
 
diff --git a/src/compiler/scala/tools/nsc/backend/opt/ConstantOptimization.scala b/src/compiler/scala/tools/nsc/backend/opt/ConstantOptimization.scala
index 43c8527f41..64a0727440 100644
--- a/src/compiler/scala/tools/nsc/backend/opt/ConstantOptimization.scala
+++ b/src/compiler/scala/tools/nsc/backend/opt/ConstantOptimization.scala
@@ -34,6 +34,8 @@ abstract class ConstantOptimization extends SubComponent {
   /** Create a new phase */
   override def newPhase(p: Phase) = new ConstantOptimizationPhase(p)
 
+  override val enabled: Boolean = settings.YconstOptimization
+
   /**
    * The constant optimization phase.
    */
diff --git a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala
index 7511da8b00..193aae37b6 100644
--- a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala
+++ b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala
@@ -22,6 +22,8 @@ abstract class DeadCodeElimination extends SubComponent {
 
   val phaseName = "dce"
 
+  override val enabled: Boolean = settings.Xdce
+
   /** Create a new phase */
   override def newPhase(p: Phase) = new DeadCodeEliminationPhase(p)
 
diff --git a/src/compiler/scala/tools/nsc/backend/opt/InlineExceptionHandlers.scala b/src/compiler/scala/tools/nsc/backend/opt/InlineExceptionHandlers.scala
index cecabda171..f4e97a91d8 100644
--- a/src/compiler/scala/tools/nsc/backend/opt/InlineExceptionHandlers.scala
+++ b/src/compiler/scala/tools/nsc/backend/opt/InlineExceptionHandlers.scala
@@ -57,6 +57,8 @@ abstract class InlineExceptionHandlers extends SubComponent {
   /** Create a new phase */
   override def newPhase(p: Phase) = new InlineExceptionHandlersPhase(p)
 
+  override def enabled = settings.inlineHandlers
+
   /**
     * Inlining Exception Handlers
     */
diff --git a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala
index 09095879bf..181f4bde4e 100644
--- a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala
+++ b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala
@@ -49,6 +49,8 @@ abstract class Inliners extends SubComponent {
 
   val phaseName = "inliner"
 
+  override val enabled: Boolean = settings.inline
+
   /** Debug - for timing the inliner. */
   /****
   private def timed[T](s: String, body: => T): T = {
diff --git a/src/compiler/scala/tools/nsc/plugins/Plugin.scala b/src/compiler/scala/tools/nsc/plugins/Plugin.scala
index 4fd6ba7d9d..1578caff26 100644
--- a/src/compiler/scala/tools/nsc/plugins/Plugin.scala
+++ b/src/compiler/scala/tools/nsc/plugins/Plugin.scala
@@ -41,12 +41,31 @@ abstract class Plugin {
    */
   val global: Global
 
-  /** Handle any plugin-specific options.  The `-P:plugname:` part
-   *  will not be present.
+  def options: List[String] = {
+    // Process plugin options of form plugin:option
+    def namec = name + ":"
+    global.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
    */
-  def processOptions(options: List[String], error: String => Unit) {
-    if (!options.isEmpty)
-      error("Error: " + name + " has no options")
+  def init(options: List[String], error: String => Unit): Boolean = {
+    processOptions(options, error)
+    true
+  }
+
+  @deprecated("use Plugin#init instead", since="2.11")
+  def processOptions(options: List[String], error: String => Unit): Unit = {
+    if (!options.isEmpty) error(s"Error: $name takes no options")
   }
 
   /** A description of this plugin's options, suitable as a response
diff --git a/src/compiler/scala/tools/nsc/plugins/PluginComponent.scala b/src/compiler/scala/tools/nsc/plugins/PluginComponent.scala
index c6e1af7ea4..a6df08c331 100644
--- a/src/compiler/scala/tools/nsc/plugins/PluginComponent.scala
+++ b/src/compiler/scala/tools/nsc/plugins/PluginComponent.scala
@@ -15,12 +15,10 @@ package plugins
  */
 abstract class PluginComponent extends SubComponent {
 
-  /** Internal flag to tell external from internal phases */
+  /** By definition, plugin phases are externally provided. */
   final override val internal = false
 
-  /** Phases supplied by plugins should not have to supply the
-   *  runsRightAfter constraint, but can override it.
-   */
+  /** Only plugins are granted a reprieve from specifying whether they follow. */
   val runsRightAfter: Option[String] = None
 
   /** Useful for -Xshow-phases. */
diff --git a/src/compiler/scala/tools/nsc/plugins/Plugins.scala b/src/compiler/scala/tools/nsc/plugins/Plugins.scala
index 8f7794fa90..4769705404 100644
--- a/src/compiler/scala/tools/nsc/plugins/Plugins.scala
+++ b/src/compiler/scala/tools/nsc/plugins/Plugins.scala
@@ -78,27 +78,18 @@ trait Plugins {
 
     val plugs = pick(roughPluginsList, Set(), (phasesSet map (_.phaseName)).toSet)
 
-    /* Verify requirements are present. */
+    // Verify required plugins are present.
     for (req <- settings.require.value ; if !(plugs exists (_.name == req)))
       globalError("Missing required plugin: " + req)
 
-    /* Process plugin options. */
-    def namec(plug: Plugin) = plug.name + ":"
-    def optList(xs: List[String], p: Plugin) = xs filter (_ startsWith namec(p))
-    def doOpts(p: Plugin): List[String] =
-      optList(settings.pluginOptions.value, p) map (_ stripPrefix namec(p))
+    // Verify no non-existent plugin given with -P
+    for {
+      opt <- settings.pluginOptions.value
+      if !(plugs exists (opt startsWith _.name + ":"))
+    } globalError("bad option: -P:" + opt)
 
-    for (p <- plugs) {
-      val opts = doOpts(p)
-      if (!opts.isEmpty)
-        p.processOptions(opts, globalError)
-    }
-
-    /* Verify no non-existent plugin given with -P */
-    for (opt <- settings.pluginOptions.value ; if plugs forall (p => optList(List(opt), p).isEmpty))
-      globalError("bad option: -P:" + opt)
-
-    plugs
+    // Plugins may opt out, unless we just want to show info
+    plugs filter (p => p.init(p.options, globalError) || (settings.debug && settings.isInfo))
   }
 
   lazy val plugins: List[Plugin] = loadPlugins()
diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
index b37d0ba283..96c93a838b 100644
--- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
@@ -41,6 +41,12 @@ trait ScalaSettings extends AbsScalaSettings
   /** Enabled under -optimise. */
   def optimiseSettings = List[BooleanSetting](inline, inlineHandlers, Xcloselim, Xdce, YconstOptimization)
 
+  /** If any of these settings is enabled, the compiler should print a message and exit.  */
+  def infoSettings = List[Setting](help, Xhelp, Yhelp, showPlugins, showPhases, genPhaseGraph)
+
+  /** Is an info setting set? */
+  def isInfo = infoSettings exists (_.isSetByUser)
+
   /** Internal use - syntax enhancements. */
   private class EnableSettings[T <: BooleanSetting](val s: T) {
     def enabling(toEnable: List[BooleanSetting]): s.type = s withPostSetHook (_ => toEnable foreach (_.value = s.value))