From d837f869bd922ae0b2e34ad8c9e90ab2c45a75b4 Mon Sep 17 00:00:00 2001 From: Mark Harrah Date: Mon, 9 Jan 2012 08:00:35 -0500 Subject: [PATCH] using some of the embedding interfaces --- compile/ClasspathOptions.scala | 2 +- compile/JavaCompiler.scala | 31 +++++++++++++------ compile/inc/CompileSetup.scala | 14 +++------ compile/integration/AggressiveCompile.scala | 12 ++++--- compile/persist/AnalysisFormats.scala | 11 +++++-- .../java/xsbti/compile/ScalaInstance.java | 4 +-- main/Defaults.scala | 8 +++-- main/Keys.scala | 3 +- main/Load.scala | 1 + main/actions/Compiler.scala | 14 +++++---- main/actions/Doc.scala | 6 ++-- project/Sbt.scala | 2 +- sbt/package.scala | 4 +++ util/classpath/ScalaInstance.scala | 6 +++- 14 files changed, 74 insertions(+), 44 deletions(-) diff --git a/compile/ClasspathOptions.scala b/compile/ClasspathOptions.scala index edbf1a3d3..548ec888e 100644 --- a/compile/ClasspathOptions.scala +++ b/compile/ClasspathOptions.scala @@ -3,7 +3,7 @@ */ package sbt -final case class ClasspathOptions(bootLibrary: Boolean, compiler: Boolean, extra: Boolean, autoBoot: Boolean, filterLibrary: Boolean) +final case class ClasspathOptions(bootLibrary: Boolean, compiler: Boolean, extra: Boolean, autoBoot: Boolean, filterLibrary: Boolean) extends xsbti.compile.ClasspathOptions object ClasspathOptions { def manual = ClasspathOptions(false, false, false, true, false) diff --git a/compile/JavaCompiler.scala b/compile/JavaCompiler.scala index 7edd7ab24..817f171d3 100644 --- a/compile/JavaCompiler.scala +++ b/compile/JavaCompiler.scala @@ -9,14 +9,25 @@ import java.io.{File, PrintWriter} abstract class JavacContract(val name: String, val clazz: String) { def exec(args: Array[String], writer: PrintWriter): Int } -trait JavaCompiler +trait JavaCompiler extends xsbti.compile.JavaCompiler { - def apply(sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String])(implicit log: Logger) { + def apply(sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String])(implicit log: Logger) + + def compile(sources: Array[File], classpath: Array[File], outputDirectory: File, options: Array[String], maxErrors: Int, log: xsbti.Logger): Unit = + apply(sources, classpath, outputDirectory, options)(log) +} +trait Javadoc +{ + def doc(sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String], maximumErrors: Int, log: Logger) +} +trait JavaTool extends Javadoc with JavaCompiler +{ + def apply(sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String])(implicit log: Logger) = compile(JavaCompiler.javac, sources, classpath, outputDirectory, options)(log) - } - def doc(sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String], maximumErrors: Int, log: Logger) { + + def doc(sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String], maximumErrors: Int, log: Logger) = compile(JavaCompiler.javadoc, sources, classpath, outputDirectory, options)(log) - } + def compile(contract: JavacContract, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String])(implicit log: Logger): Unit } object JavaCompiler @@ -36,8 +47,8 @@ object JavaCompiler } } - def construct(f: Fork, cp: ClasspathOptions, scalaInstance: ScalaInstance): JavaCompiler = - new JavaCompiler { + def construct(f: Fork, cp: ClasspathOptions, scalaInstance: ScalaInstance): JavaTool = + new JavaTool { def compile(contract: JavacContract, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String])(implicit log: Logger) { val augmentedClasspath = if(cp.autoBoot) classpath ++ Seq(scalaInstance.libraryJar) else classpath val javaCp = ClasspathOptions.javac(cp.compiler) @@ -48,13 +59,13 @@ object JavaCompiler if( code != 0 ) throw new CompileFailed(arguments.toArray, contract.name + " returned nonzero exit code") } } - def directOrFork(cp: ClasspathOptions, scalaInstance: ScalaInstance)(implicit doFork: Fork): JavaCompiler = + def directOrFork(cp: ClasspathOptions, scalaInstance: ScalaInstance)(implicit doFork: Fork): JavaTool = construct(directOrForkJavac, cp, scalaInstance) - def direct(cp: ClasspathOptions, scalaInstance: ScalaInstance): JavaCompiler = + def direct(cp: ClasspathOptions, scalaInstance: ScalaInstance): JavaTool = construct(directJavac, cp, scalaInstance) - def fork(cp: ClasspathOptions, scalaInstance: ScalaInstance)(implicit doFork: Fork): JavaCompiler = + def fork(cp: ClasspathOptions, scalaInstance: ScalaInstance)(implicit doFork: Fork): JavaTool = construct(forkJavac, cp, scalaInstance) def directOrForkJavac(implicit doFork: Fork) = (contract: JavacContract, arguments: Seq[String], log: Logger) => diff --git a/compile/inc/CompileSetup.scala b/compile/inc/CompileSetup.scala index 2c9b15712..8426f85bf 100644 --- a/compile/inc/CompileSetup.scala +++ b/compile/inc/CompileSetup.scala @@ -3,24 +3,20 @@ */ package sbt + import xsbti.compile.CompileOrder import java.io.File -object CompileOrder extends Enumeration -{ - val Mixed, JavaThenScala, ScalaThenJava = Value -} - // this class exists because of Scala's restriction on implicit parameter search. // We cannot require an implicit parameter Equiv[Seq[String]] to construct Equiv[CompileSetup] // because complexity(Equiv[Seq[String]]) > complexity(Equiv[CompileSetup]) // (6 > 4) final class CompileOptions(val options: Seq[String], val javacOptions: Seq[String]) -final class CompileSetup(val outputDirectory: File, val options: CompileOptions, val compilerVersion: String, val order: CompileOrder.Value) +final class CompileSetup(val outputDirectory: File, val options: CompileOptions, val compilerVersion: String, val order: CompileOrder) object CompileSetup { // Equiv[CompileOrder.Value] dominates Equiv[CompileSetup] - implicit def equivCompileSetup(implicit equivFile: Equiv[File], equivOpts: Equiv[CompileOptions], equivComp: Equiv[String]/*, equivOrder: Equiv[CompileOrder.Value]*/): Equiv[CompileSetup] = new Equiv[CompileSetup] { + implicit def equivCompileSetup(implicit equivFile: Equiv[File], equivOpts: Equiv[CompileOptions], equivComp: Equiv[String]/*, equivOrder: Equiv[CompileOrder]*/): Equiv[CompileSetup] = new Equiv[CompileSetup] { def equiv(a: CompileSetup, b: CompileSetup) = equivFile.equiv(a.outputDirectory, b.outputDirectory) && equivOpts.equiv(a.options, b.options) && @@ -39,7 +35,7 @@ object CompileSetup def equiv(a: String, b: String) = a == b } - implicit val equivOrder: Equiv[CompileOrder.Value] = new Equiv[CompileOrder.Value] { - def equiv(a: CompileOrder.Value, b: CompileOrder.Value) = a == b + implicit val equivOrder: Equiv[CompileOrder] = new Equiv[CompileOrder] { + def equiv(a: CompileOrder, b: CompileOrder) = a == b } } \ No newline at end of file diff --git a/compile/integration/AggressiveCompile.scala b/compile/integration/AggressiveCompile.scala index 86adb9d30..0cc348da7 100644 --- a/compile/integration/AggressiveCompile.scala +++ b/compile/integration/AggressiveCompile.scala @@ -10,11 +10,13 @@ import inc._ import classpath.ClasspathUtilities import classfile.Analyze import xsbti.api.Source + import xsbti.compile.CompileOrder + import CompileOrder.{JavaThenScala, Mixed, ScalaThenJava} import xsbti.AnalysisCallback import inc.Locate.DefinesClass import CompileSetup._ - import CompileOrder.{JavaThenScala, Mixed, ScalaThenJava} import sbinary.DefaultProtocol.{ immutableMapFormat, immutableSetFormat, StringFormat } + import Types.const final class CompileConfiguration(val sources: Seq[File], val classpath: Seq[File], val previousAnalysis: Analysis, val previousSetup: Option[CompileSetup], val currentSetup: CompileSetup, val getAnalysis: File => Option[Analysis], val definesClass: DefinesClass, @@ -22,7 +24,7 @@ final class CompileConfiguration(val sources: Seq[File], val classpath: Seq[File class AggressiveCompile(cacheFile: 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, definesClass: DefinesClass = Locate.definesClass _, maxErrors: Int = 100, compileOrder: CompileOrder.Value = Mixed, skip: Boolean = false)(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: File => Option[Analysis] = const(None), definesClass: DefinesClass = Locate.definesClass _, maxErrors: Int = 100, compileOrder: CompileOrder = Mixed, skip: Boolean = false)(implicit log: Logger): Analysis = { val setup = new CompileSetup(outputDirectory, new CompileOptions(options, javacOptions), compiler.scalaInstance.actualVersion, compileOrder) compile1(sources, classpath, setup, store, analysisMap, definesClass, compiler, javac, maxErrors, skip) @@ -31,13 +33,13 @@ class AggressiveCompile(cacheFile: File) def withBootclasspath(args: CompilerArguments, classpath: Seq[File]): Seq[File] = args.bootClasspath ++ args.finishClasspath(classpath) - def compile1(sources: Seq[File], classpath: Seq[File], setup: CompileSetup, store: AnalysisStore, analysis: Map[File, Analysis], definesClass: DefinesClass, compiler: AnalyzingCompiler, javac: JavaCompiler, maxErrors: Int, skip: Boolean)(implicit log: Logger): Analysis = + def compile1(sources: Seq[File], classpath: Seq[File], setup: CompileSetup, store: AnalysisStore, analysis: File => Option[Analysis], definesClass: DefinesClass, compiler: AnalyzingCompiler, javac: JavaCompiler, maxErrors: Int, skip: Boolean)(implicit log: Logger): Analysis = { val (previousAnalysis, previousSetup) = extract(store.get()) if(skip) previousAnalysis else { - val config = new CompileConfiguration(sources, classpath, previousAnalysis, previousSetup, setup, analysis.get _, definesClass, maxErrors, compiler, javac) + val config = new CompileConfiguration(sources, classpath, previousAnalysis, previousSetup, setup, analysis, definesClass, maxErrors, compiler, javac) val (modified, result) = compile2(config) if(modified) store.set(result, setup) @@ -122,7 +124,7 @@ object AggressiveCompile } } - def directOrFork(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File]): JavaCompiler = + def directOrFork(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File]): JavaTool = if(javaHome.isDefined) JavaCompiler.fork(cpOptions, instance)(forkJavac(javaHome)) else diff --git a/compile/persist/AnalysisFormats.scala b/compile/persist/AnalysisFormats.scala index 19c73f388..e1fec5237 100644 --- a/compile/persist/AnalysisFormats.scala +++ b/compile/persist/AnalysisFormats.scala @@ -6,6 +6,7 @@ package inc import xsbti.api.Source import xsbti.{Position,Problem,Severity} + import xsbti.compile.CompileOrder import java.io.File import sbinary._ import DefaultProtocol._ @@ -63,8 +64,8 @@ object AnalysisFormats wrap[Severity, Byte]( _.ordinal.toByte, b => Severity.values.apply(b.toInt) ) - implicit def setupFormat(implicit outDirF: Format[File], optionF: Format[CompileOptions], compilerVersion: Format[String], orderF: Format[CompileOrder.Value]): Format[CompileSetup] = - asProduct4[CompileSetup, File, CompileOptions, String, CompileOrder.Value]( (a,b,c,d) => new CompileSetup(a,b,c,d) )(s => (s.outputDirectory, s.options, s.compilerVersion, s.order))(outDirF, optionF, compilerVersion, orderF) + implicit def setupFormat(implicit outDirF: Format[File], optionF: Format[CompileOptions], compilerVersion: Format[String], orderF: Format[CompileOrder]): Format[CompileSetup] = + asProduct4[CompileSetup, File, CompileOptions, String, CompileOrder]( (a,b,c,d) => new CompileSetup(a,b,c,d) )(s => (s.outputDirectory, s.options, s.compilerVersion, s.order))(outDirF, optionF, compilerVersion, orderF) implicit def stampsFormat(implicit prodF: Format[Map[File, Stamp]], srcF: Format[Map[File, Stamp]], binF: Format[Map[File, Stamp]], nameF: Format[Map[File, String]]): Format[Stamps] = asProduct4( Stamps.apply _ )( s => (s.products, s.sources, s.binaries, s.classNames) )(prodF, srcF, binF, nameF) @@ -88,7 +89,11 @@ object AnalysisFormats implicit def optsFormat(implicit strF: Format[String]): Format[CompileOptions] = wrap[CompileOptions, (Seq[String],Seq[String])](co => (co.options, co.javacOptions), os => new CompileOptions(os._1, os._2)) - implicit val orderFormat: Format[CompileOrder.Value] = enumerationFormat(CompileOrder) + implicit val orderFormat: Format[CompileOrder] = + { + val values = CompileOrder.values + wrap[CompileOrder, Int](_.ordinal, values) + } implicit def seqFormat[T](implicit optionFormat: Format[T]): Format[Seq[T]] = viaSeq[Seq[T], T](x => x) implicit def hashStampFormat: Format[Hash] = wrap[Hash, Array[Byte]](_.value, new Hash(_)) diff --git a/interface/src/main/java/xsbti/compile/ScalaInstance.java b/interface/src/main/java/xsbti/compile/ScalaInstance.java index fd66d9a9c..4e41e1ca2 100644 --- a/interface/src/main/java/xsbti/compile/ScalaInstance.java +++ b/interface/src/main/java/xsbti/compile/ScalaInstance.java @@ -24,10 +24,10 @@ public interface ScalaInstance File compilerJar(); /** Jars provided by this Scala instance other than the compiler and library jars. */ - File[] extraJars(); + File[] otherJars(); /** All jar files provided by this Scala instance.*/ - File[] jars(); + File[] allJars(); /** The unique identifier for this Scala instance. An implementation should usually obtain this from the compiler.properties file in the compiler jar. */ String actualVersion(); diff --git a/main/Defaults.scala b/main/Defaults.scala index 2e828a42c..589da45a1 100755 --- a/main/Defaults.scala +++ b/main/Defaults.scala @@ -6,6 +6,7 @@ package sbt import Build.data import Scope.{fillTaskAxis, GlobalScope, ThisScope} import xsbt.api.Discovery + import xsbti.compile.CompileOrder import Project.{inConfig, Initialize, inScope, inTask, ScopedKey, Setting, SettingsDefinition} import Load.LoadedBuild import Artifact.{DocClassifier, SourceClassifier} @@ -43,8 +44,11 @@ object Defaults extends BuildCommon def extractAnalysis[T](a: Attributed[T]): (T, inc.Analysis) = (a.data, a.metadata get Keys.analysis getOrElse inc.Analysis.Empty) - def analysisMap[T](cp: Seq[Attributed[T]]): Map[T, inc.Analysis] = - (for(a <- cp; an <- a.metadata get Keys.analysis) yield (a.data, an) ).toMap + def analysisMap[T](cp: Seq[Attributed[T]]): T => Option[inc.Analysis] = + { + val m = (for(a <- cp; an <- a.metadata get Keys.analysis) yield (a.data, an) ).toMap + m.get _ + } def buildCore: Seq[Setting[_]] = thisBuildCore ++ globalCore def thisBuildCore: Seq[Setting[_]] = inScope(GlobalScope.copy(project = Select(ThisBuild)))(Seq( diff --git a/main/Keys.scala b/main/Keys.scala index 7e66a1d34..74a6b2a92 100644 --- a/main/Keys.scala +++ b/main/Keys.scala @@ -10,6 +10,7 @@ package sbt import inc.Analysis import inc.Locate.DefinesClass import std.TaskExtra._ + import xsbti.compile.CompileOrder import scala.xml.{Node => XNode, NodeSeq} import org.apache.ivy.core.module.{descriptor, id} import descriptor.ModuleDescriptor, id.ModuleRevisionId @@ -129,7 +130,7 @@ object Keys val scaladocOptions = TaskKey[Seq[String]]("scaladoc-options", "Options for Scaladoc.", DTask) val scalacOptions = TaskKey[Seq[String]]("scalac-options", "Options for the Scala compiler.", BPlusTask) val javacOptions = TaskKey[Seq[String]]("javac-options", "Options for the Java compiler.", BPlusTask) - val compileOrder = SettingKey[CompileOrder.Value]("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 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) diff --git a/main/Load.scala b/main/Load.scala index 19649eb1e..c86c2715e 100755 --- a/main/Load.scala +++ b/main/Load.scala @@ -7,6 +7,7 @@ package sbt import java.net.{URI,URL} import compiler.{Eval,EvalImports} import xsbt.api.{Discovered,Discovery} + import xsbti.compile.CompileOrder import classpath.ClasspathUtilities import scala.annotation.tailrec import collection.mutable diff --git a/main/actions/Compiler.scala b/main/actions/Compiler.scala index 7b978aeb0..e24d63500 100644 --- a/main/actions/Compiler.scala +++ b/main/actions/Compiler.scala @@ -4,6 +4,8 @@ package sbt import xsbti.{Logger => _,_} + import xsbti.compile.CompileOrder + import CompileOrder.{JavaThenScala, Mixed, ScalaThenJava} import compiler._ import inc._ import Locate.DefinesClass @@ -14,12 +16,12 @@ object Compiler val DefaultMaxErrors = 100 final case class Inputs(compilers: Compilers, config: Options, incSetup: IncSetup) - final case class Options(classpath: Seq[File], sources: Seq[File], classesDirectory: File, options: Seq[String], javacOptions: Seq[String], maxErrors: Int, order: CompileOrder.Value) - final case class IncSetup(analysisMap: Map[File, Analysis], definesClass: DefinesClass, skip: Boolean, cacheFile: File) - final case class Compilers(scalac: AnalyzingCompiler, javac: JavaCompiler) + final case class Options(classpath: Seq[File], sources: Seq[File], classesDirectory: File, options: Seq[String], javacOptions: Seq[String], maxErrors: Int, order: CompileOrder) + final case class IncSetup(analysisMap: File => Option[Analysis], definesClass: DefinesClass, skip: Boolean, cacheFile: File) + final case class Compilers(scalac: AnalyzingCompiler, javac: JavaTool) @deprecated("Use the other inputs variant.", "0.12.0") - def inputs(classpath: Seq[File], sources: Seq[File], outputDirectory: File, options: Seq[String], javacOptions: Seq[String], definesClass: DefinesClass, maxErrors: Int, order: CompileOrder.Value)(implicit compilers: Compilers, log: Logger): Inputs = + def inputs(classpath: Seq[File], sources: Seq[File], outputDirectory: File, options: Seq[String], javacOptions: Seq[String], definesClass: DefinesClass, maxErrors: Int, order: CompileOrder)(implicit compilers: Compilers, log: Logger): Inputs = { import Path._ val classesDirectory = outputDirectory / "classes" @@ -28,7 +30,7 @@ object Compiler val incSetup = IncSetup(Map.empty, definesClass, false, cacheFile) inputs(augClasspath, sources, classesDirectory, options, javacOptions, maxErrors, order)(compilers, incSetup, log) } - def inputs(classpath: Seq[File], sources: Seq[File], classesDirectory: File, options: Seq[String], javacOptions: Seq[String], maxErrors: Int, order: CompileOrder.Value)(implicit compilers: Compilers, incSetup: IncSetup, log: Logger): Inputs = + def inputs(classpath: Seq[File], sources: Seq[File], classesDirectory: File, options: Seq[String], javacOptions: Seq[String], maxErrors: Int, order: CompileOrder)(implicit compilers: Compilers, incSetup: IncSetup, log: Logger): Inputs = new Inputs( compilers, new Options(classpath, sources, classesDirectory, options, javacOptions, maxErrors, order), @@ -54,7 +56,7 @@ object Compiler val javaCompiler = JavaCompiler.fork(cpOptions, instance)(javac) compilers(instance, cpOptions, javaCompiler) } - def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javac: JavaCompiler)(implicit app: AppConfiguration, log: Logger): Compilers = + def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javac: JavaTool)(implicit app: AppConfiguration, log: Logger): Compilers = { val scalac = scalaCompiler(instance, cpOptions) new Compilers(scalac, javac) diff --git a/main/actions/Doc.scala b/main/actions/Doc.scala index 5e3600087..96f5fc70d 100644 --- a/main/actions/Doc.scala +++ b/main/actions/Doc.scala @@ -17,7 +17,7 @@ package sbt object Doc { def apply(maximumErrors: Int, compiler: AnalyzingCompiler) = new Scaladoc(maximumErrors, compiler) - def apply(maximumErrors: Int, compiler: JavaCompiler) = new Javadoc(maximumErrors, compiler) + def apply(maximumErrors: Int, compiler: sbt.compiler.Javadoc) = new Javadoc(maximumErrors, compiler) } sealed trait Doc { type Gen = (Seq[File], Seq[File], File, Seq[String], Int, Logger) => Unit @@ -62,11 +62,11 @@ final class Scaladoc(maximumErrors: Int, compiler: AnalyzingCompiler) extends Do generate("Scala", label, compiler.doc, sources, classpath, outputDirectory, options, maximumErrors, log) } } -final class Javadoc(maximumErrors: Int, compiler: JavaCompiler) extends Doc +final class Javadoc(maximumErrors: Int, doc: sbt.compiler.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, compiler.doc, sources.filterNot(_.name.endsWith(".scala")), classpath, outputDirectory, options, maximumErrors, log) + generate("Java", label, doc.doc, sources.filterNot(_.name.endsWith(".scala")), classpath, outputDirectory, options, maximumErrors, log) } } diff --git a/project/Sbt.scala b/project/Sbt.scala index fbf96d087..7d81c0d15 100644 --- a/project/Sbt.scala +++ b/project/Sbt.scala @@ -58,7 +58,7 @@ object Sbt extends Build // Path, IO (formerly FileUtilities), NameFilter and other I/O utility classes lazy val ioSub = testedBaseProject(utilPath / "io", "IO") dependsOn(controlSub) // Utilities related to reflection, managing Scala versions, and custom class loaders - lazy val classpathSub = baseProject(utilPath / "classpath", "Classpath") dependsOn(launchInterfaceSub, ioSub) settings(scalaCompiler) + lazy val classpathSub = baseProject(utilPath / "classpath", "Classpath") dependsOn(launchInterfaceSub, interfaceSub, ioSub) settings(scalaCompiler) // Command line-related utilities. lazy val completeSub = testedBaseProject(utilPath / "complete", "Completion") dependsOn(collectionSub, controlSub, ioSub) settings(jline) // logging diff --git a/sbt/package.scala b/sbt/package.scala index d53be82a5..c21ef9715 100644 --- a/sbt/package.scala +++ b/sbt/package.scala @@ -20,6 +20,10 @@ package object sbt extends sbt.std.TaskExtra with sbt.Types with sbt.ProcessExtr type File = java.io.File type URI = java.net.URI type URL = java.net.URL + type CompileOrder = xsbti.compile.CompileOrder + val JavaThenScala = xsbti.compile.CompileOrder.JavaThenScala + val ScalaThenJava = xsbti.compile.CompileOrder.ScalaThenJava + val Mixed = xsbti.compile.CompileOrder.Mixed implicit def maybeToOption[S](m: xsbti.Maybe[S]): Option[S] = if(m.isDefined) Some(m.get) else None diff --git a/util/classpath/ScalaInstance.scala b/util/classpath/ScalaInstance.scala index 68ec2b420..91dd6264c 100644 --- a/util/classpath/ScalaInstance.scala +++ b/util/classpath/ScalaInstance.scala @@ -10,8 +10,12 @@ package sbt * for the compiler itself. * The 'version' field is the version used to obtain the Scala classes. This is typically the version for the maven repository. * The 'actualVersion' field should be used to uniquely identify the compiler. It is obtained from the compiler.properties file.*/ -final class ScalaInstance(val version: String, val loader: ClassLoader, val libraryJar: File, val compilerJar: File, val extraJars: Seq[File], val explicitActual: Option[String]) +final class ScalaInstance(val version: String, val loader: ClassLoader, val libraryJar: File, val compilerJar: File, val extraJars: Seq[File], val explicitActual: Option[String]) extends xsbti.compile.ScalaInstance { + // These are to implement xsbti.ScalaInstance + def otherJars: Array[File] = extraJars.toArray + def allJars: Array[File] = jars.toArray + require(version.indexOf(' ') < 0, "Version cannot contain spaces (was '" + version + "')") def jars = libraryJar :: compilerJar :: extraJars.toList /** Gets the version of Scala in the compiler.properties file from the loader. This version may be different than that given by 'version'*/