diff --git a/compile/AnalyzingCompiler.scala b/compile/AnalyzingCompiler.scala index eab09fb8c..b6db23b60 100644 --- a/compile/AnalyzingCompiler.scala +++ b/compile/AnalyzingCompiler.scala @@ -20,12 +20,11 @@ final class AnalyzingCompiler(val scalaInstance: xsbti.compile.ScalaInstance, va { val arguments = (new CompilerArguments(scalaInstance, cp))(Nil, classpath, None, options) val output = CompileOutput(singleOutput) - compile(sources, changes, arguments, output, callback, maximumErrors, cache, log, None) + compile(sources, changes, arguments, output, callback, new LoggerReporter(maximumErrors, log), cache, log, None) } - def compile(sources: Seq[File], changes: DependencyChanges, options: Seq[String], output: Output, callback: AnalysisCallback, maximumErrors: Int, cache: GlobalsCache, log: Logger, progressOpt: Option[CompileProgress]): Unit = + def compile(sources: Seq[File], changes: DependencyChanges, options: Seq[String], output: Output, callback: AnalysisCallback, reporter: Reporter, cache: GlobalsCache, log: Logger, progressOpt: Option[CompileProgress]): Unit = { - val reporter = new LoggerReporter(maximumErrors, log) val cached = cache(options.toArray, output, !changes.isEmpty, this, log, reporter) val progress = progressOpt getOrElse IgnoreProgress compile(sources, changes, callback, log, reporter, progress, cached) diff --git a/compile/JavaCompiler.scala b/compile/JavaCompiler.scala index 86cc7cb8b..61bfa1e7d 100644 --- a/compile/JavaCompiler.scala +++ b/compile/JavaCompiler.scala @@ -13,7 +13,7 @@ trait JavaCompiler extends xsbti.compile.JavaCompiler { def apply(sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String])(implicit log: Logger) - def compile(sources: Array[File], classpath: Array[File], output: xsbti.compile.Output, options: Array[String], maxErrors: Int, log: xsbti.Logger): Unit = { + def compile(sources: Array[File], classpath: Array[File], output: xsbti.compile.Output, options: Array[String], log: xsbti.Logger): Unit = { val outputDirectory = output match { case single: xsbti.compile.SingleOutput => single.outputDirectory case _ => throw new RuntimeException("Javac doesn't support multiple output directories") diff --git a/compile/integration/AggressiveCompile.scala b/compile/integration/AggressiveCompile.scala index 3a481d444..4e42d8767 100644 --- a/compile/integration/AggressiveCompile.scala +++ b/compile/integration/AggressiveCompile.scala @@ -14,33 +14,33 @@ import inc._ import CompileSetup._ import sbinary.DefaultProtocol.{ immutableMapFormat, immutableSetFormat, StringFormat } - import xsbti.AnalysisCallback + import xsbti.{ Reporter, AnalysisCallback } import xsbti.api.Source import xsbti.compile.{CompileOrder, DependencyChanges, GlobalsCache, Output, SingleOutput, MultipleOutput, CompileProgress} import CompileOrder.{JavaThenScala, Mixed, ScalaThenJava} final class CompileConfiguration(val sources: Seq[File], val classpath: Seq[File], val previousAnalysis: Analysis, val previousSetup: Option[CompileSetup], val currentSetup: CompileSetup, val progress: Option[CompileProgress], val getAnalysis: File => Option[Analysis], val definesClass: DefinesClass, - val maxErrors: Int, val compiler: AnalyzingCompiler, val javac: xsbti.compile.JavaCompiler, val cache: GlobalsCache) + val reporter: Reporter, val compiler: AnalyzingCompiler, val javac: xsbti.compile.JavaCompiler, val cache: GlobalsCache) class AggressiveCompile(cacheFile: File) { - def apply(compiler: AnalyzingCompiler, javac: xsbti.compile.JavaCompiler, sources: Seq[File], classpath: Seq[File], output: Output, cache: GlobalsCache, progress: Option[CompileProgress] = None, options: Seq[String] = Nil, javacOptions: Seq[String] = Nil, analysisMap: File => Option[Analysis] = { _ => None }, definesClass: DefinesClass = Locate.definesClass _, maxErrors: Int = 100, compileOrder: CompileOrder = Mixed, skip: Boolean = false)(implicit log: Logger): Analysis = + def apply(compiler: AnalyzingCompiler, javac: xsbti.compile.JavaCompiler, sources: Seq[File], classpath: Seq[File], output: Output, cache: GlobalsCache, progress: Option[CompileProgress] = None, options: Seq[String] = Nil, javacOptions: Seq[String] = Nil, analysisMap: File => Option[Analysis] = { _ => None }, definesClass: DefinesClass = Locate.definesClass _, reporter: Reporter, compileOrder: CompileOrder = Mixed, skip: Boolean = false)(implicit log: Logger): Analysis = { val setup = new CompileSetup(output, new CompileOptions(options, javacOptions), compiler.scalaInstance.actualVersion, compileOrder) - compile1(sources, classpath, setup, progress, store, analysisMap, definesClass, compiler, javac, maxErrors, skip, cache) + compile1(sources, classpath, setup, progress, store, analysisMap, definesClass, compiler, javac, reporter, skip, cache) } def withBootclasspath(args: CompilerArguments, classpath: Seq[File]): Seq[File] = args.bootClasspathFor(classpath) ++ args.finishClasspath(classpath) - def compile1(sources: Seq[File], classpath: Seq[File], setup: CompileSetup, progress: Option[CompileProgress], store: AnalysisStore, analysis: File => Option[Analysis], definesClass: DefinesClass, compiler: AnalyzingCompiler, javac: xsbti.compile.JavaCompiler, maxErrors: Int, skip: Boolean, cache: GlobalsCache)(implicit log: Logger): Analysis = + def compile1(sources: Seq[File], classpath: Seq[File], setup: CompileSetup, progress: Option[CompileProgress], store: AnalysisStore, analysis: File => Option[Analysis], definesClass: DefinesClass, compiler: AnalyzingCompiler, javac: xsbti.compile.JavaCompiler, reporter: Reporter, skip: Boolean, cache: GlobalsCache)(implicit log: Logger): Analysis = { val (previousAnalysis, previousSetup) = extract(store.get()) if(skip) previousAnalysis else { - val config = new CompileConfiguration(sources, classpath, previousAnalysis, previousSetup, setup, progress, analysis, definesClass, maxErrors, compiler, javac, cache) + val config = new CompileConfiguration(sources, classpath, previousAnalysis, previousSetup, setup, progress, analysis, definesClass, reporter, compiler, javac, cache) val (modified, result) = compile2(config) if(modified) store.set(result, setup) @@ -69,7 +69,7 @@ class AggressiveCompile(cacheFile: File) val sources = if(order == Mixed) incSrc else scalaSrcs val arguments = cArgs(Nil, absClasspath, None, options.options) timed("Scala compilation", log) { - compiler.compile(sources, changes, arguments, output, callback, maxErrors, cache, log, progress) + compiler.compile(sources, changes, arguments, output, callback, reporter, cache, log, progress) } } def compileJava() = @@ -97,7 +97,7 @@ class AggressiveCompile(cacheFile: File) val loader = ClasspathUtilities.toLoader(searchClasspath) timed("Java compilation", log) { - javac.compile(javaSrcs.toArray, absClasspath.toArray, output, options.javacOptions.toArray, maxErrors, log) + javac.compile(javaSrcs.toArray, absClasspath.toArray, output, options.javacOptions.toArray, log) } def readAPI(source: File, classes: Seq[Class[_]]) { callback.api(source, ClassToAPI(classes)) } diff --git a/compile/integration/IncrementalCompiler.scala b/compile/integration/IncrementalCompiler.scala index 5d0224518..626103563 100644 --- a/compile/integration/IncrementalCompiler.scala +++ b/compile/integration/IncrementalCompiler.scala @@ -17,7 +17,7 @@ object IC extends IncrementalCompiler[Analysis, AnalyzingCompiler] val agg = new AggressiveCompile(setup.cacheFile) val aMap = (f: File) => m2o(analysisMap(f)) val defClass = (f: File) => { val dc = definesClass(f); (name: String) => dc.apply(name) } - agg(scalac, javac, sources, classpath, output, cache, m2o(progress), scalacOptions, javacOptions, aMap, defClass, maxErrors, order, skip)(log) + agg(scalac, javac, sources, classpath, output, cache, m2o(progress), scalacOptions, javacOptions, aMap, defClass, reporter, order, skip)(log) } private[this] def m2o[S](opt: Maybe[S]): Option[S] = if(opt.isEmpty) None else Some(opt.get) diff --git a/interface/src/main/java/xsbti/compile/JavaCompiler.java b/interface/src/main/java/xsbti/compile/JavaCompiler.java index c9947c700..ff6b83cc3 100644 --- a/interface/src/main/java/xsbti/compile/JavaCompiler.java +++ b/interface/src/main/java/xsbti/compile/JavaCompiler.java @@ -9,7 +9,6 @@ import xsbti.Logger; public interface JavaCompiler { /** Compiles Java sources using the provided classpath, output directory, and additional options. - * If supported, the number of reported errors should be limited to `maximumErrors`. * Output should be sent to the provided logger.*/ - void compile(File[] sources, File[] classpath, Output output, String[] options, int maximumErrors, Logger log); + void compile(File[] sources, File[] classpath, Output output, String[] options, Logger log); } diff --git a/interface/src/main/java/xsbti/compile/Options.java b/interface/src/main/java/xsbti/compile/Options.java index 877ff5ebf..78643202d 100644 --- a/interface/src/main/java/xsbti/compile/Options.java +++ b/interface/src/main/java/xsbti/compile/Options.java @@ -22,9 +22,6 @@ public interface Options /** The options to pass to the Java compiler other than the sources and classpath to use. */ String[] javacOptions(); - /** The maximum number of errors that the Scala compiler should report.*/ - int maxErrors(); - /** Controls the order in which Java and Scala sources are compiled.*/ CompileOrder order(); } diff --git a/interface/src/main/java/xsbti/compile/Setup.java b/interface/src/main/java/xsbti/compile/Setup.java index 1efc08782..050e20c2f 100644 --- a/interface/src/main/java/xsbti/compile/Setup.java +++ b/interface/src/main/java/xsbti/compile/Setup.java @@ -2,6 +2,7 @@ package xsbti.compile; import java.io.File; import xsbti.Maybe; +import xsbti.Reporter; /** Configures incremental recompilation. */ public interface Setup @@ -26,4 +27,7 @@ public interface Setup /** If returned, the progress that should be used to report scala compilation to. */ Maybe progress(); + + /** The reporter that should be used to report scala compilation to. */ + Reporter reporter(); } diff --git a/main/actions/Compiler.scala b/main/actions/Compiler.scala index 7d6da3c4c..79383554e 100644 --- a/main/actions/Compiler.scala +++ b/main/actions/Compiler.scala @@ -76,6 +76,6 @@ object Compiler import in.incSetup._ val agg = new AggressiveCompile(cacheFile) - agg(scalac, javac, sources, classpath, CompileOutput(classesDirectory), cache, None, options, javacOptions, analysisMap, definesClass, maxErrors, order, skip)(log) + agg(scalac, javac, sources, classpath, CompileOutput(classesDirectory), cache, None, options, javacOptions, analysisMap, definesClass, new LoggerReporter(maxErrors, log), order, skip)(log) } }