Emits SourceInfos when incremental compilation fails

internal/compiler-bridge/src/main/scala/xsbt/CompilerBridge.scala

@@ -18,6 +18,8 @@ import scala.collection.mutable
 import scala.reflect.io.AbstractFile
 import scala.tools.nsc.CompilerCommand
 import Log.debug
+import xsbti.compile.analysis.ReadSourceInfos
+
 import java.io.File
 
 /**
@@ -49,6 +51,16 @@ class InterfaceCompileFailed(
     override val toString: String
 ) extends xsbti.CompileFailed
 
+class InterfaceCompileFailed2(
+    val arguments: Array[String],
+    val sourceInfos: ReadSourceInfos,
+    override val toString: String
+) extends xsbti.CompileFailed2 {
+  import scala.collection.JavaConverters._
+  val problems: Array[Problem] =
+    sourceInfos.getAllSourceInfos.values().asScala.flatMap(_.getReportedProblems).toArray
+}
+
 class InterfaceCompileCancelled(val arguments: Array[String], override val toString: String)
     extends xsbti.CompileCancelled
 
@@ -180,8 +192,10 @@ private final class CachedCompiler0(
     }
 
     underlyingReporter.printSummary()
-    if (!noErrors(underlyingReporter))
-      handleErrors(underlyingReporter, log)
+    if (!noErrors(underlyingReporter)) {
+      val infos = callback.getSourceInfos
+      handleErrors(infos, log)
+    }
 
     // the case where we cancelled compilation _after_ some compilation errors got reported
     // will be handled by line above so errors still will be reported properly just potentially not
@@ -195,6 +209,11 @@ private final class CachedCompiler0(
     throw new InterfaceCompileFailed(args, dreporter.problems, "Compilation failed")
   }
 
+  def handleErrors(sourceInfos: ReadSourceInfos, log: Logger): Nothing = {
+    debug(log, "Compilation failed (CompilerInterface)")
+    throw new InterfaceCompileFailed2(args, sourceInfos, "Compilation failed")
+  }
+
   def handleCompilationCancellation(dreporter: DelegatingReporter, log: Logger): Nothing = {
     assert(dreporter.cancelled, "We should get here only if when compilation got cancelled")
     debug(log, "Compilation cancelled (CompilerInterface)")

internal/compiler-interface/src/main/java/xsbti/AnalysisCallback.java

@@ -12,6 +12,7 @@
 package xsbti;
 
 import xsbti.api.DependencyContext;
+import xsbti.compile.analysis.ReadSourceInfos;
 
 import java.io.File;
 import java.nio.file.Path;
@@ -260,4 +261,6 @@ void problem(String what,
     boolean isPickleJava();
 
     Optional<T2<Path, Path>> getPickleJarPair();
+
+    ReadSourceInfos getSourceInfos();
 }

internal/compiler-interface/src/main/java/xsbti/CompileFailed2.java

@@ -0,0 +1,7 @@
+package xsbti;
+
+import xsbti.compile.analysis.ReadSourceInfos;
+
+public abstract class CompileFailed2 extends CompileFailed {
+    public abstract ReadSourceInfos sourceInfos();
+}

internal/zinc-core/src/main/scala/sbt/internal/inc/Incremental.scala

@@ -1068,6 +1068,25 @@ private final class AnalysisCallback(
     }
   }
 
+  def getSourceInfos: SourceInfos = {
+    // Collect Source Info from current run
+    val sources = reporteds.keySet ++ unreporteds.keySet ++ mainClasses.keySet
+    val sourceToInfo = sources.map { source =>
+      val info = SourceInfos.makeInfo(
+        getOrNil(reporteds.iterator.map { case (k, v) => k -> v.asScala.toSeq }.toMap, source),
+        getOrNil(unreporteds.iterator.map { case (k, v) => k -> v.asScala.toSeq }.toMap, source),
+        getOrNil(mainClasses.iterator.map { case (k, v) => k -> v.asScala.toSeq }.toMap, source)
+      )
+      (source, info)
+    }.toMap
+    val sourceInfoFromCurrentRun = new MSourceInfos(sourceToInfo)
+    // Collect reported problems from previous run
+    incHandlerOpt.map(_.previousAnalysisPruned) match {
+      case Some(prevAnalysis) => prevAnalysis.infos ++ sourceInfoFromCurrentRun
+      case None               => sourceInfoFromCurrentRun
+    }
+  }
+
   override def apiPhaseCompleted(): Unit = {
     // If we know we're done with cycles (presumably because all sources were invalidated) we can store early analysis
     // and picke data now.  Otherwise, we need to wait for dependency information to decide if there are more cycles.

internal/zinc-core/src/main/scala/sbt/internal/inc/SourceInfo.scala

@@ -69,7 +69,7 @@ object SourceInfos {
   }
 }
 
-private final class MSourceInfos(val allInfos: Map[VirtualFileRef, SourceInfo])
+private[inc] final class MSourceInfos(val allInfos: Map[VirtualFileRef, SourceInfo])
     extends SourceInfos {
 
   def ++(o: SourceInfos) = {

internal/zinc-testing/src/main/scala/xsbti/TestCallback.scala

@@ -15,8 +15,8 @@ import java.io.File
 import java.nio.file.Path
 import java.{ util => ju }
 import ju.Optional
-
-import xsbti.api.{ DependencyContext, ClassLike }
+import xsbti.api.{ ClassLike, DependencyContext }
+import xsbti.compile.analysis.ReadSourceInfos
 
 import scala.collection.mutable.ArrayBuffer
 
@@ -153,6 +153,8 @@ class TestCallback extends AnalysisCallback2 {
   override def isPickleJava: Boolean = false
 
   override def getPickleJarPair = Optional.empty()
+
+  override def getSourceInfos: ReadSourceInfos = null
 }
 
 object TestCallback {