luke
/
sbt
mirror of https://github.com/sbt/sbt.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Adapting to Zinc changes

This commit is contained in:
Eugene Yokota 2016-06-26 03:49:11 +02:00
parent 824b59a3ef
commit 246ec58e35
9 changed files with 58 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
main-actions/src/main/scala/sbt/Compiler.scala
View File

@ -3,10 +3,10 @@
*/
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 java.io.File
@ -120,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 =
{

6
main-actions/src/main/scala/sbt/Console.scala
View File

@ -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 })
}
}

21
main-actions/src/main/scala/sbt/Doc.scala
View File

@ -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 {

3
main-actions/src/main/scala/sbt/RawCompileLike.scala
View File

@ -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

45
main/src/main/scala/sbt/Defaults.scala
View File

@ -9,9 +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 xsbti.compile.PerClasspathEntryLookup
import Project.{ inConfig, inScope, inTask, richInitialize, richInitializeTask, richTaskSessionVar }
import Def.{ Initialize, ScopedKey, Setting, SettingsDefinition }
import sbt.internal.librarymanagement.{ CustomPomParser, DependencyFilter }
@ -21,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` => _, _ }
@ -54,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"
@ -255,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,
@ -803,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
@ -820,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
}
@ -842,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()
}
@ -880,8 +888,17 @@ 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

4
main/src/main/scala/sbt/Keys.scala
View File

@ -9,9 +9,9 @@ import scala.concurrent.duration.{ FiniteDuration, Duration }
import Def.ScopedKey
import sbt.internal.util.complete._
import xsbti.compile.DefinesClass
import sbt.internal.inc.{ ClasspathOptions, MixedAnalyzingCompiler, ScalaInstance }
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

4
main/src/main/scala/sbt/internal/ConsoleProject.scala
View File

@ -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

4
main/src/main/scala/sbt/internal/Load.scala
View File

@ -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 }
@ -56,7 +56,7 @@ 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

2
project/Dependencies.scala
View File

@ -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-M3-2541fa40f245c612f5ad8d363b0ffea6dbffa991"
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