diff --git a/compile/integration/src/main/scala/sbt/compiler/AggressiveCompile.scala b/compile/integration/src/main/scala/sbt/compiler/AggressiveCompile.scala index 38ccc7da7..c4ce04804 100644 --- a/compile/integration/src/main/scala/sbt/compiler/AggressiveCompile.scala +++ b/compile/integration/src/main/scala/sbt/compiler/AggressiveCompile.scala @@ -200,13 +200,14 @@ object AggressiveCompile { b } } - + @deprecated("0.13.8", "Deprecated in favor of new sbt.compiler.javac package.") def directOrFork(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File]): JavaTool = if (javaHome.isDefined) JavaCompiler.fork(cpOptions, instance)(forkJavac(javaHome)) else JavaCompiler.directOrFork(cpOptions, instance)(forkJavac(None)) + @deprecated("0.13.8", "Deprecated in favor of new sbt.compiler.javac package.") def forkJavac(javaHome: Option[File]): JavaCompiler.Fork = { import Path._ @@ -225,6 +226,7 @@ object AggressiveCompile { } } +@deprecated("0.13.8", "Deprecated in favor of new sbt.compiler.javac package.") private[sbt] class JavacLogger(log: Logger) extends ProcessLogger { import scala.collection.mutable.ListBuffer import Level.{ Info, Warn, Error, Value => LogLevel } diff --git a/compile/src/main/scala/sbt/compiler/javac/DiagnosticsReporter.scala b/compile/src/main/scala/sbt/compiler/javac/DiagnosticsReporter.scala index d898fbac2..3efcdfabf 100644 --- a/compile/src/main/scala/sbt/compiler/javac/DiagnosticsReporter.scala +++ b/compile/src/main/scala/sbt/compiler/javac/DiagnosticsReporter.scala @@ -11,7 +11,7 @@ import xsbti.{ Severity, Reporter } * @param reporter */ final class DiagnosticsReporter(reporter: Reporter) extends DiagnosticListener[JavaFileObject] { - val END_OF_LINE_MATCHER = "[\r\n]|[\r]|[\n]" + val END_OF_LINE_MATCHER = "(\r\n)|[\r]|[\n]" val EOL = System.getProperty("line.separator") private def fixedDiagnosticMessage(d: Diagnostic[_ <: JavaFileObject]): String = { def getRawMessage = d.getMessage(null) diff --git a/compile/src/main/scala/sbt/compiler/javac/ForkedJava.scala b/compile/src/main/scala/sbt/compiler/javac/ForkedJava.scala index a329b3c98..4797d08e8 100644 --- a/compile/src/main/scala/sbt/compiler/javac/ForkedJava.scala +++ b/compile/src/main/scala/sbt/compiler/javac/ForkedJava.scala @@ -63,11 +63,11 @@ object ForkedJava { } /** An implementation of compiling java which forks a Javac instance. */ -final class ForkedJavaCompiler(javaHome: Option[File]) extends NewJavaCompiler { +final class ForkedJavaCompiler(javaHome: Option[File]) extends JavaCompiler { def run(sources: Seq[File], options: Seq[String])(implicit log: Logger, reporter: Reporter): Boolean = ForkedJava.launch(javaHome, "javac", sources, options, log, reporter) } -final class ForkedJavadoc(javaHome: Option[File]) extends NewJavadoc { +final class ForkedJavadoc(javaHome: Option[File]) extends Javadoc { def run(sources: Seq[File], options: Seq[String])(implicit log: Logger, reporter: Reporter): Boolean = ForkedJava.launch(javaHome, "javadoc", sources, options, log, reporter) } diff --git a/compile/src/main/scala/sbt/compiler/javac/NewJavaCompiler.scala b/compile/src/main/scala/sbt/compiler/javac/JavaCompiler.scala similarity index 89% rename from compile/src/main/scala/sbt/compiler/javac/NewJavaCompiler.scala rename to compile/src/main/scala/sbt/compiler/javac/JavaCompiler.scala index 03643abeb..8ea1be070 100644 --- a/compile/src/main/scala/sbt/compiler/javac/NewJavaCompiler.scala +++ b/compile/src/main/scala/sbt/compiler/javac/JavaCompiler.scala @@ -17,7 +17,7 @@ import xsbti.{ Severity, Reporter } */ sealed trait JavaTools { /** The raw interface of the java compiler for direct access. */ - def compiler: NewJavaTool + def compiler: JavaTool /** * This will run a java compiler. * @@ -53,7 +53,7 @@ sealed trait IncrementalCompilerJavaTools extends JavaTools { /** Factory methods for getting a java toolchain. */ object JavaTools { /** Create a new aggregate tool from existing tools. */ - def apply(c: NewJavaCompiler, docgen: NewJavadoc): JavaTools = + def apply(c: JavaCompiler, docgen: Javadoc): JavaTools = new JavaTools { override def compiler = c def compile(sources: Seq[File], options: Seq[String])(implicit log: Logger, reporter: Reporter): Boolean = @@ -77,10 +77,10 @@ object JavaTools { */ def directOrFork(instance: xsbti.compile.ScalaInstance, cpOptions: xsbti.compile.ClasspathOptions, javaHome: Option[File]): IncrementalCompilerJavaTools = { val (compiler, doc) = javaHome match { - case Some(_) => (NewJavaCompiler.fork(javaHome), NewJavadoc.fork(javaHome)) + case Some(_) => (JavaCompiler.fork(javaHome), Javadoc.fork(javaHome)) case _ => - val c = NewJavaCompiler.local.getOrElse(NewJavaCompiler.fork(None)) - val d = NewJavadoc.local.getOrElse(NewJavadoc.fork()) + val c = JavaCompiler.local.getOrElse(JavaCompiler.fork(None)) + val d = Javadoc.local.getOrElse(Javadoc.fork()) (c, d) } val delegate = apply(compiler, doc) @@ -102,7 +102,7 @@ object JavaTools { * - The all take sources and options and log error messages * - They return success or failure. */ -sealed trait NewJavaTool { +sealed trait JavaTool { /** * This will run a java compiler / or other like tool (e.g. javadoc). * @@ -117,34 +117,34 @@ sealed trait NewJavaTool { } /** Interface we use to compile java code. This is mostly a tag over the raw JavaTool interface. */ -trait NewJavaCompiler extends NewJavaTool {} +trait JavaCompiler extends JavaTool {} /** Factory methods for constructing a java compiler. */ -object NewJavaCompiler { +object JavaCompiler { /** Returns a local compiler, if the current runtime supports it. */ - def local: Option[NewJavaCompiler] = + def local: Option[JavaCompiler] = for { compiler <- Option(javax.tools.ToolProvider.getSystemJavaCompiler) } yield new LocalJavaCompiler(compiler) /** Returns a local compiler that will fork javac when needed. */ - def fork(javaHome: Option[File] = None): NewJavaCompiler = + def fork(javaHome: Option[File] = None): JavaCompiler = new ForkedJavaCompiler(javaHome) } /** Interface we use to document java code. This is a tag over the raw JavaTool interface. */ -trait NewJavadoc extends NewJavaTool {} +trait Javadoc extends JavaTool {} /** Factory methods for constructing a javadoc. */ -object NewJavadoc { +object Javadoc { /** Returns a local compiler, if the current runtime supports it. */ - def local: Option[NewJavadoc] = + def local: Option[Javadoc] = // TODO - javax doc tool not supported in JDK6 //Option(javax.tools.ToolProvider.getSystemDocumentationTool) if (LocalJava.hasLocalJavadoc) Some(new LocalJavadoc) else None /** Returns a local compiler that will fork javac when needed. */ - def fork(javaHome: Option[File] = None): NewJavadoc = + def fork(javaHome: Option[File] = None): Javadoc = new ForkedJavadoc(javaHome) } diff --git a/compile/src/main/scala/sbt/compiler/javac/JavaCompilerAdapter.scala b/compile/src/main/scala/sbt/compiler/javac/JavaCompilerAdapter.scala index cf581679f..7ee67543a 100644 --- a/compile/src/main/scala/sbt/compiler/javac/JavaCompilerAdapter.scala +++ b/compile/src/main/scala/sbt/compiler/javac/JavaCompilerAdapter.scala @@ -14,7 +14,7 @@ import xsbti.compile.{ MultipleOutput, SingleOutput, Output } * wrapper around running Javac (forked or direct) into the interfaces used by incremental compiler. * */ -class JavaCompilerAdapter(delegate: NewJavaTool, scalaInstance: xsbti.compile.ScalaInstance, cpOptions: xsbti.compile.ClasspathOptions) extends xsbti.compile.JavaCompiler { +class JavaCompilerAdapter(delegate: JavaTool, scalaInstance: xsbti.compile.ScalaInstance, cpOptions: xsbti.compile.ClasspathOptions) extends xsbti.compile.JavaCompiler { override final def compile(sources: Array[File], classpath: Array[File], output: Output, options: Array[String], log: xsbti.Logger): Unit = { // TODO - 5 max errors ok? We're not expecting this code path to be called, ever. This is only for clients who try to use the xsbti.compile.JavaCompiler interface // outside of the incremental compiler, for some reason. diff --git a/compile/src/main/scala/sbt/compiler/javac/LocalJava.scala b/compile/src/main/scala/sbt/compiler/javac/LocalJava.scala index 406c49c3a..81f4e1293 100644 --- a/compile/src/main/scala/sbt/compiler/javac/LocalJava.scala +++ b/compile/src/main/scala/sbt/compiler/javac/LocalJava.scala @@ -35,7 +35,7 @@ object LocalJava { } } /** Implementation of javadoc tool which attempts to run it locally (in-class). */ -final class LocalJavadoc() extends NewJavadoc { +final class LocalJavadoc() extends Javadoc { override def run(sources: Seq[File], options: Seq[String])(implicit log: Logger, reporter: Reporter): Boolean = { val cwd = new File(new File(".").getAbsolutePath).getCanonicalFile val (jArgs, nonJArgs) = options.partition(_.startsWith("-J")) @@ -57,7 +57,7 @@ final class LocalJavadoc() extends NewJavadoc { } /** An implementation of compiling java which delegates to the JVM resident java compiler. */ -final class LocalJavaCompiler(compiler: javax.tools.JavaCompiler) extends NewJavaCompiler { +final class LocalJavaCompiler(compiler: javax.tools.JavaCompiler) extends JavaCompiler { override def run(sources: Seq[File], options: Seq[String])(implicit log: Logger, reporter: Reporter): Boolean = { import collection.JavaConverters._ val logger = new LoggerWriter(log) diff --git a/compile/src/test/scala/sbt/compiler/javac/NewJavaCompilerSpec.scala b/compile/src/test/scala/sbt/compiler/javac/NewJavaCompilerSpec.scala index 9357cf201..d0333d797 100644 --- a/compile/src/test/scala/sbt/compiler/javac/NewJavaCompilerSpec.scala +++ b/compile/src/test/scala/sbt/compiler/javac/NewJavaCompilerSpec.scala @@ -115,12 +115,12 @@ object NewJavaCompilerSpec extends Specification { } // TODO - Create one with known JAVA HOME. - def forked = JavaTools(NewJavaCompiler.fork(), NewJavadoc.fork()) + def forked = JavaTools(JavaCompiler.fork(), Javadoc.fork()) def local = JavaTools( - NewJavaCompiler.local.getOrElse(sys.error("This test cannot be run on a JRE, but only a JDK.")), - NewJavadoc.local.getOrElse(NewJavadoc.fork()) + JavaCompiler.local.getOrElse(sys.error("This test cannot be run on a JRE, but only a JDK.")), + Javadoc.local.getOrElse(Javadoc.fork()) ) def cwd = diff --git a/main/actions/src/main/scala/sbt/Compiler.scala b/main/actions/src/main/scala/sbt/Compiler.scala index 9cd51f72f..672e4105e 100644 --- a/main/actions/src/main/scala/sbt/Compiler.scala +++ b/main/actions/src/main/scala/sbt/Compiler.scala @@ -3,7 +3,7 @@ */ package sbt -import sbt.compiler.javac.{ IncrementalCompilerJavaTools, NewJavaCompiler, JavaTools } +import sbt.compiler.javac.{ IncrementalCompilerJavaTools, JavaCompiler, JavaTools } import xsbti.{ Logger => _, _ } import xsbti.compile.{ CompileOrder, GlobalsCache } import CompileOrder.{ JavaThenScala, Mixed, ScalaThenJava } @@ -60,11 +60,13 @@ object Compiler { } compilers(instance, cpOptions, CheaterJavaTool(javac2, javac)) } - def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javac: JavaCompiler.Fork)(implicit app: AppConfiguration, log: Logger): Compilers = + @deprecated("0.13.8", "Deprecated in favor of new sbt.compiler.javac package.") + def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javac: sbt.compiler.JavaCompiler.Fork)(implicit app: AppConfiguration, log: Logger): Compilers = { - val javaCompiler = JavaCompiler.fork(cpOptions, instance)(javac) + val javaCompiler = sbt.compiler.JavaCompiler.fork(cpOptions, instance)(javac) compilers(instance, cpOptions, javaCompiler) } + @deprecated("0.13.8", "Deprecated in favor of new sbt.compiler.javac package.") def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javac: JavaTool)(implicit app: AppConfiguration, log: Logger): Compilers = { val scalac = scalaCompiler(instance, cpOptions)