WIP pipeline main works in sequential mode

Author: retronym

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

@@ -22,33 +22,40 @@ class PipelineMainClass {
   def process(args: Array[String]): Boolean = {
     reporter = new ConsoleReporter(new Settings(scalacError))
 
-    def commandFor(argFileArg: String): CompilerCommand = {
+    def commandFor(argFileArg: String): Task = {
       val ss   = new Settings(scalacError)
-      new CompilerCommand(args.toList, ss)
+      Task(argFileArg, new CompilerCommand(("@" + argFileArg) :: Nil, ss))
     }
-    val projects: List[CompilerCommand] = args.toList.map(commandFor)
-    val produces = mutable.HashMap[Path, CompilerCommand]()
+    val projects: List[Task] = args.toList.map(commandFor)
+    val produces = mutable.HashMap[Path, Task]()
     for (p <- projects) {
-      val outputDir = p.settings.outputDirs.getSingleOutput.get.file.toPath.toAbsolutePath.normalize()
+      val outputDir = p.command.settings.outputDirs.getSingleOutput.get.file.toPath.toAbsolutePath.normalize()
       produces(outputDir) = p
     }
-    val dependsOn = mutable.HashMap[CompilerCommand, List[CompilerCommand]]()
+    val dependsOn = mutable.HashMap[Task, List[Task]]()
     for (p <- projects) {
-      val value: Seq[String] = ClassPath.expandPath(p.settings.classpath.value, expandStar = true)
+      val value: Seq[String] = ClassPath.expandPath(p.command.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]()
+    val done = mutable.HashSet[Task]()
+    var round = 0
     while (toProcess.nonEmpty) {
+      round += 1
       val (nextRound, blocked) = toProcess.partition(x => dependsOn.getOrElse(x, Nil).forall(done))
+      if (nextRound.isEmpty) throw new RuntimeException("cyclic dependency")
       toProcess = blocked
       for (p <- nextRound) {
-        if (!compile(p)) return false
+        println(s"Round #$round: ${p.argsFile}")
+        if (!compile(p.command)) return false
         done += p
       }
     }
     true
   }
+  private case class Task(argsFile: String, command: CompilerCommand) {
+    override def toString: String = argsFile
+  }
 
   def compile(command: CompilerCommand): Boolean = {
     val compiler = newCompiler(command.settings)