val graph = DependencyGraph(phasesSet, warnAll = !settings.isScaladoc || settings.isDebug)

graph.compilerPhaseList().tap(_ => graph.warnings.foreach(msg => reporter.warning(NoPosition, msg)))

import DependencyGraph.{Follows, FollowsNow, Weight}

require(components.contains(start), s"Start $start is not a component in ${components.keys.mkString(", ")}")

private final val debugging = false

case _ => // ignore duplicate

// input must be acyclic and a vertex can have only one outgoing FollowsNow edge

// check reachability

for (i <- 0.until(order) if !seen(i)) {

warning(s"Phase ${names(i)} is not reachable from $start")

addEdge(start, names(i), Follows)

walk() // check cycles

}

def namedEdge(e: Edge): String = if (e == null) "[no edge]" else s"${names(e.from)}<${distance(e.from)}> ${if (e.weight == FollowsNow) "=" else "-"}> ${names(e.to)}<${distance(e.to)}>"

if (debugging) println(s"deq ${names(v)}")

if (debugging) println(s"update ${namedEdge(e)} dist = ${distance(w)}, enq ${names(w)}")

if (debugging) edgeTo.foreach(e => println(namedEdge(e)))

val di = distance.zipWithIndex // pairs (distance, node)

di.groupBy(_._1).toArray.sortBy(_._1).iterator // group by distance, sorted by distance

.flatMap { case (d@_, dis) =>

}.toList

private val compilerPhases = List(

"parser", "namer", "packageobjects", "typer", "superaccessors", "extmethods", "pickler",

"refchecks", "patmat", "uncurry", "fields", "tailcalls", "specialize", "explicitouter",

"erasure", "posterasure", "lambdalift", "constructors", "flatten", "mixin", "cleanup",

"delambdafy", "jvm", "terminal",

)

def apply(components: Iterable[SubComponent], warnAll: Boolean = true): DependencyGraph = {

val phases = components.toArray

val phaseNames = components.iterator.map(_.phaseName).toSet

def isPhaseName(s: String): Boolean = phaseNames.contains(s)

val constraints = ListBuffer.empty[(String, String, Weight)]

def addConstraint(from: String, to: String, weight: Weight): Unit = constraints.addOne((from, to, weight))

val warnings = ListBuffer.empty[String]

var i = 0

while (i < phases.length) {

val p = phases(i)

require(p.phaseName.nonEmpty, "Phase name must be non-empty.")

var constrained = false

var badConstraint = false

def checkConstraint(name: String, constraint: String, warn: Boolean): Boolean = isPhaseName(name).tap { ok =>

if (!ok && warn) {

val help = if (compilerPhases.contains(name)) "" else

compilerPhases.filter(util.EditDistance.levenshtein(name, _) < 3) match {

case Nil => ""

case close => s" - did you mean ${util.StringUtil.oxford(close, "or")}?"

}

warnings.addOne(s"No phase `$name` for ${p.phaseName}.$constraint$help")

badConstraint = true

}

// add edges for each constraint

for (after <- p.runsRightAfter if after.nonEmpty && checkConstraint(after, "runsRightAfter", warn=true)) {

addConstraint(after, p.phaseName, FollowsNow)

constrained = true

}

for (after <- p.runsAfter if after.nonEmpty && !p.runsRightAfter.contains(after) && checkConstraint(after, "runsAfter", warn=true)) {

addConstraint(after, p.phaseName, Follows)

constrained = true

}

for (before <- p.runsBefore if before.nonEmpty && checkConstraint(before, "runsBefore", warn=warnAll)) {

addConstraint(p.phaseName, before, Follows)

constrained = true

}

// if it doesn't follow a phase in the run, replace this component with a no-op that follows start

if ((!constrained || badConstraint) && p != start && p != end) {

phases(i) = new SubComponent {

val global = p.global

val phaseName = p.phaseName

val runsAfter = start.phaseName :: Nil

val runsRightAfter = None

def newPhase(prev: Phase): Phase = new Phase(prev) {

val name = phaseName

def run() = ()

}

}

addConstraint(start.phaseName, p.phaseName, Follows)

if (warnAll) warnings.addOne(s"Component ${p.phaseName} dropped due to bad or missing constraint")

}

// terminal follows every phase; parser is not before every phase because traverse uses edgeTo to find "anchors"

if (p != end || p == end && p == start)

addConstraint(p.phaseName, end.phaseName, Follows)

i += 1

}

new DependencyGraph(phases.size, start.phaseName, phases.iterator.map(p => p.phaseName -> p).toMap).tap { graph =>

for ((from, to, weight) <- constraints)

graph.addEdge(from, to, weight)

for (warning <- warnings)

graph.warning(warning)

warning: No phase `refchicks` for ploogin.runsAfter - did you mean refchecks?

warning: No phase `java` for ploogin.runsBefore - did you mean jvm?

warning: Component ploogin dropped due to bad or missing constraint

override val runsBefore = List("java")

warning: Phase ploogin is not reachable from parser

phase name id description

---------- -- -----------

parser 1 parse source into ASTs, perform simple desugaring

namer 2 resolve names, attach symbols to named trees

packageobjects 3 load package objects

typer 4 the meat and potatoes: type the trees

ploogin 5 A phase that another phase must run before.

superaccessors 6 add super accessors in traits and nested classes

extmethods 7 add extension methods for inline classes

pickler 8 serialize symbol tables

refchecks 9 reference/override checking, translate nested objects

patmat 10 translate match expressions

uncurry 11 uncurry, translate function values to anonymous classes

fields 12 synthesize accessors and fields, add bitmaps for lazy vals

tailcalls 13 replace tail calls by jumps

specialize 14 @specialized-driven class and method specialization

explicitouter 15 this refs to outer pointers

erasure 16 erase types, add interfaces for traits

posterasure 17 clean up erased inline classes

lambdalift 18 move nested functions to top level

constructors 19 move field definitions into constructors

flatten 20 eliminate inner classes

mixin 21 mixin composition

cleanup 22 platform-specific cleanups, generate reflective calls

delambdafy 23 remove lambdas

jvm 24 generate JVM bytecode

terminal 25 the last phase during a compilation run

package t8755

import scala.tools.nsc.{Global, Phase}

import scala.tools.nsc.plugins.{Plugin, PluginComponent}

import scala.reflect.io.Path

import scala.reflect.io.File

class Ploogin(val global: Global) extends Plugin {

import global._

val name = "ploogin"

val description = "A sample plugin for testing."

val components = List[PluginComponent](TestComponent)

private object TestComponent extends PluginComponent {

val global: Ploogin.this.global.type = Ploogin.this.global

override val runsBefore = List("erasure")

val runsAfter = Nil

val phaseName = Ploogin.this.name

override def description = "A phase that another phase must run before."

def newPhase(prev: Phase) = new TestPhase(prev)

class TestPhase(prev: Phase) extends StdPhase(prev) {

override def description = TestComponent.this.description

def apply(unit: CompilationUnit): Unit = ()

}

}

}

package sample

object Sample extends App {

}

<plugin>

<name>ploogin</name>

<classname>t8755.Ploogin</classname>

</plugin>

warning: No phase `refchecks` for ploogin.runsAfter

parser -> namer -> packageobjects -> typer -> ploogin -> terminal

super.newDocFactory.tap(df => println(df.compiler.phaseNames.mkString(" -> ")))

def apply(unit: CompilationUnit): Unit = ???

warning: No phase `refchecks` for ploogin.runsAfter

parser -> namer -> packageobjects -> typer -> ploogin -> terminal

super.newDocFactory.tap(df => println(df.compiler.phaseNames.mkString(" -> ")))

def apply(unit: CompilationUnit): Unit = ???

warning: No phase `refchecks` for ploogin.runsBefore

warning: Component ploogin dropped due to bad or missing constraint

parser -> namer -> packageobjects -> typer -> ploogin -> terminal

[running phase parser on newSource]

[running phase namer on newSource]

[running phase packageobjects on newSource]

[running phase typer on newSource]

override def scaladocSettings = s"-Xplugin:$testOutput -Xplugin-require:ploogin -Vdebug"

super.newDocFactory.tap(df => println(df.compiler.phaseNames.mkString(" -> ")))