Build MR JAR and prepare compilation with Gradle toolchains

Author: uschindler

build.gradle

@@ -72,7 +72,7 @@ ext {
   }
 
   // Minimum Java version required to compile and run Lucene.
-  minJavaVersion = JavaVersion.VERSION_19
+  minJavaVersion = JavaVersion.VERSION_17
 
   // snapshot build marker used in scripts.
   snapshotBuild = version.contains("SNAPSHOT")

gradle/generation/local-settings.gradle

@@ -98,9 +98,6 @@ org.gradle.workers.max=${maxWorkers}
 # Maximum number of test JVMs forked per test task.
 tests.jvms=${testsJvms}
 
-# Disable auto JVM provisioning (we don't use toolchains yet but want no surprises).
-org.gradle.java.installations.auto-download=false
-
 # Set these to enable automatic JVM location discovery.
 org.gradle.java.installations.fromEnv=JDK11,JDK12,JDK13,JDK14,JDK15,JDK16,JDK17
 org.gradle.java.installations.paths=(custom paths)

gradle/java/javac.gradle

@@ -55,7 +55,7 @@ allprojects {
         "-Xlint:-path",
         "-Xlint:processing",
         "-Xlint:rawtypes",
-        "-Xlint:-removal",
+        "-Xlint:removal",
         "-Xlint:requires-automatic",
         "-Xlint:requires-transitive-automatic",
         "-Xlint:-serial",
@@ -66,18 +66,66 @@ allprojects {
         "-Xlint:try",
         "-Xlint:unchecked",
         "-Xlint:varargs",
-        "-Xlint:-preview",
+        "-Xlint:preview",
         "-Xdoclint:all/protected",
         "-Xdoclint:-missing",
         "-Xdoclint:-accessibility",
         "-proc:none",  // proc:none was added because of LOG4J2-1925 / JDK-8186647
-
-        "--enable-preview"
       ]
 
       if (propertyOrDefault("javac.failOnWarnings", true).toBoolean()) {
-        // disabled in this branch: options.compilerArgs += "-Werror"
+        options.compilerArgs += "-Werror"
+      }
+    }
+  }
+}
+
+configure(project(":lucene:core")) {
+  plugins.withType(JavaPlugin) {
+    sourceSets {
+      main19 {
+        java {
+          srcDirs = ['src/java19']
+        }
+      }
+    }
+
+    configurations {
+      // Inherit any dependencies from the main source set.
+      main19Implementation.extendsFrom implementation
+    }
+    
+    dependencies {
+      // We need the main classes to compile our Java 19 pieces.
+      main19Implementation sourceSets.main.output
+    }
+
+    tasks.named('compileMain19Java').configure {
+      /* This will work when JDK 19 comes out:
+    
+      // select EA build:
+      javaCompiler = javaToolchains.compilerFor {
+        languageVersion = JavaLanguageVersion.of(19)
+        vendor = JvmVendorSpec.ADOPTOPENJDK
+      }
+      
+      // undo alternative JDK support:
+      options.forkOptions.javaHome = null
+      */
+      
+      sourceCompatibility = 19
+      targetCompatibility = 19
+      options.compilerArgs += ["--release", 19 as String, "--enable-preview"]
+    }
+    
+    tasks.named('jar').configure {
+      into('META-INF/versions/19') {
+        from sourceSets.main19.output
       }
+
+      manifest.attributes(
+        'Multi-Release': 'true'
+      )
     }
   }
 }

gradle/validation/ecj-lint.gradle

@@ -34,7 +34,7 @@ allprojects {
     // Create a [sourceSetName]EcjLint task for each source set
     // with a non-empty java.srcDirs. These tasks are then
     // attached to project's "ecjLint" task.
-    def lintTasks = sourceSets.collect { sourceSet ->
+    def lintTasks = sourceSets.findAll { it.name != 'main19' }.collect { sourceSet ->
       def srcDirs = sourceSet.java.sourceDirectories
           .filter { dir -> dir.exists() }
 

gradle/validation/forbidden-apis.gradle

@@ -115,6 +115,10 @@ allprojects { prj ->
       inputs.dir(file(resources))
     }
 
+    tasks.matching { it.name == "forbiddenApisMain19" }.all {
+      enabled = false
+    }
+
     // We rely on resolved configurations to compute the relevant set of rule
     // files for forbiddenApis. Since we don't want to resolve these configurations until
     // the task is executed, we can't really use them as task inputs properly. This is a

lucene/core.tests/src/test/org/apache/lucene/core/tests/TestMMap.java

@@ -24,6 +24,9 @@ public class TestMMap extends LuceneTestCase {
   public void testUnmapSupported() {
     final Module module = MMapDirectory.class.getModule();
     Assert.assertTrue("Lucene Core is not loaded as module", module.isNamed());
+    Assert.assertTrue(
+        "Lucene Core can't read 'jdk.unsupported' module",
+        module.getLayer().findModule("jdk.unsupported").map(module::canRead).orElse(false));
 
     // check that MMapDirectory can unmap by running the autodetection logic:
     Assert.assertTrue(MMapDirectory.UNMAP_NOT_SUPPORTED_REASON, MMapDirectory.UNMAP_SUPPORTED);

lucene/core/src/java/module-info.java

@@ -22,6 +22,7 @@
 @SuppressWarnings("module") // the test framework is compiled after the core...
 module org.apache.lucene.core {
   requires java.logging;
+  requires static jdk.unsupported; // this is optional but without it MMapDirectory won't be enabled
   requires static jdk.management; // this is optional but explicit declaration is recommended
 
   exports org.apache.lucene.analysis;