WIP refine

Author: retronym

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

@@ -99,18 +99,26 @@ class PipelineMainClass {
       toProcess = blocked
       for (p <- nextRound) {
         println(s"Round #$round: ${p.argsFile}")
-        if (!compile(p.command)) return false
+        if (!compile(p)) return false
         done += p
+        println(f"Done: outline typing ${p.outlineDurationMs}%.2f ms, full compilation ${p.regularDurationMs}%.2f ms")
       }
     }
     true
   }
 
   private case class Task(argsFile: String, command: CompilerCommand) {
     override def toString: String = argsFile
+    var start: Long = 0
+    var outlineEnd: Long = 0
+    var regularStart: Long = 0
+    var regularEnd: Long = 0
+    def outlineDurationMs: Double = (outlineEnd - start).toDouble / 1000 / 1000
+    def regularDurationMs: Double = (regularEnd - regularStart).toDouble / 1000 / 1000
   }
 
-  def compile(command: CompilerCommand): Boolean = {
+  def compile(task: Task): Boolean = {
+    import task.command
     val compiler = newCompiler(command.settings)
     reporter     = compiler.reporter
     try {
@@ -119,7 +127,7 @@ class PipelineMainClass {
       else if (command.shouldStopWithInfo)
         reporter.echo(command.getInfoMessage(compiler))
       else
-        doCompile(command, compiler)
+        doCompile(task, compiler)
     } catch {
       case ex: Throwable =>
         compiler.reportThrowable(ex)
@@ -168,38 +176,50 @@ class PipelineMainClass {
     g
   }
 
-  protected def doCompile(command: CompilerCommand, compiler: Global): Unit = {
+  protected def doCompile(task: Task, compiler: Global): Unit = {
+    import task.command
     if (command.files.isEmpty) {
       reporter.echo(command.usageMsg)
       reporter.echo(compiler.pluginOptionsHelp)
     } else {
-      println("outline typing")
-      command.settings.Youtline.value = true
-      command.settings.stopAfter.value = List("pickler")
-      val run1 = new compiler.Run()
-      run1 compile command.files
-      reporter.finish()
-      if (!reporter.hasErrors) {
-        println("regular compilation")
+      def outlineCompile(): Unit = {
+        command.settings.Youtline.value = true
+        command.settings.stopAfter.value = List("pickler")
+        val run1 = new compiler.Run()
+        run1 compile command.files
+        allPickleData.put(command.settings.outputDirs.getSingleOutput.get.file.toPath.toRealPath().normalize(), new PickleClassPath(run1.symData))
+        reporter.finish()
+      }
+      def fullCompile(): Unit = {
         command.settings.Youtline.value = false
         command.settings.stopAfter.value = Nil
         val compiler2 = newCompiler(command.settings)
-        allPickleData.put(command.settings.outputDirs.getSingleOutput.get.file.toPath.toRealPath().normalize(), new PickleClassPath(run1.symData))
         val run2 = new compiler2.Run()
         run2 compile command.files
         compiler2.reporter.finish()
       }
+
+      task.start = System.nanoTime()
+      outlineCompile()
+      task.outlineEnd = System.nanoTime()
+      if (!reporter.hasErrors) {
+
+        task.regularStart = System.nanoTime()
+        fullCompile()
+        task.regularEnd = System.nanoTime()
+      }
     }
   }
+}
 
+object PipelineMain {
   def main(args: Array[String]): Unit = {
     for (i <- 1 to 10) {
-      val result = process(args)
+      val result = new PipelineMainClass().process(args)
       if (!result)
         System.exit(1)
     }
     System.exit(0)
   }
 }
 
-object PipelineMain extends PipelineMainClass {}

src/compiler/scala/tools/nsc/typechecker/Analyzer.scala

@@ -104,11 +104,13 @@ trait Analyzer extends AnyRef
         try {
           val typer = newTyper(rootContext(unit))
           unit.body = typer.typed(unit.body)
-          for (workItem <- unit.toCheck) workItem()
-          if (settings.warnUnusedImport)
-            warnUnusedImports(unit)
-          if (settings.warnUnused.isSetByUser)
-            new checkUnused(typer).apply(unit)
+          if (!settings.Youtline.value) {
+            for (workItem <- unit.toCheck) workItem()
+            if (settings.warnUnusedImport)
+              warnUnusedImports(unit)
+            if (settings.warnUnused.isSetByUser)
+              new checkUnused(typer).apply(unit)
+          }
         }
         finally {
           unit.toCheck.clear()