WIP PipelineMain

Author: retronym

src/compiler/scala/tools/nsc/PipelineMain.scala

@@ -0,0 +1,91 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2018 LAMP/EPFL
+ * @author  Martin Odersky
+ */
+package scala.tools.nsc
+
+import java.nio.file.{Files, Path, Paths}
+
+import scala.collection.mutable
+import scala.reflect.internal.util.FakePos
+import scala.tools.nsc.reporters.Reporter
+import scala.tools.nsc.util.ClassPath
+
+
+class PipelineMainClass {
+  /** Forward errors to the (current) reporter. */
+  protected def scalacError(msg: String): Unit = {
+    reporter.error(FakePos("scalac"), msg + "\n  scalac -help  gives more information")
+  }
+
+  private var reporter: Reporter = _
+  def process(args: Array[String]): Boolean = {
+    reporter = Reporter(new Settings(scalacError))
+
+    def commandFor(argFileArg: String): CompilerCommand = {
+      val ss   = new Settings(scalacError)
+      new CompilerCommand(args.toList, ss)
+    }
+    val projects: List[CompilerCommand] = args.toList.map(commandFor)
+    val produces = mutable.HashMap[Path, CompilerCommand]()
+    for (p <- projects) {
+      val outputDir = p.settings.outputDirs.getSingleOutput.get.file.toPath.toAbsolutePath.normalize()
+      produces(outputDir) = p
+    }
+    val dependsOn = mutable.HashMap[CompilerCommand, List[CompilerCommand]]()
+    for (p <- projects) {
+      val value: Seq[String] = ClassPath.expandPath(p.settings.classpath.value, expandStar = true)
+      dependsOn(p) = value.flatMap(s => produces.get(Paths.get(s).toAbsolutePath.normalize())).toList
+    }
+    var toProcess = projects.toList
+    val done = mutable.HashSet[CompilerCommand]()
+    while (toProcess.nonEmpty) {
+      val (nextRound, blocked) = toProcess.partition(x => dependsOn.getOrElse(x, Nil).forall(done))
+      toProcess = blocked
+      for (p <- nextRound) {
+        if (!compile(p)) return false
+        done += p
+      }
+    }
+    true
+  }
+
+  def compile(command: CompilerCommand): Boolean = {
+    val compiler = newCompiler(command.settings)
+    reporter     = compiler.reporter
+    try {
+      if (reporter.hasErrors)
+        reporter.flush()
+      else if (command.shouldStopWithInfo)
+        reporter.echo(command.getInfoMessage(compiler))
+      else
+        doCompile(command, compiler)
+    } catch {
+      case ex: Throwable =>
+        compiler.reportThrowable(ex)
+        ex match {
+          case FatalError(msg)  => // signals that we should fail compilation.
+          case _                => throw ex // unexpected error, tell the outside world.
+        }
+    }
+    !reporter.hasErrors
+  }
+
+  protected def newCompiler(settings: Settings): Global = Global(settings)
+
+  protected def doCompile(command: CompilerCommand, compiler: Global): Unit = {
+    if (command.files.isEmpty) {
+      reporter.echo(command.usageMsg)
+      reporter.echo(compiler.pluginOptionsHelp)
+    } else {
+      val run = new compiler.Run()
+      run compile command.files
+      reporter.finish()
+    }
+  }
+
+
+  def main(args: Array[String]): Unit = System.exit(if (process(args)) 0 else 1)
+}
+
+object PipelineMain extends PipelineMainClass {}