From 4fe0c02536ef86412da67f9dd7879e9443538843 Mon Sep 17 00:00:00 2001 From: Grzegorz Kossakowski Date: Wed, 16 Jan 2013 21:39:56 -0800 Subject: [PATCH] Break long argument list into multiple lines. Some methods take a lot of arguments and I'm about to add one more which will make them too long for easy reading. This change is changes code formatting only. That's done on purpose to make it easier to review other changes. --- .../inc/src/main/scala/sbt/inc/Compile.scala | 6 +++- .../src/main/scala/sbt/inc/Incremental.scala | 11 +++++-- .../sbt/compiler/AggressiveCompile.scala | 31 ++++++++++++++++--- .../actions/src/main/scala/sbt/Compiler.scala | 3 +- 4 files changed, 43 insertions(+), 8 deletions(-) diff --git a/compile/inc/src/main/scala/sbt/inc/Compile.scala b/compile/inc/src/main/scala/sbt/inc/Compile.scala index df79a9b24..582008cac 100644 --- a/compile/inc/src/main/scala/sbt/inc/Compile.scala +++ b/compile/inc/src/main/scala/sbt/inc/Compile.scala @@ -12,7 +12,11 @@ import java.io.File object IncrementalCompile { - def apply(sources: Set[File], entry: String => Option[File], compile: (Set[File], DependencyChanges, xsbti.AnalysisCallback) => Unit, previous: Analysis, forEntry: File => Option[Analysis], output: Output, log: Logger): (Boolean, Analysis) = + def apply(sources: Set[File], entry: String => Option[File], + compile: (Set[File], DependencyChanges, xsbti.AnalysisCallback) => Unit, + previous: Analysis, + forEntry: File => Option[Analysis], + output: Output, log: Logger): (Boolean, Analysis) = { val current = Stamps.initial(Stamp.exists, Stamp.hash, Stamp.lastModified) val internalMap = (f: File) => previous.relations.produced(f).headOption diff --git a/compile/inc/src/main/scala/sbt/inc/Incremental.scala b/compile/inc/src/main/scala/sbt/inc/Incremental.scala index d2047e94f..811a0cc51 100644 --- a/compile/inc/src/main/scala/sbt/inc/Incremental.scala +++ b/compile/inc/src/main/scala/sbt/inc/Incremental.scala @@ -16,7 +16,13 @@ object Incremental final val TransitiveStep = 2 final val RecompileAllFraction = 0.5 - def compile(sources: Set[File], entry: String => Option[File], previous: Analysis, current: ReadStamps, forEntry: File => Option[Analysis], doCompile: (Set[File], DependencyChanges) => Analysis, log: Logger)(implicit equivS: Equiv[Stamp]): (Boolean, Analysis) = + def compile(sources: Set[File], + entry: String => Option[File], + previous: Analysis, + current: ReadStamps, + forEntry: File => Option[Analysis], + doCompile: (Set[File], DependencyChanges) => Analysis, + log: Logger)(implicit equivS: Equiv[Stamp]): (Boolean, Analysis) = { val initialChanges = changedInitial(entry, sources, previous, current, forEntry) val binaryChanges = new DependencyChanges { @@ -33,7 +39,8 @@ object Incremental val incDebugProp = "xsbt.inc.debug" // TODO: the Analysis for the last successful compilation should get returned + Boolean indicating success // TODO: full external name changes, scopeInvalidations - def cycle(invalidatedRaw: Set[File], allSources: Set[File], binaryChanges: DependencyChanges, previous: Analysis, doCompile: (Set[File], DependencyChanges) => Analysis, cycleNum: Int, log: Logger): Analysis = + def cycle(invalidatedRaw: Set[File], allSources: Set[File], binaryChanges: DependencyChanges, previous: Analysis, + doCompile: (Set[File], DependencyChanges) => Analysis, cycleNum: Int, log: Logger): Analysis = if(invalidatedRaw.isEmpty) previous else diff --git a/compile/integration/src/main/scala/sbt/compiler/AggressiveCompile.scala b/compile/integration/src/main/scala/sbt/compiler/AggressiveCompile.scala index 6aa9dfb58..dc48a5d3b 100644 --- a/compile/integration/src/main/scala/sbt/compiler/AggressiveCompile.scala +++ b/compile/integration/src/main/scala/sbt/compiler/AggressiveCompile.scala @@ -25,22 +25,45 @@ final class CompileConfiguration(val sources: Seq[File], val classpath: Seq[File 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 _, reporter: Reporter, 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, reporter, 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, reporter: Reporter, 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, reporter, 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) diff --git a/main/actions/src/main/scala/sbt/Compiler.scala b/main/actions/src/main/scala/sbt/Compiler.scala index 3a2a431a4..779474043 100644 --- a/main/actions/src/main/scala/sbt/Compiler.scala +++ b/main/actions/src/main/scala/sbt/Compiler.scala @@ -76,7 +76,8 @@ object Compiler import in.incSetup._ val agg = new AggressiveCompile(cacheFile) - agg(scalac, javac, sources, classpath, CompileOutput(classesDirectory), cache, None, options, javacOptions, analysisMap, definesClass, new LoggerReporter(maxErrors, log, sourcePositionMapper), order, skip)(log) + agg(scalac, javac, sources, classpath, CompileOutput(classesDirectory), cache, None, options, javacOptions, + analysisMap, definesClass, new LoggerReporter(maxErrors, log, sourcePositionMapper), order, skip)(log) } private[sbt] def foldMappers[A](mappers: Seq[A => Option[A]]) =