Apply test reachability metadata to dedicated layers

Author: Zeavee

docs/tck.md

@@ -104,12 +104,17 @@ test classes. The application invocation uses the coordinate's real unique-ID
 files to discover and register those classes. The written test code therefore
 remains exclusively in the final application layer.
 The base build uses the same resolved Native Image configuration directories as
-the final test image, including JUnit metadata and generated test resources, so
-`typeReached` and class-initialization state remain stable across the layer
-boundary. Gradle tracks the coordinate, Native Image version and arguments,
-configuration files, and complete base-analysis classpath, rebuilding the layer
-when an input changes. The final test image retains the complete
-standalone test runtime classpath while using the coordinate-specific layer.
+the final test image. For both builds, it stages test-scoped
+`reachability-metadata.json` without conditions because LayerCreate does not
+preserve runtime `typeReached` tracking for selected JAR types. The normal test
+lane still validates the original conditions; the dedicated lane applies the
+same metadata unconditionally in both analyses to keep class-initialization
+policy stable without including test classes or unrelated test resources in the
+base layer.
+Gradle rebuilds the layer when its coordinate, Native Image settings,
+configuration, or base-analysis classpath changes. The final test image retains
+the complete standalone test runtime classpath while using the
+coordinate-specific layer.
 CI supplies `-Ptck.layered.deleteDedicatedLayerAfterTest=true` to delete each
 large coordinate layer after its test; local runs retain layers for reuse unless
 they explicitly request the same cleanup behavior.

tests/tck-build-logic/src/main/groovy/org.graalvm.internal.tck.gradle

@@ -4,6 +4,7 @@
  * You should have received a copy of the CC0 legalcode along with this
  * work. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
  */
+import groovy.json.JsonOutput
 import groovy.json.JsonSlurper
 import org.graalvm.internal.tck.utils.DynamicAccessUtils
 import org.graalvm.internal.tck.utils.BaseLayerUtils
@@ -398,6 +399,17 @@ Provider<Directory> dedicatedLayerJUnitTestListDirectory = layout.buildDirectory
         "native/generated/dedicatedLayerJUnitTestList")
 Provider<Directory> dedicatedLayerConfigurationDirectory = layout.buildDirectory.dir(
         "native/generated/dedicatedLayerConfiguration")
+Provider<Directory> dedicatedLayerReachabilityMetadataDirectory = layout.buildDirectory.dir(
+        "native/generated/dedicatedLayerReachabilityMetadata")
+
+if (dedicatedLayer) {
+    tasks.named("processTestResources").configure { task ->
+        task.exclude("META-INF/native-image/**/reachability-metadata.json")
+    }
+    tasks.named("generateTestResourcesConfigFile").configure { task ->
+        task.dependsOn(tasks.named("processTestResources"))
+    }
+}
 
 tasks.register("generateDedicatedLayerJUnitTestList") { task ->
     task.setDescription("Generates engine-root JUnit selectors for the dedicated layer")
@@ -419,10 +431,70 @@ tasks.register("generateDedicatedLayerJUnitTestList") { task ->
     }
 }
 
+Closure<List<File>> resolveTestReachabilityMetadataFiles = {
+    return sourceSets.test.resources.srcDirs.collectMany { File resourceDirectory ->
+        fileTree(resourceDirectory) {
+            include("META-INF/native-image/**/reachability-metadata.json")
+        }.files
+    }.unique().sort { File file -> file.absolutePath }
+}
+
+tasks.register("prepareDedicatedLayerReachabilityMetadata") { task ->
+    task.setDescription("Prepares test-scoped reachability metadata for dedicated-layer builds")
+    task.setGroup("build")
+    task.inputs.files(providers.provider { resolveTestReachabilityMetadataFiles() })
+            .withPropertyName("testReachabilityMetadata")
+            .withPathSensitivity(PathSensitivity.RELATIVE)
+    task.outputs.dir(dedicatedLayerReachabilityMetadataDirectory)
+    task.doLast {
+        File outputDirectory = dedicatedLayerReachabilityMetadataDirectory.get().asFile
+        delete(outputDirectory)
+        if (!outputDirectory.mkdirs()) {
+            throw new GradleException("Failed to create dedicated-layer reachability metadata directory: " +
+                    outputDirectory.absolutePath)
+        }
+        resolveTestReachabilityMetadataFiles().eachWithIndex { File metadataFile, int index ->
+            File metadataDirectory = new File(outputDirectory, "entry-${index}")
+            if (!metadataDirectory.mkdirs()) {
+                throw new GradleException("Failed to create dedicated-layer metadata entry: " +
+                        metadataDirectory.absolutePath)
+            }
+            Closure<Object> withoutConditions
+            withoutConditions = { Object value ->
+                if (value instanceof Map) {
+                    Map<String, Object> result = new LinkedHashMap<>()
+                    value.each { Object key, Object nestedValue ->
+                        if (key != "condition") {
+                            result.put(key.toString(), withoutConditions(nestedValue))
+                        }
+                    }
+                    return result
+                }
+                if (value instanceof List) {
+                    return value.collect { Object nestedValue -> withoutConditions(nestedValue) }
+                }
+                return value
+            }
+            Object metadata = new JsonSlurper().parse(metadataFile)
+            String json = JsonOutput.prettyPrint(JsonOutput.toJson(withoutConditions(metadata)))
+            new File(metadataDirectory, "reachability-metadata.json").text =
+                    json + System.lineSeparator()
+        }
+    }
+}
+
+Closure<List<File>> resolveDedicatedLayerReachabilityMetadataDirectories = {
+    File outputDirectory = dedicatedLayerReachabilityMetadataDirectory.get().asFile
+    return resolveTestReachabilityMetadataFiles().indices.collect { int index ->
+        new File(outputDirectory, "entry-${index}")
+    }
+}
+
 Closure<List<File>> resolveNativeTestConfigurationDirectories = {
     Set<File> directories = new LinkedHashSet<>(nativeTestCompileTask.get()
             .options.get().configurationFileDirectories.files)
     directories.add(coordinateMetadataDirectory)
+    directories.addAll(resolveDedicatedLayerReachabilityMetadataDirectories())
     return directories.findAll { File directory -> directory.isDirectory() }
             .toList()
             .sort { File directory -> directory.absolutePath }
@@ -432,6 +504,10 @@ tasks.register("prepareDedicatedLayerConfiguration") { task ->
     task.setDescription("Prepares Native Image configuration for the dedicated layer")
     task.setGroup("build")
     task.dependsOn(tasks.named("generateTestResourcesConfigFile"))
+    task.dependsOn(tasks.named("prepareDedicatedLayerReachabilityMetadata"))
+    task.inputs.dir(dedicatedLayerReachabilityMetadataDirectory)
+            .withPropertyName("dedicatedLayerReachabilityMetadata")
+            .withPathSensitivity(PathSensitivity.RELATIVE)
     task.outputs.dir(dedicatedLayerConfigurationDirectory)
     task.outputs.upToDateWhen { false }
     task.doLast {
@@ -812,6 +888,13 @@ graalvmNative {
             buildArgs.addAll(nativeTraceBuildArgs)
             if (dedicatedLayer) {
                 buildArgs.add(coordinateMetadataArgument)
+                buildArgs.addAll(providers.provider {
+                    List<File> metadataDirectories = resolveDedicatedLayerReachabilityMetadataDirectories()
+                    return metadataDirectories.isEmpty() ? [] : [
+                            "-H:ConfigurationFileDirectories=" +
+                                    metadataDirectories.collect { File file -> file.absolutePath }.join(",")
+                    ]
+                })
             }
             if (layeredNativeImage && !dedicatedLayer) {
                 buildArgs.addAll([