diff --git a/main-actions/src/main/scala/sbt/Compiler.scala b/main-actions/src/main/scala/sbt/Compiler.scala index 5332da9f9..610b286b6 100644 --- a/main-actions/src/main/scala/sbt/Compiler.scala +++ b/main-actions/src/main/scala/sbt/Compiler.scala @@ -3,12 +3,11 @@ */ package sbt -import sbt.internal.inc.javac.{ IncrementalCompilerJavaTools, JavaTools } -import sbt.internal.inc.{ Analysis, AnalyzingCompiler, ClasspathOptions, CompileOutput, ComponentCompiler, IncrementalCompilerImpl, JavaTool, Locate, LoggerReporter, ScalaInstance } +import sbt.internal.inc.javac.JavaTools +import sbt.internal.inc.{ Analysis, AnalyzingCompiler, CompileOutput, ComponentCompiler, IncrementalCompilerImpl, Locate, LoggerReporter, ScalaInstance } import xsbti.{ Logger => _, _ } -import xsbti.compile.{ CompileOrder, Compilers, CompileResult, GlobalsCache, IncOptions, Inputs, MiniSetup } +import xsbti.compile.{ ClasspathOptions, CompileOrder, Compilers, CompileResult, GlobalsCache, IncOptions, Inputs, MiniSetup } import CompileOrder.{ JavaThenScala, Mixed, ScalaThenJava } -import Locate.DefinesClass import java.io.File import sbt.internal.librarymanagement.{ ComponentManager, IvyConfiguration } @@ -121,7 +120,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) - IncrementalCompilerImpl.Compilers(scalac, javac) + new Compilers(scalac, javac) } def scalaCompiler(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File], ivyConfiguration: IvyConfiguration, sourcesModule: ModuleID)(implicit app: AppConfiguration, log: Logger): AnalyzingCompiler = { diff --git a/main-actions/src/main/scala/sbt/Console.scala b/main-actions/src/main/scala/sbt/Console.scala index 6e6ea8418..fd9e2965a 100644 --- a/main-actions/src/main/scala/sbt/Console.scala +++ b/main-actions/src/main/scala/sbt/Console.scala @@ -4,11 +4,11 @@ package sbt import java.io.File -import sbt.internal.inc.{ AnalyzingCompiler, IncrementalCompilerImpl } +import sbt.internal.inc.AnalyzingCompiler import sbt.internal.util.JLine import sbt.util.Logger -import xsbti.compile.Inputs +import xsbti.compile.{ Inputs, Compilers } final class Console(compiler: AnalyzingCompiler) { /** Starts an interactive scala interpreter session with the given classpath.*/ @@ -32,6 +32,6 @@ final class Console(compiler: AnalyzingCompiler) { object Console { def apply(conf: Inputs): Console = conf.compilers match { - case IncrementalCompilerImpl.Compilers(scalac, _) => new Console(scalac) + case cs: Compilers => new Console(cs.scalac match { case x: AnalyzingCompiler => x }) } } diff --git a/main-actions/src/main/scala/sbt/Doc.scala b/main-actions/src/main/scala/sbt/Doc.scala index f6d9477f0..3ee0fb85e 100644 --- a/main-actions/src/main/scala/sbt/Doc.scala +++ b/main-actions/src/main/scala/sbt/Doc.scala @@ -4,7 +4,7 @@ package sbt import java.io.{ File, PrintWriter } -import sbt.internal.inc.{ AnalyzingCompiler, JavaCompiler } +import sbt.internal.inc.AnalyzingCompiler import Predef.{ conforms => _, _ } import sbt.internal.util.Types.:+: @@ -17,6 +17,7 @@ import sbt.internal.util.Tracked.{ inputChanged, outputChanged } import sbt.internal.util.{ FilesInfo, HashFileInfo, HNil, ModifiedFileInfo, PlainFileInfo } import sbt.internal.util.FilesInfo.{ exists, hash, lastModified } import xsbti.Reporter +import xsbti.compile.JavaTools import sbt.util.Logger @@ -26,9 +27,9 @@ object Doc { scaladoc(label, cache, compiler, Seq()) def scaladoc(label: String, cache: File, compiler: AnalyzingCompiler, fileInputOptions: Seq[String]): Gen = cached(cache, fileInputOptions, prepare(label + " Scala API documentation", compiler.doc)) - def javadoc(label: String, cache: File, doc: sbt.internal.inc.javac.JavaTools, log: Logger, reporter: Reporter): Gen = + def javadoc(label: String, cache: File, doc: JavaTools, log: Logger, reporter: Reporter): Gen = javadoc(label, cache, doc, log, reporter, Seq()) - def javadoc(label: String, cache: File, doc: sbt.internal.inc.javac.JavaTools, log: Logger, reporter: Reporter, fileInputOptions: Seq[String]): Gen = + def javadoc(label: String, cache: File, doc: JavaTools, log: Logger, reporter: Reporter, fileInputOptions: Seq[String]): Gen = cached(cache, fileInputOptions, prepare(label + " Java API documentation", filterSources(javaSourcesOnly, (sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String], maxErrors: Int, log: Logger) => { // doc.doc @@ -48,13 +49,13 @@ object Doc { generate("Scala", label, compiler.doc, sources, classpath, outputDirectory, options, maximumErrors, log) } } - // TODO: trait Javadoc in package inc is deprecated: Please use the new set of compilers in sbt.compilers.javac - private[sbt] final class Javadoc(maximumErrors: Int, doc: sbt.internal.inc.Javadoc) extends Doc { - def apply(label: String, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String], log: Logger): Unit = { - // javadoc doesn't handle *.scala properly, so we evict them from javadoc sources list. - generate("Java", label, doc.doc, sources.filterNot(_.name.endsWith(".scala")), classpath, outputDirectory, options, maximumErrors, log) - } - } + + // private[sbt] final class Javadoc(maximumErrors: Int, doc: sbt.internal.inc.Javadoc) extends Doc { + // def apply(label: String, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String], log: Logger) { + // // javadoc doesn't handle *.scala properly, so we evict them from javadoc sources list. + // generate("Java", label, doc.doc, sources.filterNot(_.name.endsWith(".scala")), classpath, outputDirectory, options, maximumErrors, log) + // } + // } } // @deprecated("No longer used. See `Doc.javadoc` or `Doc.scaladoc`", "0.13.0") sealed trait Doc { diff --git a/main-actions/src/main/scala/sbt/RawCompileLike.scala b/main-actions/src/main/scala/sbt/RawCompileLike.scala index 5791b6601..cfa91dc75 100644 --- a/main-actions/src/main/scala/sbt/RawCompileLike.scala +++ b/main-actions/src/main/scala/sbt/RawCompileLike.scala @@ -4,7 +4,7 @@ package sbt import java.io.File -import sbt.internal.inc.{ AnalyzingCompiler, ClasspathOptions, JavaCompiler, RawCompiler, ScalaInstance } +import sbt.internal.inc.{ AnalyzingCompiler, RawCompiler, ScalaInstance } import Predef.{ conforms => _, _ } import sbt.io.syntax._ @@ -16,6 +16,7 @@ import sbt.internal.util.Cache.{ defaultEquiv, hConsCache, hNilCache, IntFormat, import sbt.internal.util.Tracked.{ inputChanged, outputChanged } import sbt.internal.util.{ FilesInfo, HashFileInfo, HNil, ModifiedFileInfo, PlainFileInfo } import sbt.internal.util.FilesInfo.{ exists, hash, lastModified } +import xsbti.compile.ClasspathOptions import sbt.util.Logger diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala index 5913f0e5a..7d5e028ed 100755 --- a/main/src/main/scala/sbt/Defaults.scala +++ b/main/src/main/scala/sbt/Defaults.scala @@ -9,8 +9,6 @@ import sbt.internal.util.Attributed import sbt.internal.util.Attributed.data import Scope.{ fillTaskAxis, GlobalScope, ThisScope } import sbt.internal.librarymanagement.mavenint.{ PomExtraDependencyAttributes, SbtPomExtraProperties } -import xsbt.api.Discovery -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 +18,6 @@ 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, IncrementalCompilerImpl, Locate, LoggerReporter, MixedAnalyzingCompiler, ScalaInstance } import testing.{ Framework, Runner, AnnotatedFingerprint, SubclassFingerprint } import sbt.librarymanagement.{ `package` => _, _ } @@ -53,6 +50,12 @@ import Path._ import sbt.io.syntax._ import Keys._ +// incremental compiler +import xsbt.api.Discovery +import xsbti.compile.{ Compilers, ClasspathOptions, CompileAnalysis, CompileOptions, CompileOrder, CompileResult, DefinesClass, IncOptions, IncOptionsUtil, Inputs, MiniSetup, PreviousResult, Setup, TransactionalManagerType } +import xsbti.compile.PerClasspathEntryLookup +import sbt.internal.inc.{ AnalyzingCompiler, Analysis, ClassfileManager, CompilerCache, FileValueCache, IncrementalCompilerImpl, Locate, LoggerReporter, MixedAnalyzingCompiler, ScalaInstance, ClasspathOptionsUtil } + object Defaults extends BuildCommon { final val CacheDirectoryName = "cache" @@ -88,7 +91,7 @@ object Defaults extends BuildCommon { apiMappings := Map.empty, autoScalaLibrary :== true, managedScalaInstance :== true, - definesClass :== FileValueCache(Locate.definesClass _).get, + classpathEntryDefinesClass :== FileValueCache(Locate.definesClass _).get, traceLevel in run :== 0, traceLevel in runMain :== 0, traceLevel in console :== Int.MaxValue, @@ -254,8 +257,8 @@ object Defaults extends BuildCommon { // must be a val: duplication detected by object identity private[this] lazy val compileBaseGlobal: Seq[Setting[_]] = globalDefaults(Seq( incOptions := IncOptionsUtil.defaultIncOptions, - classpathOptions :== ClasspathOptions.boot, - classpathOptions in console :== ClasspathOptions.repl, + classpathOptions :== ClasspathOptionsUtil.boot, + classpathOptions in console :== ClasspathOptionsUtil.repl, compileOrder :== CompileOrder.Mixed, javacOptions :== Nil, scalacOptions :== Nil, @@ -802,7 +805,7 @@ object Defaults extends BuildCommon { fileInputOptions := Seq("-doc-root-content", "-diagrams-dot-path"), key in TaskGlobal := { val s = streams.value - val cs: IncrementalCompilerImpl.Compilers = compilers.value match { case c: IncrementalCompilerImpl.Compilers => c } + val cs: Compilers = compilers.value val srcs = sources.value val out = target.value val sOpts = scalacOptions.value @@ -819,10 +822,14 @@ object Defaults extends BuildCommon { (hasScala, hasJava) match { case (true, _) => val options = sOpts ++ Opts.doc.externalAPI(xapis) - val runDoc = Doc.scaladoc(label, s.cacheDirectory / "scala", cs.scalac.onArgs(exported(s, "scaladoc")), fiOpts) + val runDoc = Doc.scaladoc(label, s.cacheDirectory / "scala", + cs.scalac match { + case ac: AnalyzingCompiler => ac.onArgs(exported(s, "scaladoc")) + }, + fiOpts) runDoc(srcs, cp, out, options, maxErrors.value, s.log) case (_, true) => - val javadoc = sbt.inc.Doc.cachedJavadoc(label, s.cacheDirectory / "java", cs.javac) + val javadoc = sbt.inc.Doc.cachedJavadoc(label, s.cacheDirectory / "java", cs.javaTools) javadoc.run(srcs.toList, cp, out, javacOptions.value.toList, s.log, reporter) case _ => () // do nothing } @@ -841,12 +848,14 @@ 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 { - // TODO: Make exhaustive after zinc is updated to include https://github.com/sbt/zinc/pull/128 - case (cs: IncrementalCompilerImpl.Compilers, cp, options, initCommands, cleanup, temp, si, s) => + case (cs: 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)) - val compiler = cs.scalac.onArgs(exported(s, "scala")) + val compiler = + cs.scalac match { + case ac: AnalyzingCompiler => ac.onArgs(exported(s, "scala")) + } (new Console(compiler))(cpFiles, options, loader, initCommands, cleanup)()(s.log).foreach(msg => sys.error(msg)) println() } @@ -879,20 +888,33 @@ object Defaults extends BuildCommon { private[this] def compileIncrementalTaskImpl(s: TaskStreams, ci: Inputs): CompileResult = { lazy val x = s.text(ExportStream) - 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 } + def onArgs(cs: Compilers) = + cs.withScalac( + cs.scalac match { + case ac: AnalyzingCompiler => ac.onArgs(exported(x, "scalac")) + case x => x + } + ) + // .withJavac( + // cs.javac.onArgs(exported(x, "javac")) + //) + val compilers: Compilers = ci.compilers val i = ci.withCompilers(onArgs(compilers)) try Compiler.compile(i, s.log) finally x.close() // workaround for #937 } def compileIncSetupTask = Def.task { - val dc: File => DefinesClass = { - val dc = definesClass.value - f => new DefinesClass { override def apply(className: String): Boolean = dc(f)(className) } + val lookup = new PerClasspathEntryLookup { + private val cachedAnalysisMap = analysisMap(dependencyClasspath.value) + private val cachedPerEntryDefinesClassLookup = Keys.classpathEntryDefinesClass.value + + override def analysis(classpathEntry: File): Maybe[CompileAnalysis] = + o2m(cachedAnalysisMap(classpathEntry)) + override def definesClass(classpathEntry: File): DefinesClass = + cachedPerEntryDefinesClassLookup(classpathEntry) } new Setup( - f1(t => o2m(analysisMap(dependencyClasspath.value)(t))), - f1(dc), + lookup, (skip in compile).value, // TODO - this is kind of a bad way to grab the cache directory for streams... streams.value.cacheDirectory / compileAnalysisFilename.value, diff --git a/main/src/main/scala/sbt/Keys.scala b/main/src/main/scala/sbt/Keys.scala index 2e214701b..d3e828085 100644 --- a/main/src/main/scala/sbt/Keys.scala +++ b/main/src/main/scala/sbt/Keys.scala @@ -8,10 +8,10 @@ import java.net.URL import scala.concurrent.duration.{ FiniteDuration, Duration } import Def.ScopedKey import sbt.internal.util.complete._ -import sbt.internal.inc.Locate.DefinesClass -import sbt.internal.inc.{ ClasspathOptions, MixedAnalyzingCompiler, ScalaInstance } +import xsbti.compile.DefinesClass +import sbt.internal.inc.{ MixedAnalyzingCompiler, ScalaInstance } import std.TaskExtra._ -import xsbti.compile.{ CompileAnalysis, CompileOptions, CompileOrder, Compilers, CompileResult, GlobalsCache, IncOptions, Inputs, PreviousResult, Setup } +import xsbti.compile.{ ClasspathOptions, 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 @@ -195,7 +195,7 @@ object Keys { 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) + val classpathEntryDefinesClass = TaskKey[File => DefinesClass]("classpath-entry-defines-class", "Internal use: provides a function that determines whether the provided file contains a given class.", Invisible) val doc = TaskKey[File]("doc", "Generates API documentation.", AMinusTask) val copyResources = TaskKey[Seq[(File, File)]]("copy-resources", "Copies resources to the output directory.", AMinusTask) val aggregate = SettingKey[Boolean]("aggregate", "Configures task aggregation.", BMinusSetting) diff --git a/main/src/main/scala/sbt/internal/ConsoleProject.scala b/main/src/main/scala/sbt/internal/ConsoleProject.scala index a10cb4147..fcdba0cdb 100644 --- a/main/src/main/scala/sbt/internal/ConsoleProject.scala +++ b/main/src/main/scala/sbt/internal/ConsoleProject.scala @@ -8,7 +8,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, IncrementalCompilerImpl, ScalaInstance } +import sbt.internal.inc.{ AnalyzingCompiler, ClasspathOptionsUtil, IncrementalCompilerImpl, ScalaInstance } object ConsoleProject { def apply(state: State, extra: String, cleanupCommands: String = "", options: Seq[String] = Nil)(implicit log: Logger): Unit = { @@ -22,7 +22,7 @@ object ConsoleProject { ScalaInstance(scalaProvider.version, scalaProvider.launcher) } val sourcesModule = extracted.get(Keys.scalaCompilerBridgeSource) - val compiler = Compiler.scalaCompiler(scalaInstance, ClasspathOptions.repl, None, ivyConf, sourcesModule)(state.configuration, log) + val compiler = Compiler.scalaCompiler(scalaInstance, ClasspathOptionsUtil.repl, None, ivyConf, sourcesModule)(state.configuration, log) 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/internal/Load.scala b/main/src/main/scala/sbt/internal/Load.scala index 08a136c82..99e14e78f 100755 --- a/main/src/main/scala/sbt/internal/Load.scala +++ b/main/src/main/scala/sbt/internal/Load.scala @@ -13,7 +13,7 @@ import java.net.{ URI, URL } import compiler.{ Eval, EvalImports } import scala.annotation.tailrec import collection.mutable -import sbt.internal.inc.{ Analysis, ClasspathOptions, FileValueCache, Locate, ModuleUtilities } +import sbt.internal.inc.{ Analysis, ClasspathOptionsUtil, FileValueCache, Locate, ModuleUtilities } import sbt.internal.inc.classpath.ClasspathUtilities import Project.inScope import Def.{ isDummy, ScopedKey, ScopeLocal, Setting } @@ -26,7 +26,6 @@ import Scope.{ GlobalScope, ThisScope } import sbt.internal.util.Types.const import BuildPaths._ import BuildStreams._ -import Locate.DefinesClass import sbt.io.{ GlobFilter, IO, Path } import sbt.internal.io.Alternatives import sbt.util.Logger @@ -38,15 +37,13 @@ private[sbt] object Load { { val globalBase = getGlobalBase(state) val base = baseDirectory.getCanonicalFile - val definesClass = FileValueCache(Locate.definesClass _) - val rawConfig = defaultPreGlobal(state, base, definesClass.get, globalBase, log) + val rawConfig = defaultPreGlobal(state, base, globalBase, log) val config0 = defaultWithGlobal(state, base, rawConfig, globalBase, log) val config = if (isPlugin) enableSbtPlugin(config0) else config0.copy(extraBuilds = topLevelExtras) val result = apply(base, state, config) - definesClass.clear() result } - def defaultPreGlobal(state: State, baseDirectory: File, definesClass: DefinesClass, globalBase: File, log: Logger): LoadBuildConfiguration = + def defaultPreGlobal(state: State, baseDirectory: File, globalBase: File, log: Logger): LoadBuildConfiguration = { val provider = state.configuration.provider val scalaProvider = provider.scalaProvider @@ -59,13 +56,13 @@ private[sbt] object Load { val ivyPaths = new IvyPaths(baseDirectory, bootIvyHome(state.configuration)) val ivyConfiguration = new InlineIvyConfiguration(ivyPaths, Resolver.withDefaultResolvers(Nil), Nil, Nil, localOnly, lock, checksums, None, UpdateOptions(), log) - val compilers = Compiler.compilers(ClasspathOptions.boot, ivyConfiguration)(state.configuration, log) + val compilers = Compiler.compilers(ClasspathOptionsUtil.boot, ivyConfiguration)(state.configuration, log) val evalPluginDef = EvaluateTask.evalPluginDef(log) _ val delegates = defaultDelegates val initialID = baseDirectory.getName val pluginMgmt = PluginManagement(loader) val inject = InjectSettings(injectGlobal(state), Nil, const(Nil)) - new LoadBuildConfiguration(stagingDirectory, classpath, loader, compilers, evalPluginDef, definesClass, delegates, + new LoadBuildConfiguration(stagingDirectory, classpath, loader, compilers, evalPluginDef, delegates, EvaluateTask.injectStreams, pluginMgmt, inject, None, Nil, log) } private def bootIvyHome(app: xsbti.AppConfiguration): Option[File] = @@ -905,7 +902,6 @@ final case class LoadBuildConfiguration( loader: ClassLoader, compilers: Compilers, evalPluginDef: (BuildStructure, State) => PluginData, - definesClass: DefinesClass, delegates: LoadedBuild => Scope => Seq[Scope], scopeLocal: ScopeLocal, pluginManagement: PluginManagement, diff --git a/project/Dependencies.scala b/project/Dependencies.scala index 817af7e28..d5de24446 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -12,7 +12,7 @@ object Dependencies { val ioVersion = "1.0.0-M6" val utilVersion = "0.1.0-M13" val librarymanagementVersion = "0.1.0-M12" - val zincVersion = "1.0.0-M3" + val zincVersion = "1.0.0-M5" lazy val sbtIO = "org.scala-sbt" %% "io" % ioVersion lazy val utilCollection = "org.scala-sbt" %% "util-collection" % utilVersion lazy val utilLogging = "org.scala-sbt" %% "util-logging" % utilVersion