diff --git a/compile/inc/CompileSetup.scala b/compile/inc/CompileSetup.scala index ef52a8342..2c9b15712 100644 --- a/compile/inc/CompileSetup.scala +++ b/compile/inc/CompileSetup.scala @@ -2,9 +2,8 @@ * Copyright 2010 Mark Harrah */ package sbt -package inc -import java.io.File + import java.io.File object CompileOrder extends Enumeration { diff --git a/main/AggressiveCompile.scala b/main/AggressiveCompile.scala index e7f8b2911..39def00ad 100644 --- a/main/AggressiveCompile.scala +++ b/main/AggressiveCompile.scala @@ -12,6 +12,7 @@ import inc._ import xsbti.api.Source import xsbti.AnalysisCallback import CompileSetup._ + import CompileOrder.{JavaThenScala, Mixed, ScalaThenJava} import sbinary.DefaultProtocol.{ immutableMapFormat, immutableSetFormat, StringFormat } final class CompileConfiguration(val sources: Seq[File], val classpath: Seq[File], @@ -20,9 +21,9 @@ final class CompileConfiguration(val sources: Seq[File], val classpath: Seq[File class AggressiveCompile(cacheDirectory: File) { - def apply(compiler: AnalyzingCompiler, javac: JavaCompiler, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String] = Nil, javacOptions: Seq[String] = Nil, analysisMap: Map[File, Analysis] = Map.empty, maxErrors: Int = 100)(implicit log: Logger): Analysis = + def apply(compiler: AnalyzingCompiler, javac: JavaCompiler, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String] = Nil, javacOptions: Seq[String] = Nil, analysisMap: Map[File, Analysis] = Map.empty, maxErrors: Int = 100, compileOrder: CompileOrder.Value = Mixed)(implicit log: Logger): Analysis = { - val setup = new CompileSetup(outputDirectory, new CompileOptions(options, javacOptions), compiler.scalaInstance.actualVersion, CompileOrder.Mixed) + val setup = new CompileSetup(outputDirectory, new CompileOptions(options, javacOptions), compiler.scalaInstance.actualVersion, compileOrder) compile1(sources, classpath, setup, store, analysisMap, compiler, javac, maxErrors) } @@ -57,20 +58,24 @@ class AggressiveCompile(cacheDirectory: File) val incSrc = sources.filter(include) val (javaSrcs, scalaSrcs) = incSrc partition javaOnly println("Compiling:\n\t" + incSrc.mkString("\n\t")) - if(!scalaSrcs.isEmpty) - { - val arguments = cArgs(incSrc, absClasspath, outputDirectory, options.options) - compiler.compile(arguments, callback, maxErrors, log) - } - if(!javaSrcs.isEmpty) - { - import Path._ - val loader = ClasspathUtilities.toLoader(absClasspath, compiler.scalaInstance.loader) - def readAPI(source: File, classes: Seq[Class[_]]) { callback.api(source, ClassToAPI(classes)) } - Analyze(outputDirectory, javaSrcs, log)(callback, loader, readAPI) { - javac(javaSrcs, absClasspath, outputDirectory, options.javacOptions) + def compileScala() = + if(!scalaSrcs.isEmpty) + { + val sources = if(order == Mixed) incSrc else scalaSrcs + val arguments = cArgs(sources, absClasspath, outputDirectory, options.options) + compiler.compile(arguments, callback, maxErrors, log) } - } + def compileJava() = + if(!javaSrcs.isEmpty) + { + import Path._ + val loader = ClasspathUtilities.toLoader(absClasspath, compiler.scalaInstance.loader) + def readAPI(source: File, classes: Seq[Class[_]]) { callback.api(source, ClassToAPI(classes)) } + Analyze(outputDirectory, javaSrcs, log)(callback, loader, readAPI) { + javac(javaSrcs, absClasspath, outputDirectory, options.javacOptions) + } + } + if(order == ScalaThenJava) { compileScala(); compileJava() } else { compileJava(); compileScala() } } val sourcesSet = sources.toSet diff --git a/main/Compiler.scala b/main/Compiler.scala index a4081aeed..1d65be33d 100644 --- a/main/Compiler.scala +++ b/main/Compiler.scala @@ -23,22 +23,22 @@ object Compiler } final class Inputs(val compilers: Compilers, val config: Options, val incSetup: IncSetup) - final class Options(val classpath: Seq[File], val sources: Seq[File], val classesDirectory: File, val options: Seq[String], val javacOptions: Seq[String], val maxErrors: Int) + final class Options(val classpath: Seq[File], val sources: Seq[File], val classesDirectory: File, val options: Seq[String], val javacOptions: Seq[String], val maxErrors: Int, val order: CompileOrder.Value) final class IncSetup(val analysisMap: Map[File, Analysis], val cacheDirectory: File) final class Compilers(val scalac: AnalyzingCompiler, val javac: JavaCompiler) - def inputs(classpath: Seq[File], sources: Seq[File], outputDirectory: File, options: Seq[String], javacOptions: Seq[String], maxErrors: Int)(implicit compilers: Compilers, log: Logger): Inputs = + def inputs(classpath: Seq[File], sources: Seq[File], outputDirectory: File, options: Seq[String], javacOptions: Seq[String], maxErrors: Int, order: CompileOrder.Value)(implicit compilers: Compilers, log: Logger): Inputs = { import Path._ val classesDirectory = outputDirectory / "classes" val cacheDirectory = outputDirectory / "cache" val augClasspath = classesDirectory.asFile +: classpath - inputs(augClasspath, sources, classesDirectory, options, javacOptions, Map.empty, cacheDirectory, maxErrors) + inputs(augClasspath, sources, classesDirectory, options, javacOptions, Map.empty, cacheDirectory, maxErrors, order) } - def inputs(classpath: Seq[File], sources: Seq[File], classesDirectory: File, options: Seq[String], javacOptions: Seq[String], analysisMap: Map[File, Analysis], cacheDirectory: File, maxErrors: Int)(implicit compilers: Compilers, log: Logger): Inputs = + def inputs(classpath: Seq[File], sources: Seq[File], classesDirectory: File, options: Seq[String], javacOptions: Seq[String], analysisMap: Map[File, Analysis], cacheDirectory: File, maxErrors: Int, order: CompileOrder.Value)(implicit compilers: Compilers, log: Logger): Inputs = new Inputs( compilers, - new Options(classpath, sources, classesDirectory, options, javacOptions, maxErrors), + new Options(classpath, sources, classesDirectory, options, javacOptions, maxErrors, order), new IncSetup(analysisMap, cacheDirectory) ) @@ -98,6 +98,6 @@ object Compiler import in.incSetup._ val agg = new AggressiveCompile(cacheDirectory) - agg(scalac, javac, sources, classpath, classesDirectory, options, javacOptions, analysisMap, maxErrors)(log) + agg(scalac, javac, sources, classpath, classesDirectory, options, javacOptions, analysisMap, maxErrors, order)(log) } } \ No newline at end of file diff --git a/main/Defaults.scala b/main/Defaults.scala index cdd79ab6c..7e0467307 100755 --- a/main/Defaults.scala +++ b/main/Defaults.scala @@ -119,6 +119,7 @@ object Defaults def compileBase = Seq( classpathOptions in GlobalScope :== ClasspathOptions.auto, + compileOrder in GlobalScope :== CompileOrder.Mixed, compilers <<= (scalaInstance, appConfiguration, streams, classpathOptions, javaHome) map { (si, app, s, co, jh) => Compiler.compilers(si, co, jh)(app, s.log) }, javacOptions in GlobalScope :== Nil, scalacOptions in GlobalScope :== Nil, @@ -327,12 +328,12 @@ object Defaults def compileTask = (compileInputs, streams) map { (i,s) => Compiler(i,s.log) } def compileInputsTask = - (dependencyClasspath, sources, compilers, javacOptions, scalacOptions, cacheDirectory, classDirectory, streams) map { - (cp, srcs, cs, javacOpts, scalacOpts, cacheDir, classes, s) => + (dependencyClasspath, sources, compilers, javacOptions, scalacOptions, cacheDirectory, classDirectory, compileOrder, streams) map { + (cp, srcs, cs, javacOpts, scalacOpts, cacheDir, classes, order, s) => val classpath = classes +: data(cp) val analysis = analysisMap(cp) val cache = cacheDir / "compile" - Compiler.inputs(classpath, srcs, classes, scalacOpts, javacOpts, analysis, cache, 100)(cs, s.log) + Compiler.inputs(classpath, srcs, classes, scalacOpts, javacOpts, analysis, cache, 100, order)(cs, s.log) } def writePluginsDescriptor(plugins: Set[String], dir: File): List[File] = diff --git a/main/Keys.scala b/main/Keys.scala index 441178f8c..d73a614fd 100644 --- a/main/Keys.scala +++ b/main/Keys.scala @@ -68,6 +68,7 @@ object Keys val scaladocOptions = SettingKey[Seq[String]]("scaladoc-options") val scalacOptions = SettingKey[Seq[String]]("scalac-options") val javacOptions = SettingKey[Seq[String]]("javac-options") + val compileOrder = SettingKey[CompileOrder.Value]("compile-order") val initialCommands = SettingKey[String]("initial-commands") val compileInputs = TaskKey[Compiler.Inputs]("compile-inputs") val scalaHome = SettingKey[Option[File]]("scala-home")