Test on Java 8, Java 11 and Java 15.

Previously, the build used the Java version that `sbt` was launched
with. Now, the build automatically downloads appropriate Java versions
for each project.

* Build by default with Java 11.
* Build compiler plugin with Java 8.
* Cross-build the "minimized" project for Java 8/11/15.

Author: olafurpg

.github/workflows/ci.yml

@@ -10,8 +10,6 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - uses: olafurpg/setup-scala@v10
-        with:
-          java-version: [email protected]
       - uses: actions/setup-go@v2
         with:
           go-version: '^1.13.1'
@@ -22,6 +20,4 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - uses: olafurpg/setup-scala@v10
-        with:
-          java-version: [email protected]
       - run: sbt checkAll

README.md

@@ -13,17 +13,17 @@ Currently, only Java 8 with the build tool sbt is supported. We hope to increase
 compatibility with more Java language versions and build tools as the project
 evolves.
 
-| Language version | Support            |
-| ---------------- | ------------------ |
-| Java 7           | ❌                 |
-| Java 8           | ✅                 |
-| Java 11          | ✅                 |
-| Java 12          | Untested, may work |
-| Java 13          | Untested, may work |
-| Java 14          | Untested, may work |
-| Java 15          | Untested, may work |
-| Java 16          | Untested, may work |
-| Java 17          | Untested, may work |
+| Language version | Support                           |
+| ---------------- | --------------------------------- |
+| Java 7           | ❌                                |
+| Java 8           | ✅                                |
+| Java 11          | ✅                                |
+| Java 12          | Not tested in CI, but should work |
+| Java 13          | Not tested in CI, but should work |
+| Java 14          | Not tested in CI, but should work |
+| Java 15          | ✅                                |
+| Java 16          | Not tested in CI, but should work |
+| Java 17          | Not tested in CI, but should work |
 
 | Build tool | Support |
 | ---------- | ------- |

build.sbt

@@ -91,6 +91,7 @@ lazy val plugin = project
   .in(file("semanticdb-javac"))
   .settings(
     moduleName := "semanticdb-javac",
+    javaToolchainVersion := "1.8",
     autoScalaLibrary := false,
     incOptions ~= { old =>
       old.withEnabled(false)
@@ -152,24 +153,39 @@ lazy val cli = project
   )
   .enablePlugins(NativeImagePlugin, BuildInfoPlugin)
 
+def minimizedSourceDirectory =
+  file("tests/minimized/src/main/java").getAbsoluteFile
+lazy val minimizedSettings = List[Def.Setting[_]](
+  autoScalaLibrary := false,
+  skip.in(publish) := true,
+  fork.in(run) := true,
+  unmanagedSourceDirectories.in(Compile) += minimizedSourceDirectory,
+  javacOptions.in(Compile) ++=
+    List[String](
+      s"-Arandomtimestamp=${System.nanoTime()}",
+      List(
+        s"-Xplugin:semanticdb",
+        s"-text:on",
+        s"-verbose",
+        s"-sourceroot:${baseDirectory.in(ThisBuild).value}",
+        s"-targetroot:${semanticdbTargetRoot.in(Compile).value}"
+      ).mkString(" ")
+    )
+)
+
 lazy val minimized = project
-  .in(file("tests/minimized"))
-  .settings(
-    autoScalaLibrary := false,
-    skip.in(publish) := true,
-    fork.in(run) := true,
-    javacOptions.in(Compile) ++=
-      List[String](
-        s"-Arandomtimestamp=${System.nanoTime()}",
-        List(
-          s"-Xplugin:semanticdb",
-          s"-text:on",
-          s"-verbose",
-          s"-sourceroot:${baseDirectory.in(ThisBuild).value}",
-          s"-targetroot:${semanticdbTargetRoot.in(Compile).value}"
-        ).mkString(" ")
-      )
-  )
+  .in(file("tests/minimized/.j11"))
+  .settings(minimizedSettings)
+  .dependsOn(agent, plugin)
+
+lazy val minimized8 = project
+  .in(file("tests/minimized/.j8"))
+  .settings(minimizedSettings, javaToolchainVersion := "8")
+  .dependsOn(agent, plugin)
+
+lazy val minimized15 = project
+  .in(file("tests/minimized/.j15"))
+  .settings(minimizedSettings, javaToolchainVersion := "15")
   .dependsOn(agent, plugin)
 
 lazy val minimizedScala = project
@@ -190,8 +206,7 @@ lazy val unit = project
         scalaVersion,
         "temporaryDirectory" -> target.value / "tmpdir",
         "sourceroot" -> baseDirectory.in(ThisBuild).value,
-        "minimizedJavaSourceDirectory" ->
-          sourceDirectory.in(minimized, Compile).value / "java",
+        "minimizedJavaSourceDirectory" -> minimizedSourceDirectory,
         "minimizedJavaTargetroot" ->
           semanticdbTargetRoot.in(minimized, Compile).value,
         "minimizedScalaSourceDirectory" ->

project/JavaToolchainPlugin.scala

@@ -0,0 +1,83 @@
+import sbt.{Compile, Def, File, _}
+import sbt.Keys._
+import sbt.plugins.JvmPlugin
+
+import java.nio.file.Paths
+import java.util
+import java.util.Collections
+import scala.util.Properties
+import scala.sys.process.Process
+
+/**
+ * An sbt plugin that automatically adds the Java compiler to the boot classpath
+ * when necessary.
+ */
+object JavaToolchainPlugin extends AutoPlugin {
+  override def trigger = allRequirements
+  override def requires = JvmPlugin
+
+  object autoImport {
+    lazy val javaToolchainVersion = settingKey[String](
+      "The version of the Java"
+    )
+  }
+  import autoImport._
+
+  lazy val configSettings = List(
+    javacOptions ++=
+      List(
+        "-target",
+        "1.8",
+        "-source",
+        "1.8",
+        "-bootclasspath",
+        java8Bootclasspath()
+      ),
+    javacOptions.in(doc) --= List("-target", "1.8"),
+    javacOptions.in(doc) --= bootclasspathSettings(javaToolchainVersion.value),
+    javaHome := Some(getJavaHome(javaToolchainVersion.value)),
+    javacOptions ++= bootclasspathSettings(javaToolchainVersion.value),
+    javaOptions ++= bootclasspathSettings(javaToolchainVersion.value)
+  )
+
+  override lazy val projectSettings: Seq[Def.Setting[_]] =
+    List(Compile, Test).flatMap(c => inConfig(c)(configSettings)) ++
+      List(fork := true, javaToolchainVersion := "11")
+
+  /**
+   * For Java 8, we need to manually add the Java compiler to the boot
+   * classpath.
+   *
+   * Newer Java versions include the compiler by default.
+   */
+  private def bootclasspathSettings(version: String): List[String] = {
+    val home = getJavaHome(version)
+    val toolsJar: File = home / "lib" / "tools.jar"
+    // The tools.jar file includes the bytecode for the Java compiler in the com.sun.source package.
+    // The Java compiler is available by default in Java 9+, so we only need to add tools.jar to the
+    // bootclasspath for Java 8.
+    if (home.toString.contains("1.8") && toolsJar.isFile) {
+      List(s"-Xbootclasspath/p:$toolsJar")
+    } else {
+      List()
+    }
+  }
+
+  private def java8Bootclasspath(): String = {
+    (getJavaHome("8") / "jre" / "lib" / "rt.jar").toString
+  }
+
+  private val javaHomeCache: util.Map[String, File] = Collections
+    .synchronizedMap(new util.HashMap[String, File]())
+  private def getJavaHome(version: String): File = {
+    javaHomeCache.computeIfAbsent(
+      version,
+      (v: String) => {
+        val coursier = Paths.get("bin", "coursier")
+        new File(
+          Process(List(coursier.toString, "java-home", "--jvm", v)).!!.trim
+        )
+      }
+    )
+  }
+}

project/JavacBootClasspathPlugin.scala

@@ -44,8 +44,7 @@ private String uncachedSemanticdbSymbol(Symbol sym, LocalSymbolsCache locals) {
     }
     SemanticdbSymbols.Descriptor desc = semanticdbDescriptor(sym);
     if (options.verboseEnabled && desc.kind == SemanticdbSymbols.Descriptor.Kind.None) {
-      pprint(sym.name.toString());
-      pprint(sym.kind);
+      pprint(sym.getQualifiedName().toString());
       pprint(
           String.format(
               "sym: %s (%s - superclass %s)", sym, sym.getClass(), sym.getClass().getSuperclass()));