diff --git a/main/actions/src/main/scala/sbt/Compiler.scala b/main/actions/src/main/scala/sbt/Compiler.scala index 0af0cc0df..5332da9f9 100644 --- a/main/actions/src/main/scala/sbt/Compiler.scala +++ b/main/actions/src/main/scala/sbt/Compiler.scala @@ -4,11 +4,10 @@ package sbt import sbt.internal.inc.javac.{ IncrementalCompilerJavaTools, JavaTools } -import sbt.internal.inc.{ AnalyzingCompiler, ClasspathOptions, CompileSetup, CompileOutput, IC, JavaTool, LoggerReporter, ScalaInstance } +import sbt.internal.inc.{ Analysis, AnalyzingCompiler, ClasspathOptions, CompileOutput, ComponentCompiler, IncrementalCompilerImpl, JavaTool, Locate, LoggerReporter, ScalaInstance } import xsbti.{ Logger => _, _ } -import xsbti.compile.{ CompileOrder, GlobalsCache } +import xsbti.compile.{ CompileOrder, Compilers, CompileResult, GlobalsCache, IncOptions, Inputs, MiniSetup } import CompileOrder.{ JavaThenScala, Mixed, ScalaThenJava } -import sbt.internal.inc.{ Analysis, ComponentCompiler, IncOptions, Locate } import Locate.DefinesClass import java.io.File @@ -31,29 +30,29 @@ object Compiler { ComponentCompiler.incrementalVersion, Some("component")).sources() /** Inputs necessary to run the incremental compiler. */ - final case class Inputs(compilers: Compilers, config: Options, incSetup: IncSetup) - /** The inputs for the copiler *and* the previous analysis of source dependecnies. */ - final case class InputsWithPrevious(inputs: Inputs, previousAnalysis: PreviousAnalysis) - final case class Options(classpath: Seq[File], sources: Seq[File], classesDirectory: File, options: Seq[String], javacOptions: Seq[String], maxErrors: Int, sourcePositionMapper: Position => Position, order: CompileOrder) - final case class IncSetup(analysisMap: File => Option[Analysis], definesClass: DefinesClass, skip: Boolean, cacheFile: File, cache: GlobalsCache, incOptions: IncOptions) - private[sbt] trait JavaToolWithNewInterface extends JavaTool { - def newJavac: IncrementalCompilerJavaTools - } + // final case class Inputs(compilers: Compilers, config: Options, incSetup: IncSetup) + // /** The inputs for the copiler *and* the previous analysis of source dependecnies. */ + // final case class InputsWithPrevious(inputs: Inputs, previousAnalysis: PreviousAnalysis) + // final case class Options(classpath: Seq[File], sources: Seq[File], classesDirectory: File, options: Seq[String], javacOptions: Seq[String], maxErrors: Int, sourcePositionMapper: Position => Position, order: CompileOrder) + // final case class IncSetup(analysisMap: File => Option[Analysis], definesClass: DefinesClass, skip: Boolean, cacheFile: File, cache: GlobalsCache, incOptions: IncOptions) + + // private[sbt] trait JavaToolWithNewInterface extends JavaTool { + // def newJavac: IncrementalCompilerJavaTools + // } /** The instances of Scalac/Javac used to compile the current project. */ - final case class Compilers(scalac: AnalyzingCompiler, javac: IncrementalCompilerJavaTools) + // final case class Compilers(scalac: AnalyzingCompiler, javac: IncrementalCompilerJavaTools) /** The previous source dependency analysis result from compilation. */ - final case class PreviousAnalysis(analysis: Analysis, setup: Option[CompileSetup]) - type CompileResult = IC.Result + // final case class PreviousAnalysis(analysis: Analysis, setup: Option[MiniSetup]) - def inputs(classpath: Seq[File], sources: Seq[File], classesDirectory: File, options: Seq[String], - javacOptions: Seq[String], maxErrors: Int, sourcePositionMappers: Seq[Position => Option[Position]], - order: CompileOrder)(implicit compilers: Compilers, incSetup: IncSetup, log: Logger): Inputs = - new Inputs( - compilers, - new Options(classpath, sources, classesDirectory, options, javacOptions, maxErrors, foldMappers(sourcePositionMappers), order), - incSetup - ) + // def inputs(classpath: Seq[File], sources: Seq[File], classesDirectory: File, options: Seq[String], + // javacOptions: Seq[String], maxErrors: Int, sourcePositionMappers: Seq[Position => Option[Position]], + // order: CompileOrder)(implicit compilers: Compilers, incSetup: IncSetup, log: Logger): Inputs = + // new Inputs( + // compilers, + // new Options(classpath, sources, classesDirectory, options, javacOptions, maxErrors, foldMappers(sourcePositionMappers), order), + // incSetup + // ) // @deprecated("Use `compilers(ScalaInstance, ClasspathOptions, Option[File], IvyConfiguration)`.", "0.13.10") // def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File])(implicit app: AppConfiguration, log: Logger): Compilers = @@ -122,7 +121,7 @@ object Compiler { ivyConfiguration: IvyConfiguration, sourcesModule: ModuleID)(implicit app: AppConfiguration, log: Logger): Compilers = { val scalac = scalaCompiler(instance, cpOptions, javaHome, ivyConfiguration, sourcesModule) val javac = JavaTools.directOrFork(instance, cpOptions, javaHome) - new Compilers(scalac, javac) + IncrementalCompilerImpl.Compilers(scalac, javac) } def scalaCompiler(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File], ivyConfiguration: IvyConfiguration, sourcesModule: ModuleID)(implicit app: AppConfiguration, log: Logger): AnalyzingCompiler = { @@ -132,25 +131,27 @@ object Compiler { new AnalyzingCompiler(instance, provider, cpOptions) } - def compile(in: InputsWithPrevious, log: Logger): CompileResult = + def compile(in: Inputs, log: Logger): CompileResult = { - import in.inputs.config._ - compile(in, log, new LoggerReporter(maxErrors, log, sourcePositionMapper)) - } - def compile(in: InputsWithPrevious, log: Logger, reporter: xsbti.Reporter): CompileResult = - { - import in.inputs.compilers._ - import in.inputs.config._ - import in.inputs.incSetup._ - // Here is some trickery to choose the more recent (reporter-using) java compiler rather - // than the previously defined versions. - // TODO - Remove this hackery in sbt 1.0. - val javacChosen: xsbti.compile.JavaCompiler = - in.inputs.compilers.javac.xsbtiCompiler // ).getOrElse(in.inputs.compilers.javac) - // TODO - Why are we not using the IC interface??? - IC.incrementalCompile(scalac, javacChosen, sources, classpath, CompileOutput(classesDirectory), cache, None, options, javacOptions, - in.previousAnalysis.analysis, in.previousAnalysis.setup, analysisMap, definesClass, reporter, order, skip, incOptions)(log) + sbt.inc.IncrementalCompilerUtil.defaultIncrementalCompiler.compile(in, log) + // import in.inputs.config._ + // compile(in, log, new LoggerReporter(maxErrors, log, sourcePositionMapper)) } + // def compile(in: Inputs, log: Logger, reporter: xsbti.Reporter): CompileResult = + // { + // import in.inputs.compilers._ + // import in.inputs.config._ + // import in.inputs.incSetup._ + // // Here is some trickery to choose the more recent (reporter-using) java compiler rather + // // than the previously defined versions. + // // TODO - Remove this hackery in sbt 1.0. + // val javacChosen: xsbti.compile.JavaCompiler = + // in.inputs.compilers.javac.xsbtiCompiler // ).getOrElse(in.inputs.compilers.javac) + // // TODO - Why are we not using the IC interface??? + // val compiler = new IncrementalCompilerImpl + // compiler.incrementalCompile(scalac, javacChosen, sources, classpath, CompileOutput(classesDirectory), cache, None, options, javacOptions, + // in.previousAnalysis.analysis, in.previousAnalysis.setup, analysisMap, definesClass, reporter, order, skip, incOptions)(log) + // } private[sbt] def foldMappers[A](mappers: Seq[A => Option[A]]) = mappers.foldRight({ p: A => p }) { (mapper, mappers) => { p: A => mapper(p).getOrElse(mappers(p)) } } diff --git a/main/actions/src/main/scala/sbt/Console.scala b/main/actions/src/main/scala/sbt/Console.scala index d6dc07074..6e6ea8418 100644 --- a/main/actions/src/main/scala/sbt/Console.scala +++ b/main/actions/src/main/scala/sbt/Console.scala @@ -4,10 +4,12 @@ package sbt import java.io.File -import sbt.internal.inc.AnalyzingCompiler +import sbt.internal.inc.{ AnalyzingCompiler, IncrementalCompilerImpl } import sbt.internal.util.JLine import sbt.util.Logger +import xsbti.compile.Inputs + final class Console(compiler: AnalyzingCompiler) { /** Starts an interactive scala interpreter session with the given classpath.*/ def apply(classpath: Seq[File], log: Logger): Option[String] = @@ -28,5 +30,8 @@ final class Console(compiler: AnalyzingCompiler) { } } object Console { - def apply(conf: Compiler.Inputs): Console = new Console(conf.compilers.scalac) + def apply(conf: Inputs): Console = + conf.compilers match { + case IncrementalCompilerImpl.Compilers(scalac, _) => new Console(scalac) + } } diff --git a/main/actions/src/main/scala/sbt/Tests.scala b/main/actions/src/main/scala/sbt/Tests.scala index cd0bdb87d..1aab7ada9 100644 --- a/main/actions/src/main/scala/sbt/Tests.scala +++ b/main/actions/src/main/scala/sbt/Tests.scala @@ -10,6 +10,7 @@ import TaskExtra._ import sbt.internal.util.FeedbackProvidedException import sbt.internal.util.Types._ import xsbti.api.Definition +import xsbti.compile.CompileAnalysis import ConcurrentRestrictions.Tag import testing.{ AnnotatedFingerprint, Fingerprint, Framework, SubclassFingerprint, Runner, TaskDef, SuiteSelector, Task => TestTask } @@ -269,10 +270,10 @@ object Tests { } def overall(results: Iterable[TestResult.Value]): TestResult.Value = (TestResult.Passed /: results) { (acc, result) => if (acc.id < result.id) result else acc } - def discover(frameworks: Seq[Framework], analysis: Analysis, log: Logger): (Seq[TestDefinition], Set[String]) = + def discover(frameworks: Seq[Framework], analysis: CompileAnalysis, log: Logger): (Seq[TestDefinition], Set[String]) = discover(frameworks flatMap TestFramework.getFingerprints, allDefs(analysis), log) - def allDefs(analysis: Analysis) = analysis.apis.internal.values.flatMap(_.api.definitions).toSeq + def allDefs(analysis: CompileAnalysis) = analysis match { case analysis: Analysis => analysis.apis.internal.values.flatMap(_.api.definitions).toSeq } def discover(fingerprints: Seq[Fingerprint], definitions: Seq[Definition], log: Logger): (Seq[TestDefinition], Set[String]) = { val subclasses = fingerprints collect { case sub: SubclassFingerprint => (sub.superclassName, sub.isModule, sub) }; diff --git a/main/src/main/scala/sbt/Build.scala b/main/src/main/scala/sbt/Build.scala index 64e7939e9..a88cae1a2 100644 --- a/main/src/main/scala/sbt/Build.scala +++ b/main/src/main/scala/sbt/Build.scala @@ -69,5 +69,5 @@ object Build { @deprecated("Use Attributed.data", "0.13.0") def data[T](in: Seq[Attributed[T]]): Seq[T] = Attributed.data(in) - def analyzed(in: Seq[Attributed[_]]): Seq[sbt.internal.inc.Analysis] = in.flatMap { _.metadata.get(Keys.analysis) } + def analyzed(in: Seq[Attributed[_]]): Seq[xsbti.compile.CompileAnalysis] = in.flatMap { _.metadata.get(Keys.analysis) } } diff --git a/main/src/main/scala/sbt/ConsoleProject.scala b/main/src/main/scala/sbt/ConsoleProject.scala index c8546c075..c8a3e283b 100644 --- a/main/src/main/scala/sbt/ConsoleProject.scala +++ b/main/src/main/scala/sbt/ConsoleProject.scala @@ -7,7 +7,7 @@ import sbt.util.Logger import java.io.File import sbt.librarymanagement.Resolver import sbt.internal.librarymanagement.{ InlineIvyConfiguration, IvyPaths } -import sbt.internal.inc.{ AnalyzingCompiler, ClasspathOptions } +import sbt.internal.inc.{ AnalyzingCompiler, ClasspathOptions, IncrementalCompilerImpl } object ConsoleProject { def apply(state: State, extra: String, cleanupCommands: String = "", options: Seq[String] = Nil)(implicit log: Logger): Unit = { @@ -21,7 +21,7 @@ object ConsoleProject { val ivyPaths = new IvyPaths(unit.unit.localBase, bootIvyHome(state.configuration)) val ivyConfiguration = new InlineIvyConfiguration(ivyPaths, Resolver.withDefaultResolvers(Nil), Nil, Nil, localOnly, lock, checksums, None, log) - val compiler: AnalyzingCompiler = Compiler.compilers(ClasspathOptions.repl, ivyConfiguration)(state.configuration, log).scalac + val compiler: AnalyzingCompiler = Compiler.compilers(ClasspathOptions.repl, ivyConfiguration)(state.configuration, log) match { case IncrementalCompilerImpl.Compilers(scalac, _) => scalac } val imports = BuildUtil.getImports(unit.unit) ++ BuildUtil.importAll(bindings.map(_._1)) val importString = imports.mkString("", ";\n", ";\n\n") val initCommands = importString + extra diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala index 2aada95e7..2860c67d8 100755 --- a/main/src/main/scala/sbt/Defaults.scala +++ b/main/src/main/scala/sbt/Defaults.scala @@ -7,10 +7,9 @@ import scala.concurrent.duration.{ FiniteDuration, Duration } import sbt.internal.util.Attributed import sbt.internal.util.Attributed.data import Scope.{ fillTaskAxis, GlobalScope, ThisScope } -import sbt.Compiler.InputsWithPrevious import sbt.internal.librarymanagement.mavenint.{ PomExtraDependencyAttributes, SbtPomExtraProperties } import xsbt.api.Discovery -import xsbti.compile.CompileOrder +import xsbti.compile.{ CompileAnalysis, CompileOptions, CompileOrder, CompileResult, DefinesClass, IncOptions, IncOptionsUtil, Inputs, MiniSetup, PreviousResult, Setup, TransactionalManagerType } import Project.{ inConfig, inScope, inTask, richInitialize, richInitializeTask, richTaskSessionVar } import Def.{ Initialize, ScopedKey, Setting, SettingsDefinition } import sbt.internal.librarymanagement.{ CustomPomParser, DependencyFilter } @@ -20,7 +19,7 @@ import sbt.librarymanagement.Configurations.{ Compile, CompilerPlugin, Integrati import sbt.librarymanagement.CrossVersion.{ binarySbtVersion, binaryScalaVersion, partialVersion } import sbt.internal.util.complete._ import std.TaskExtra._ -import sbt.internal.inc.{ Analysis, ClassfileManager, ClasspathOptions, CompilerCache, FileValueCache, IncOptions, Locate, LoggerReporter, MixedAnalyzingCompiler, ScalaInstance } +import sbt.internal.inc.{ Analysis, ClassfileManager, ClasspathOptions, CompilerCache, FileValueCache, IncrementalCompilerImpl, Locate, LoggerReporter, MixedAnalyzingCompiler, ScalaInstance } import testing.{ Framework, Runner, AnnotatedFingerprint, SubclassFingerprint } import sbt.librarymanagement.{ `package` => _, _ } @@ -41,6 +40,9 @@ import sbt.internal.util.Cache.seqFormat import sbt.util.Logger import CommandStrings.ExportStream +import xsbti.Maybe +import sbt.util.InterfaceUtil.{ f1, o2m } + import sbt.internal.util.Types._ import sbt.internal.io.WatchState @@ -58,10 +60,10 @@ object Defaults extends BuildCommon { def lock(app: xsbti.AppConfiguration): xsbti.GlobalLock = app.provider.scalaProvider.launcher.globalLock - def extractAnalysis[T](a: Attributed[T]): (T, Analysis) = + def extractAnalysis[T](a: Attributed[T]): (T, CompileAnalysis) = (a.data, a.metadata get Keys.analysis getOrElse Analysis.Empty) - def analysisMap[T](cp: Seq[Attributed[T]]): T => Option[Analysis] = + def analysisMap[T](cp: Seq[Attributed[T]]): T => Option[CompileAnalysis] = { val m = (for (a <- cp; an <- a.metadata get Keys.analysis) yield (a.data, an)).toMap m.get _ @@ -237,8 +239,8 @@ object Defaults extends BuildCommon { ) def compileBase = inTask(console)(compilersSetting :: Nil) ++ compileBaseGlobal ++ Seq( - incOptions := incOptions.value.withNewClassfileManager( - ClassfileManager.transactional(crossTarget.value / "classes.bak", sbt.util.Logger.Null)), + incOptions := incOptions.value.withClassfileManagerType( + Maybe.just(new TransactionalManagerType(crossTarget.value / "classes.bak", sbt.util.Logger.Null))), scalaInstance <<= scalaInstanceTask, crossVersion := (if (crossPaths.value) CrossVersion.binary else CrossVersion.Disabled), crossTarget := makeCrossTarget(target.value, scalaBinaryVersion.value, sbtBinaryVersion.value, sbtPlugin.value, crossPaths.value), @@ -250,7 +252,7 @@ object Defaults extends BuildCommon { ) // must be a val: duplication detected by object identity private[this] lazy val compileBaseGlobal: Seq[Setting[_]] = globalDefaults(Seq( - incOptions := IncOptions.Default, + incOptions := IncOptionsUtil.defaultIncOptions, classpathOptions :== ClasspathOptions.boot, classpathOptions in console :== ClasspathOptions.repl, compileOrder :== CompileOrder.Mixed, @@ -496,7 +498,7 @@ object Defaults extends BuildCommon { def testQuickFilter: Initialize[Task[Seq[String] => Seq[String => Boolean]]] = (fullClasspath in test, streams in test) map { (cp, s) => - val ans = cp.flatMap(_.metadata get Keys.analysis) + val ans: Seq[Analysis] = cp.flatMap(_.metadata get Keys.analysis) map { case a0: Analysis => a0 } val succeeded = TestStatus.read(succeededFile(s.cacheDirectory)) val stamps = collection.mutable.Map.empty[File, Long] def stamp(dep: String): Long = { @@ -788,7 +790,7 @@ object Defaults extends BuildCommon { fileInputOptions := Seq("-doc-root-content", "-diagrams-dot-path"), key in TaskGlobal := { val s = streams.value - val cs = compilers.value + val cs: IncrementalCompilerImpl.Compilers = compilers.value match { case c: IncrementalCompilerImpl.Compilers => c } val srcs = sources.value val out = target.value val sOpts = scalacOptions.value @@ -801,11 +803,7 @@ object Defaults extends BuildCommon { val logger: Logger = s.log val maxer = maxErrors.value val spms = sourcePositionMappers.value - val reporter: xsbti.Reporter = - (compilerReporter in compile).value match { - case Some(r) => r - case _ => new LoggerReporter(maxer, logger, Compiler.foldMappers(spms)) - } + val reporter = (compilerReporter in compile).value (hasScala, hasJava) match { case (true, _) => val options = sOpts ++ Opts.doc.externalAPI(xapis) @@ -823,7 +821,7 @@ object Defaults extends BuildCommon { def mainRunTask = run <<= runTask(fullClasspath in Runtime, mainClass in run, runner in run) def mainRunMainTask = runMain <<= runMainTask(fullClasspath in Runtime, runner in run) - def discoverMainClasses(analysis: Analysis): Seq[String] = + def discoverMainClasses(analysis: CompileAnalysis): Seq[String] = Discovery.applications(Tests.allDefs(analysis)).collect({ case (definition, discovered) if discovered.hasMain => definition.name }).sorted def consoleProjectTask = (state, streams, initialCommands in consoleProject) map { (state, s, extra) => ConsoleProject(state, extra)(s.log); println() } @@ -831,7 +829,7 @@ object Defaults extends BuildCommon { def consoleQuickTask = consoleTask(externalDependencyClasspath, consoleQuick) def consoleTask(classpath: TaskKey[Classpath], task: TaskKey[_]): Initialize[Task[Unit]] = (compilers in task, classpath in task, scalacOptions in task, initialCommands in task, cleanupCommands in task, taskTemporaryDirectory in task, scalaInstance in task, streams) map { - (cs, cp, options, initCommands, cleanup, temp, si, s) => + case (cs: IncrementalCompilerImpl.Compilers, cp, options, initCommands, cleanup, temp, si, s) => val cpFiles = data(cp) val fullcp = (cpFiles ++ si.allJars).distinct val loader = sbt.internal.inc.classpath.ClasspathUtilities.makeLoader(fullcp, si, IO.createUniqueDirectory(temp)) @@ -851,10 +849,10 @@ object Defaults extends BuildCommon { @deprecated("Use inTask(compile)(compileInputsSettings)", "0.13.0") def compileTaskSettings: Seq[Setting[_]] = inTask(compile)(compileInputsSettings) - def compileTask: Initialize[Task[Analysis]] = Def.task { - val setup: Compiler.IncSetup = compileIncSetup.value + def compileTask: Initialize[Task[CompileAnalysis]] = Def.task { + val setup: Setup = compileIncSetup.value // TODO - expose bytecode manipulation phase. - val analysisResult: Compiler.CompileResult = manipulateBytecode.value + val analysisResult: CompileResult = manipulateBytecode.value if (analysisResult.hasModified) { val store = MixedAnalyzingCompiler.staticCachedStore(setup.cacheFile) store.set(analysisResult.analysis, analysisResult.setup) @@ -863,52 +861,70 @@ object Defaults extends BuildCommon { } def compileIncrementalTask = Def.task { // TODO - Should readAnalysis + saveAnalysis be scoped by the compile task too? - compileIncrementalTaskImpl(streams.value, (compileInputs in compile).value, previousCompile.value, (compilerReporter in compile).value) + compileIncrementalTaskImpl(streams.value, (compileInputs in compile).value) } - private[this] def compileIncrementalTaskImpl(s: TaskStreams, ci: Compiler.Inputs, previous: Compiler.PreviousAnalysis, reporter: Option[xsbti.Reporter]): Compiler.CompileResult = + private[this] def compileIncrementalTaskImpl(s: TaskStreams, ci: Inputs): CompileResult = { lazy val x = s.text(ExportStream) - def onArgs(cs: Compiler.Compilers) = cs.copy(scalac = cs.scalac.onArgs(exported(x, "scalac")), javac = cs.javac /*.onArgs(exported(x, "javac"))*/ ) - val i = InputsWithPrevious(ci.copy(compilers = onArgs(ci.compilers)), previous) - try reporter match { - case Some(reporter) => Compiler.compile(i, s.log, reporter) - case None => Compiler.compile(i, s.log) - } + def onArgs(cs: IncrementalCompilerImpl.Compilers) = cs.copy(scalac = cs.scalac.onArgs(exported(x, "scalac")), javac = cs.javac /*.onArgs(exported(x, "javac"))*/ ) + val compilers: IncrementalCompilerImpl.Compilers = ci.compilers match { case compilers: IncrementalCompilerImpl.Compilers => compilers } + val i = ci.withCompilers(onArgs(compilers)) + try Compiler.compile(i, s.log) finally x.close() // workaround for #937 } def compileIncSetupTask = Def.task { - Compiler.IncSetup( - analysisMap(dependencyClasspath.value), - definesClass.value, + val dc: File => DefinesClass = { + val dc = definesClass.value + f => new DefinesClass { override def apply(className: String): Boolean = dc(f)(className) } + } + new Setup( + f1(t => o2m(analysisMap(dependencyClasspath.value)(t))), + f1(dc), (skip in compile).value, // TODO - this is kind of a bad way to grab the cache directory for streams... streams.value.cacheDirectory / compileAnalysisFilename.value, compilerCache.value, - incOptions.value) + incOptions.value, + (compilerReporter in compile).value, + // TODO - task / setting for extra, + Array.empty) + } + def compileInputsSettings: Seq[Setting[_]] = { + Seq( + compileOptions := new CompileOptions( + (classDirectory.value +: data(dependencyClasspath.value)).toArray, + sources.value.toArray, + classDirectory.value, + scalacOptions.value.toArray, + javacOptions.value.toArray, + maxErrors.value, + f1(Compiler.foldMappers(sourcePositionMappers.value)), + compileOrder.value), + compilerReporter := new LoggerReporter(maxErrors.value, streams.value.log, Compiler.foldMappers(sourcePositionMappers.value)), + compileInputs := new Inputs( + compilers.value, + compileOptions.value, + compileIncSetup.value, + previousCompile.value) + ) } - def compileInputsSettings: Seq[Setting[_]] = - Seq(compileInputs := { - val cp = classDirectory.value +: data(dependencyClasspath.value) - Compiler.inputs(cp, sources.value, classDirectory.value, scalacOptions.value, javacOptions.value, - maxErrors.value, sourcePositionMappers.value, compileOrder.value)(compilers.value, compileIncSetup.value, streams.value.log) - }, - compilerReporter := None) def compileAnalysisSettings: Seq[Setting[_]] = Seq( previousCompile := { - val setup: Compiler.IncSetup = compileIncSetup.value + val setup = compileIncSetup.value val store = MixedAnalyzingCompiler.staticCachedStore(setup.cacheFile) store.get() match { - case Some((an, setup)) => Compiler.PreviousAnalysis(an, Some(setup)) - case None => Compiler.PreviousAnalysis(Analysis.empty(nameHashing = setup.incOptions.nameHashing), None) + case Some((an, setup)) => new PreviousResult(Maybe.just(an), Maybe.just(setup)) + case None => new PreviousResult(Maybe.nothing[CompileAnalysis], Maybe.nothing[MiniSetup]) } } ) def printWarningsTask: Initialize[Task[Unit]] = - (streams, compile, maxErrors, sourcePositionMappers) map { (s, analysis, max, spms) => - val problems = analysis.infos.allInfos.values.flatMap(i => i.reportedProblems ++ i.unreportedProblems) - val reporter = new LoggerReporter(max, s.log, Compiler.foldMappers(spms)) - problems foreach { p => reporter.display(p.position, p.message, p.severity) } + (streams, compile, maxErrors, sourcePositionMappers) map { + case (s, analysis: Analysis, max, spms) => + val problems = analysis.infos.allInfos.values.flatMap(i => i.reportedProblems ++ i.unreportedProblems) + val reporter = new LoggerReporter(max, s.log, Compiler.foldMappers(spms)) + problems foreach { p => reporter.display(p.position, p.message, p.severity) } } def sbtPluginExtra(m: ModuleID, sbtV: String, scalaV: String): ModuleID = @@ -926,7 +942,7 @@ object Defaults extends BuildCommon { def discoverPlugins: Initialize[Task[Set[String]]] = (compile, sbtPlugin, streams) map { (analysis, isPlugin, s) => if (isPlugin) discoverSbtPlugins(analysis, s.log) else Set.empty } @deprecated("Use PluginDiscovery.sourceModuleNames[Plugin].", "0.13.2") - def discoverSbtPlugins(analysis: Analysis, log: Logger): Set[String] = + def discoverSbtPlugins(analysis: CompileAnalysis, log: Logger): Set[String] = PluginDiscovery.sourceModuleNames(analysis, classOf[Plugin].getName).toSet def copyResourcesTask = @@ -1584,7 +1600,7 @@ object Classpaths { new RawRepository(new ProjectResolver(ProjectResolver.InterProject, m)) } - def analyzed[T](data: T, analysis: Analysis) = Attributed.blank(data).put(Keys.analysis, analysis) + def analyzed[T](data: T, analysis: CompileAnalysis) = Attributed.blank(data).put(Keys.analysis, analysis) def makeProducts: Initialize[Task[Seq[File]]] = Def.task { val x1 = compile.value val x2 = copyResources.value diff --git a/main/src/main/scala/sbt/Keys.scala b/main/src/main/scala/sbt/Keys.scala index de381c6ce..5536feeca 100644 --- a/main/src/main/scala/sbt/Keys.scala +++ b/main/src/main/scala/sbt/Keys.scala @@ -9,9 +9,9 @@ import scala.concurrent.duration.{ FiniteDuration, Duration } import Def.ScopedKey import sbt.internal.util.complete._ import sbt.internal.inc.Locate.DefinesClass -import sbt.internal.inc.{ Analysis, ClasspathOptions, IncOptions, MixedAnalyzingCompiler, ScalaInstance } +import sbt.internal.inc.{ ClasspathOptions, MixedAnalyzingCompiler, ScalaInstance } import std.TaskExtra._ -import xsbti.compile.{ CompileOrder, GlobalsCache } +import xsbti.compile.{ CompileAnalysis, CompileOptions, CompileOrder, Compilers, CompileResult, GlobalsCache, IncOptions, Inputs, PreviousResult, Setup } import scala.xml.{ Node => XNode, NodeSeq } import org.apache.ivy.core.module.{ descriptor, id } import descriptor.ModuleDescriptor, id.ModuleRevisionId @@ -103,7 +103,7 @@ object Keys { // Command keys val historyPath = SettingKey(BasicKeys.historyPath) val shellPrompt = SettingKey(BasicKeys.shellPrompt) - val analysis = AttributeKey[Analysis]("analysis", "Analysis of compilation, including dependencies and generated outputs.", DSetting) + val analysis = AttributeKey[CompileAnalysis]("analysis", "Analysis of compilation, including dependencies and generated outputs.", DSetting) val watch = SettingKey(BasicKeys.watch) val pollInterval = SettingKey[Int]("poll-interval", "Interval between checks for modified sources by the continuous execution command.", BMinusSetting) val watchSources = TaskKey[Seq[File]]("watch-sources", "Defines the sources in this project for continuous execution to watch for changes.", BMinusSetting) @@ -165,7 +165,8 @@ object Keys { val compileOrder = SettingKey[CompileOrder]("compile-order", "Configures the order in which Java and sources within a single compilation are compiled. Valid values are: JavaThenScala, ScalaThenJava, or Mixed.", BPlusSetting) val initialCommands = SettingKey[String]("initial-commands", "Initial commands to execute when starting up the Scala interpreter.", AMinusSetting) val cleanupCommands = SettingKey[String]("cleanup-commands", "Commands to execute before the Scala interpreter exits.", BMinusSetting) - val compileInputs = TaskKey[Compiler.Inputs]("compile-inputs", "Collects all inputs needed for compilation.", DTask) + val compileOptions = TaskKey[CompileOptions]("compile-options", "Collects basic options to configure compilers", DTask) + val compileInputs = TaskKey[Inputs]("compile-inputs", "Collects all inputs needed for compilation.", DTask) val scalaHome = SettingKey[Option[File]]("scala-home", "If Some, defines the local Scala installation to use for compilation, running, and testing.", ASetting) val scalaInstance = TaskKey[ScalaInstance]("scala-instance", "Defines the Scala instance to use for compilation, running, and testing.", DTask) val scalaOrganization = SettingKey[String]("scala-organization", "Organization/group ID of the Scala used in the project. Default value is 'org.scala-lang'. This is an advanced setting used for clones of the Scala Language. It should be disregarded in standard use cases.", CSetting) @@ -185,13 +186,13 @@ object Keys { val console = TaskKey[Unit]("console", "Starts the Scala interpreter with the project classes on the classpath.", APlusTask) val consoleQuick = TaskKey[Unit]("console-quick", "Starts the Scala interpreter with the project dependencies on the classpath.", ATask, console) val consoleProject = TaskKey[Unit]("console-project", "Starts the Scala interpreter with the sbt and the build definition on the classpath and useful imports.", AMinusTask) - val compile = TaskKey[Analysis]("compile", "Compiles sources.", APlusTask) - val manipulateBytecode = TaskKey[Compiler.CompileResult]("manipulateBytecode", "Manipulates generated bytecode", BTask) - val compileIncremental = TaskKey[Compiler.CompileResult]("compileIncremental", "Actually runs the incremental compilation", DTask) - val previousCompile = TaskKey[Compiler.PreviousAnalysis]("readAnalysis", "Read the incremental compiler analysis from disk", DTask) - val compilers = TaskKey[Compiler.Compilers]("compilers", "Defines the Scala and Java compilers to use for compilation.", DTask) + val compile = TaskKey[CompileAnalysis]("compile", "Compiles sources.", APlusTask) + val manipulateBytecode = TaskKey[CompileResult]("manipulateBytecode", "Manipulates generated bytecode", BTask) + val compileIncremental = TaskKey[CompileResult]("compileIncremental", "Actually runs the incremental compilation", DTask) + val previousCompile = TaskKey[PreviousResult]("readAnalysis", "Read the incremental compiler analysis from disk", DTask) + val compilers = TaskKey[Compilers]("compilers", "Defines the Scala and Java compilers to use for compilation.", DTask) val compileAnalysisFilename = TaskKey[String]("compileAnalysisFilename", "Defines the filename used to store the incremental compiler analysis file (inside the streams cacheDirectory).", DTask) - val compileIncSetup = TaskKey[Compiler.IncSetup]("inc-compile-setup", "Configures aspects of incremental compilation.", DTask) + val compileIncSetup = TaskKey[Setup]("inc-compile-setup", "Configures aspects of incremental compilation.", DTask) val compilerCache = TaskKey[GlobalsCache]("compiler-cache", "Cache of scala.tools.nsc.Global instances. This should typically be cached so that it isn't recreated every task run.", DTask) val stateCompilerCache = AttributeKey[GlobalsCache]("compiler-cache", "Internal use: Global cache.") val definesClass = TaskKey[DefinesClass]("defines-class", "Internal use: provides a function that determines whether the provided file contains a given class.", Invisible) @@ -418,7 +419,7 @@ object Keys { private[sbt] val taskCancelStrategy = SettingKey[State => TaskCancellationStrategy]("taskCancelStrategy", "Experimental task cancellation handler.", DTask) // Experimental in sbt 0.13.2 to enable grabing semantic compile failures. - private[sbt] val compilerReporter = TaskKey[Option[xsbti.Reporter]]("compilerReporter", "Experimental hook to listen (or send) compilation failure messages.", DTask) + private[sbt] val compilerReporter = TaskKey[xsbti.Reporter]("compilerReporter", "Experimental hook to listen (or send) compilation failure messages.", DTask) val triggeredBy = Def.triggeredBy val runBefore = Def.runBefore diff --git a/main/src/main/scala/sbt/Load.scala b/main/src/main/scala/sbt/Load.scala index 398292e3d..eb26a0a72 100755 --- a/main/src/main/scala/sbt/Load.scala +++ b/main/src/main/scala/sbt/Load.scala @@ -12,7 +12,6 @@ import java.net.{ URI, URL } import compiler.{ Eval, EvalImports } import scala.annotation.tailrec import collection.mutable -import Compiler.Compilers import sbt.internal.inc.{ Analysis, ClasspathOptions, FileValueCache, Locate, ModuleUtilities } import sbt.internal.inc.classpath.ClasspathUtilities import Project.{ inScope, makeSettings } @@ -30,6 +29,7 @@ import Locate.DefinesClass import sbt.io.{ GlobFilter, IO, Path } import sbt.internal.io.Alternatives import sbt.util.Logger +import xsbti.compile.Compilers object Load { // note that there is State passed in but not pulled out diff --git a/main/src/main/scala/sbt/PluginDiscovery.scala b/main/src/main/scala/sbt/PluginDiscovery.scala index 41f637fa1..11c729178 100644 --- a/main/src/main/scala/sbt/PluginDiscovery.scala +++ b/main/src/main/scala/sbt/PluginDiscovery.scala @@ -7,7 +7,8 @@ import java.net.URL import Attributed.data import Build.analyzed import xsbt.api.{ Discovered, Discovery } -import sbt.internal.inc.{ Analysis, ModuleUtilities } +import xsbti.compile.CompileAnalysis +import sbt.internal.inc.ModuleUtilities import sbt.io.IO @@ -48,7 +49,7 @@ object PluginDiscovery { } /** Discovers the sbt-plugin-related top-level modules from the provided source `analysis`. */ - def discoverSourceAll(analysis: Analysis): DiscoveredNames = + def discoverSourceAll(analysis: CompileAnalysis): DiscoveredNames = { def discover[T](implicit classTag: reflect.ClassTag[T]): Seq[String] = sourceModuleNames(analysis, classTag.runtimeClass.getName) @@ -92,7 +93,7 @@ object PluginDiscovery { ).distinct /** Discovers top-level modules in `analysis` that inherit from any of `subclasses`. */ - def sourceModuleNames(analysis: Analysis, subclasses: String*): Seq[String] = + def sourceModuleNames(analysis: CompileAnalysis, subclasses: String*): Seq[String] = { val subclassSet = subclasses.toSet val ds = Discovery(subclassSet, Set.empty)(Tests.allDefs(analysis)) diff --git a/project/Dependencies.scala b/project/Dependencies.scala index d61f21035..333733685 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -9,9 +9,9 @@ object Dependencies { lazy val scala211 = "2.11.7" // sbt modules - val utilVersion = "0.1.0-M5" + val utilVersion = "0.1.0-M8" val ioVersion = "1.0.0-M3" - val incremenalcompilerVersion = "0.1.0-M1-168cb7a4877917e01917e35b9b82a62afe5c2a01" + val incrementalcompilerVersion = "0.1.0-M2-ea408e4710e2616f437d5cfae5ba4846fcb9a019-SNAPSHOT" val librarymanagementVersion = "0.1.0-M7" lazy val sbtIO = "org.scala-sbt" %% "io" % ioVersion lazy val utilCollection = "org.scala-sbt" %% "util-collection" % utilVersion @@ -28,13 +28,13 @@ object Dependencies { lazy val rawLauncher = "org.scala-sbt" % "launcher" % "1.0.0-M1" lazy val testInterface = "org.scala-sbt" % "test-interface" % "1.0" - lazy val incrementalcompiler = "org.scala-sbt" %% "incrementalcompiler" % incremenalcompilerVersion - lazy val incrementalcompilerCompile = "org.scala-sbt" %% "incrementalcompiler-compile" % incremenalcompilerVersion - lazy val compilerInterface = "org.scala-sbt" % "compiler-interface" % incremenalcompilerVersion - lazy val compilerBrdige = "org.scala-sbt" %% "compiler-bridge" % incremenalcompilerVersion - lazy val compilerClasspath = "org.scala-sbt" %% "incrementalcompiler-classpath" % incremenalcompilerVersion - lazy val compilerApiInfo = "org.scala-sbt" %% "incrementalcompiler-apiinfo" % incremenalcompilerVersion - lazy val compilerIvyIntegration = "org.scala-sbt" %% "incrementalcompiler-ivy-integration" % incremenalcompilerVersion + lazy val incrementalcompiler = "org.scala-sbt" %% "incrementalcompiler" % incrementalcompilerVersion + lazy val incrementalcompilerCompile = "org.scala-sbt" %% "incrementalcompiler-compile" % incrementalcompilerVersion + lazy val compilerInterface = "org.scala-sbt" % "compiler-interface" % incrementalcompilerVersion + lazy val compilerBrdige = "org.scala-sbt" %% "compiler-bridge" % incrementalcompilerVersion + lazy val compilerClasspath = "org.scala-sbt" %% "incrementalcompiler-classpath" % incrementalcompilerVersion + lazy val compilerApiInfo = "org.scala-sbt" %% "incrementalcompiler-apiinfo" % incrementalcompilerVersion + lazy val compilerIvyIntegration = "org.scala-sbt" %% "incrementalcompiler-ivy-integration" % incrementalcompilerVersion lazy val jline = "jline" % "jline" % "2.11" lazy val ivy = "org.scala-sbt.ivy" % "ivy" % "2.3.0-sbt-d592b1b0f77cf706e882b1b8e0162dee28165fb2" diff --git a/sbt/src/main/scala/Import.scala b/sbt/src/main/scala/Import.scala index 7a5d9be3c..4bd3928bf 100644 --- a/sbt/src/main/scala/Import.scala +++ b/sbt/src/main/scala/Import.scala @@ -431,7 +431,7 @@ object Import { type SelfFirstLoader = sbt.internal.inc.classpath.SelfFirstLoader } - val IncOptions = sbt.internal.inc.IncOptions + type IncOptions = xsbti.compile.IncOptions type Analysis = sbt.internal.inc.Analysis val Analysis = sbt.internal.inc.Analysis val ClassfileManager = sbt.internal.inc.ClassfileManager