Layers DSL follow-up: configuration-cache and test cleanup (#1034)

* Fix layer DSL configuration-cache isolation

* Make layered test fixture edits line-ending independent

* Make Maven layer configuration descriptor optional

* Link layer regression tests to issues

Author: jvukicev

native-gradle-plugin/docs/e2e.md

@@ -95,6 +95,8 @@ or Native Image invocation, add or update a functional test in the closest scena
 Configuration-cache functional tests validate that Gradle-specific task and provider wiring works
 with Gradle's configuration-cache model. They protect [§REQ-gradle-model](requirements.md#req-gradle-model-the-gradle-plugin-preserves-gradle-model-compatibility)
 and the architecture boundaries in [§AR-gradle-plugin.2](architecture.md#2-extension-and-option-model) and [§AR-gradle-plugin.3](architecture.md#3-task-graph-architecture).
+They cover both named-layer consumers and ordinary native tasks with no declared layers so the
+layer DSL cannot leak project model objects into otherwise unrelated task state. [§FS-plugin-model.2](functional/plugin-model.md#2-extension-surface).
 
 Run the configuration-cache suite with the task exposed by the Gradle functional-testing
 convention, or let CI run the generated matrix from [§root/AR-repository-ci.1.3](../../docs/spec/architecture/ci.md#13-gradle-plugin-pr-workflow).

native-gradle-plugin/docs/functional/plugin-model.md

@@ -69,7 +69,9 @@ name to the same selection set. A consuming binary may select each logical name
 plugin resolves provider-backed names lazily and fails duplicate-name validation before any
 selected producer task executes. This layer model must not introduce avoidable project or task
 container serialization; general configuration-cache compatibility remains governed by the
-plugin's existing configuration-cache baseline.
+plugin's existing configuration-cache baseline. Binaries that select no named layers retain no
+reference to the layer container, its callbacks, or the project model; selected layers reach tasks
+only through normalized names, output-file providers, and file collections.
 
 `fromConfiguration(...)` and `all` include resolved external and project dependencies. Dependency
 selectors also accept Gradle providers, including version-catalog accessors.

native-gradle-plugin/src/functionalTest/groovy/org/graalvm/buildtools/gradle/LayeredApplicationFunctionalTest.groovy

@@ -46,6 +46,7 @@ import org.graalvm.buildtools.gradle.fixtures.GraalVMSupport
 import org.graalvm.buildtools.utils.NativeImageUtils
 import spock.lang.Ignore
 import spock.lang.IgnoreIf
+import spock.lang.Issue
 import spock.lang.Requires
 import spock.util.concurrent.PollingConditions
 
@@ -77,6 +78,47 @@ class LayeredApplicationFunctionalTest extends AbstractFunctionalTest {
         outputContains "Builds the dependencies Native Image layer."
     }
 
+    @Issue("https://github.com/graalvm/native-build-tools/issues/1027")
+    def "native tasks without layers reuse the configuration cache"() {
+        given:
+        withSample("java-application")
+        buildFile << '''
+            // Keep the compile task in the graph without invoking Native Image. §FS-plugin-model.2.
+            tasks.named("nativeCompile") {
+                enabled = false
+            }
+        '''.stripIndent()
+
+        when:
+        runAndReloadConfigurationCache 'nativeCompile', 'generateResourcesConfigFile'
+        if (hasConfigurationCache) {
+            // TestKit creates its exploded plugin classpath during the first pair of builds.
+            // Run once more after that input stabilizes to verify an actual cache reuse.
+            runAndReloadConfigurationCache 'nativeCompile', 'generateResourcesConfigFile'
+        }
+
+        then:
+        if (hasConfigurationCache) {
+            configurationCacheStoreTasks {
+                upToDate ':generateResourcesConfigFile'
+                skipped ':nativeCompile'
+                doesNotContain ':nativeDependenciesLayer'
+            }
+            tasks {
+                upToDate ':generateResourcesConfigFile'
+                skipped ':nativeCompile'
+                doesNotContain ':nativeDependenciesLayer'
+            }
+            outputContains 'Reusing configuration cache.'
+        } else {
+            tasks {
+                succeeded ':generateResourcesConfigFile'
+                skipped ':nativeCompile'
+                doesNotContain ':nativeDependenciesLayer'
+            }
+        }
+    }
+
     def "rejects an empty named layer before invoking Native Image"() {
         given:
         withSample("layered-java-application")
@@ -91,11 +133,13 @@ class LayeredApplicationFunctionalTest extends AbstractFunctionalTest {
         errorOutputContains "Layer 'empty' has no contents"
     }
 
+    @Issue("https://github.com/graalvm/native-build-tools/issues/1033")
     def "rejects duplicate provider layer selections before the producer runs"() {
         given:
         withSample("layered-java-application")
+        buildFile.text = buildFile.text.replace('\r\n', '\n').replace('\n', '\r\n')
         // Replace the sample's happy-path consumer so this test isolates direct/provider duplicates. §FS-plugin-model.2.
-        buildFile.text = buildFile.text.replace('''        main {
+        replaceBuildFile('''        main {
             usesLayer('dependencies')
         }
 ''', '''        main {
@@ -270,7 +314,7 @@ public class Application {
                 implementation("org.slf4j:slf4j-api:2.0.17")
             }
         '''.stripIndent()
-        buildFile.text = buildFile.text.replace('''                modules("java.base")
+        replaceBuildFile('''                modules("java.base")
 ''', '''                packages("org.slf4j")
 ''')
         buildFile << '''
@@ -300,7 +344,7 @@ public class Application {
 
         given:
         withSample("layered-java-application")
-        buildFile.text = buildFile.text.replace('''                modules("java.base")
+        replaceBuildFile('''                modules("java.base")
 ''', '''                all = true
 ''')
         buildFile << '''
@@ -334,7 +378,7 @@ public class Application {
                 implementation("org.apache.commons:commons-lang3:3.17.0")
             }
         '''.stripIndent()
-        buildFile.text = buildFile.text.replace('''                modules("java.base")
+        replaceBuildFile('''                modules("java.base")
 ''', '''                modules("java.base")
                 from(configurations.runtimeClasspath)
 ''')
@@ -585,4 +629,10 @@ public class Application {
             }
         }
     }
+
+    private void replaceBuildFile(String expected, String replacement) {
+        String normalized = buildFile.text.replace('\r\n', '\n')
+        assert normalized.contains(expected): "Expected layered application fixture text was not found:\n${expected}"
+        buildFile.text = normalized.replace(expected, replacement)
+    }
 }

native-gradle-plugin/src/main/java/org/graalvm/buildtools/gradle/NativeImagePlugin.java

@@ -57,6 +57,7 @@
 import org.graalvm.buildtools.gradle.internal.GraalVMReachabilityMetadataService;
 import org.graalvm.buildtools.gradle.internal.GradleUtils;
 import org.graalvm.buildtools.gradle.internal.NativeImageExecutableLocator;
+import org.graalvm.buildtools.gradle.internal.NativeImageLayerRegistry;
 import org.graalvm.buildtools.gradle.internal.agent.AgentConfigurationFactory;
 import org.graalvm.buildtools.gradle.tasks.BuildNativeImageTask;
 import org.graalvm.buildtools.gradle.tasks.CollectReachabilityMetadata;
@@ -200,6 +201,7 @@ public class NativeImagePlugin implements Plugin<Project> {
     private static final String NATIVE_IMAGE_OPTIONS_ENV = "NATIVE_IMAGE_OPTIONS";
 
     private GraalVMLogger logger;
+    private transient NativeImageLayerRegistry layerRegistry;
 
     // Exposed detection provider for test binaries (to be used by follow-up tasks)
     private Provider<Boolean> compatModeEnabled;
@@ -580,7 +582,7 @@ private void configureLayerTasks(Project project,
                 project.getObjects(),
                 project.getProviders(),
                 project.getExtensions().findByType(JavaToolchainService.class),
-                graalExtension.getLayers(),
+                layerRegistry,
                 "lib" + layer.getName()
             );
             CreateLayerOptions create = project.getObjects().newInstance(CreateLayerOptions.class);
@@ -910,10 +912,14 @@ private static boolean isJar(FileSystemLocation location) {
     }
 
     private GraalVMExtension registerGraalVMExtension(Project project) {
+        layerRegistry = new NativeImageLayerRegistry(project.getObjects());
         NamedDomainObjectContainer<NativeImageLayer> layers = project.getObjects()
             .domainObjectContainer(NativeImageLayer.class, name -> {
                 NativeImageLayerArguments.validateLayerName(name);
-                return project.getObjects().newInstance(NativeImageLayer.class, name, project.getObjects(), project);
+                NativeImageLayer layer = project.getObjects().newInstance(
+                    NativeImageLayer.class, name, project.getObjects(), project, layerRegistry);
+                layerRegistry.register(layer);
+                return layer;
             });
         NamedDomainObjectContainer<NativeImageOptions> nativeImages = project.getObjects()
             .domainObjectContainer(NativeImageOptions.class, name ->
@@ -922,7 +928,7 @@ private GraalVMExtension registerGraalVMExtension(Project project) {
                     project.getObjects(),
                     project.getProviders(),
                     project.getExtensions().findByType(JavaToolchainService.class),
-                    layers,
+                    layerRegistry,
                     project.getName())
             );
         GraalVMExtension graalvmNative = project.getExtensions().create(GraalVMExtension.class, "graalvmNative",

native-gradle-plugin/src/main/java/org/graalvm/buildtools/gradle/dsl/NativeImageLayer.java

@@ -48,10 +48,10 @@
 import org.gradle.api.model.ObjectFactory;
 import org.gradle.api.provider.ListProperty;
 import org.gradle.api.provider.Property;
-import org.gradle.api.provider.Provider;
 import org.gradle.api.tasks.Input;
 import org.gradle.api.tasks.Internal;
 import org.gradle.api.tasks.Nested;
+import org.graalvm.buildtools.gradle.internal.NativeImageLayerRegistry;
 import org.graalvm.buildtools.utils.NativeImageLayerArguments;
 
 import javax.inject.Inject;
@@ -64,17 +64,17 @@
 public abstract class NativeImageLayer implements Named {
     private final String name;
     private final LayerContents contents;
-    private final Project project;
+    private final transient NativeImageLayerRegistry layerRegistry;
     private final ConfigurableFileCollection layerFiles;
     private final ConfigurableFileCollection inheritedCompatibilityClasspath;
     private final ConfigurableFileCollection compatibilityClasspath;
     private final Set<String> configuredLayerNames = new HashSet<>();
 
     @Inject
-    public NativeImageLayer(String name, ObjectFactory objects, Project project) {
+    public NativeImageLayer(String name, ObjectFactory objects, Project project, NativeImageLayerRegistry layerRegistry) {
         this.name = name;
         this.contents = objects.newInstance(LayerContents.class, project);
-        this.project = project;
+        this.layerRegistry = layerRegistry;
         this.layerFiles = project.files();
         this.inheritedCompatibilityClasspath = project.files();
         this.compatibilityClasspath = project.files();
@@ -114,12 +114,9 @@ public void usesLayer(String name) {
             throw new IllegalArgumentException("Layer '" + name + "' is selected more than once");
         }
         getUseLayerNames().add(name);
-        Provider<NativeImageLayer> layer = project.provider(() -> project.getExtensions()
-            .getByType(GraalVMExtension.class)
-            .getLayers()
-            .getByName(name));
-        layerFiles.from(layer.flatMap(NativeImageLayer::getOutputFile));
-        inheritedCompatibilityClasspath.from(layer.map(NativeImageLayer::getCompatibilityClasspath));
+        NativeImageLayerRegistry.LayerReference reference = layerRegistry.reference(name);
+        layerFiles.from(reference.getOutputFile());
+        inheritedCompatibilityClasspath.from(reference.getCompatibilityClasspath());
     }
 
     @Internal

native-gradle-plugin/src/main/java/org/graalvm/buildtools/gradle/internal/BaseNativeImageOptions.java

@@ -53,7 +53,6 @@
 import org.graalvm.buildtools.utils.NativeImageLayerArguments;
 import org.gradle.api.Action;
 import org.gradle.api.DomainObjectSet;
-import org.gradle.api.NamedDomainObjectContainer;
 import org.gradle.api.file.ConfigurableFileCollection;
 import org.gradle.api.file.DirectoryProperty;
 import org.gradle.api.file.ProjectLayout;
@@ -94,13 +93,13 @@ public abstract class BaseNativeImageOptions implements NativeImageOptions {
     private static final GraalVMLogger LOGGER = GraalVMLogger.of(Logging.getLogger(BaseNativeImageOptions.class));
     private final DomainObjectSet<LayerOptions> layers;
     private final ConfigurableFileCollection layerCompatibilityClasspath;
-    private NativeImageLayer assignedLayer;
+    private transient NativeImageLayer assignedLayer;
 
     private final String name;
     private final transient TaskContainer tasks;
     private final ObjectFactory objects;
     private final ProviderFactory providers;
-    private final NamedDomainObjectContainer<NativeImageLayer> namedLayers;
+    private final transient NativeImageLayerRegistry layerRegistry;
 
     @Override
     @Internal
@@ -267,7 +266,7 @@ public BaseNativeImageOptions(String name,
                                   ProviderFactory providers,
                                   JavaToolchainService toolchains,
                                   TaskContainer tasks,
-                                  NamedDomainObjectContainer<NativeImageLayer> namedLayers,
+                                  NativeImageLayerRegistry layerRegistry,
                                   String defaultImageName) {
         this.name = name;
         getDebug().convention(false);
@@ -295,7 +294,7 @@ public BaseNativeImageOptions(String name,
         this.tasks = tasks;
         this.objects = objectFactory;
         this.providers = providers;
-        this.namedLayers = namedLayers;
+        this.layerRegistry = layerRegistry;
     }
 
     private static Provider<Boolean> property(ProviderFactory providers, String name) {
@@ -458,8 +457,7 @@ public void useLayer(String name) {
     public void useLayer(NativeImageLayer layer) {
         // Typed layer consumption records the producing layer output on the binary. §FS-plugin-model.2.
         addLayerName(layer.getName());
-        getLayerFiles().from(layer.getOutputFile());
-        layerCompatibilityClasspath.from(layer.getCompatibilityClasspath());
+        addLayerReference(layerRegistry.reference(layer.getName()));
     }
 
     @Override
@@ -472,12 +470,10 @@ public void useLayer(Provider<? extends NativeImageLayer> layer) {
 
     @Override
     public void usesLayer(String name) {
-        // Resolve the container only when Gradle queries the binary, allowing layers to be declared later. §FS-plugin-model.2.
+        // Resolve normalized properties without retaining the layer container in task state. §FS-plugin-model.2.
         NativeImageLayerArguments.validateLayerName(name);
-        Provider<NativeImageLayer> layer = providers.provider(() -> namedLayers.getByName(name));
         addLayerName(name);
-        getLayerFiles().from(layer.flatMap(NativeImageLayer::getOutputFile));
-        layerCompatibilityClasspath.from(layer.map(NativeImageLayer::getCompatibilityClasspath));
+        addLayerReference(layerRegistry.reference(name));
     }
 
     @Override
@@ -490,8 +486,14 @@ public void setLayer(NativeImageLayer layer) {
         // Singular property assignment replaces any prior layer selection. §FS-plugin-model.2.
         assignedLayer = layer;
         getLayerNames().set(List.of(layer.getName()));
-        getLayerFiles().setFrom(layer.getOutputFile());
-        layerCompatibilityClasspath.setFrom(layer.getCompatibilityClasspath());
+        NativeImageLayerRegistry.LayerReference reference = layerRegistry.reference(layer.getName());
+        getLayerFiles().setFrom(reference.getOutputFile());
+        layerCompatibilityClasspath.setFrom(reference.getCompatibilityClasspath());
+    }
+
+    private void addLayerReference(NativeImageLayerRegistry.LayerReference reference) {
+        getLayerFiles().from(reference.getOutputFile());
+        layerCompatibilityClasspath.from(reference.getCompatibilityClasspath());
     }
 
     private void addLayerName(String layerName) {