Fix additive reachability metadata requires selection (#1018)

Author: jvukicev

common/docs/functional-spec.md

@@ -115,6 +115,15 @@ metadata directory using index data, module-to-config-version overrides, default
 exclusions. Queries must classify dependencies as supported, excluded, not-for-Native-Image, or
 missing so plugin diagnostics and reports do not duplicate repository rules.
 
+The artifacts submitted in one query form the eligible resolved dependency graph for single-level
+`requires` expansion. Every selected configuration retains the group and artifact identity of the
+module whose repository directory owns it. If a required module is present in the submitted graph,
+only that module's direct query selects its metadata, using its resolved version, exclusion, and
+module-to-config-version override. If it is absent, the requiring module may select it once from the
+required module's directory using the requiring module's resolved version and normal exact-version
+then latest/default fallback behavior. An indirect required selection counts as repository coverage
+for the requiring query, but it does not recursively expand the required module's own `requires`.
+
 ### 5.2 Plugin entry points and outputs
 
 Product-specific repository resolution entry points are specified by [§gradle/FS-resources-and-metadata.3](../../native-gradle-plugin/docs/functional/resources-and-metadata.md#3-reachability-metadata-collection)

common/graalvm-reachability-metadata/src/main/java/org/graalvm/reachability/internal/FileSystemRepository.java

@@ -47,15 +47,19 @@
 import org.graalvm.reachability.internal.index.artifacts.SingleModuleJsonVersionToConfigDirectoryIndex;
 import org.graalvm.reachability.internal.index.artifacts.VersionToConfigDirectoryIndex;
 import org.graalvm.reachability.internal.index.modules.FileSystemModuleToConfigDirectoryIndex;
+import org.graalvm.reachability.internal.index.modules.ModuleConfigurationDirectory;
 
 import java.nio.file.Path;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
-import java.util.stream.Collectors;
 
 /**
  * Queries an unpacked reachability metadata repository. §FS-common-libraries.5.
@@ -99,90 +103,109 @@ public static boolean isSupportedArchiveFormat(String path) {
     public Set<DirectoryConfiguration> findConfigurationsFor(Consumer<? super Query> queryBuilder) {
         DefaultQuery query = new DefaultQuery();
         queryBuilder.accept(query);
-        return query.getArtifacts()
-                .stream()
-                .flatMap(artifactQuery -> {
-                    String groupId = artifactQuery.getGroupId();
-                    String artifactId = artifactQuery.getArtifactId();
-                    String version = artifactQuery.getVersion();
-                    return moduleIndex.findConfigurationDirectories(groupId, artifactId)
-                            .stream()
-                            .map(dir -> {
-                                VersionToConfigDirectoryIndex index = artifactIndexes.computeIfAbsent(dir,
-                                        SingleModuleJsonVersionToConfigDirectoryIndex::new);
-                                if (artifactQuery.getForcedConfig().isPresent()) {
-                                    String configVersion = artifactQuery.getForcedConfig().get();
-                                    logger.log(groupId, artifactId, version, "Configuration is forced to version " + configVersion);
-                                    return index.findConfiguration(groupId, artifactId, configVersion);
-                                }
-                                Optional<DirectoryConfiguration> configuration = index.findConfiguration(groupId, artifactId, version);
-                                if (!configuration.isPresent() && artifactQuery.isUseLatestVersion()) {
-                                    logger.log(groupId, artifactId, version, "Configuration directory not found. Trying latest version.");
-                                    configuration = index.findLatestConfigurationFor(groupId, artifactId, version);
-                                    if (!configuration.isPresent()) {
-                                        logger.log(groupId, artifactId, version, "Latest version not found!");
-                                    }
-                                }
-                                Optional<DirectoryConfiguration> finalConfigurationDirectory = configuration;
-                                logger.log(groupId, artifactId, version, () -> {
-                                    if (finalConfigurationDirectory.isPresent()) {
-                                        Path path = finalConfigurationDirectory.get().getDirectory();
-                                        return "Configuration directory is " + rootDirectory.relativize(path);
-                                    }
-                                    return "missing.";
-                                });
-                                return configuration;
-                            })
-                            .filter(Optional::isPresent)
-                            .map(Optional::get);
-                })
-                .collect(Collectors.toSet());
+        List<DefaultArtifactQuery> artifacts = query.getArtifacts();
+        Set<String> directlyQueriedModules = directlyQueriedModules(artifacts);
+        Map<String, DirectoryConfiguration> configurations = new LinkedHashMap<>();
+        // Select the complete query as one graph so requires never preempts a direct module query. §FS-common-libraries.5.1.
+        for (DefaultArtifactQuery artifactQuery : artifacts) {
+            for (ModuleConfigurationDirectory candidate : moduleIndex.findConfigurationDirectories(
+                    artifactQuery.getGroupId(), artifactQuery.getArtifactId())) {
+                boolean direct = isSameModule(candidate, artifactQuery);
+                if (!direct && directlyQueriedModules.contains(moduleKey(candidate.getGroupId(), candidate.getArtifactId()))) {
+                    continue;
+                }
+                Optional<String> forcedConfig = direct ? artifactQuery.getForcedConfig() : Optional.empty();
+                selectConfiguration(candidate, artifactQuery.getVersion(), artifactQuery.isUseLatestVersion(), forcedConfig)
+                        .ifPresent(configuration -> configurations.putIfAbsent(configurationKey(configuration), configuration));
+            }
+        }
+        return Collections.unmodifiableSet(new LinkedHashSet<>(configurations.values()));
     }
 
     @Override
     public boolean isCoveredByRepository(Consumer<? super Query> queryBuilder) {
         DefaultQuery query = new DefaultQuery();
         queryBuilder.accept(query);
-        return query.getArtifacts()
-                .stream()
-                .anyMatch(artifactQuery -> {
-                    String groupId = artifactQuery.getGroupId();
-                    String artifactId = artifactQuery.getArtifactId();
-                    String version = artifactQuery.getVersion();
-                    return moduleIndex.findConfigurationDirectories(groupId, artifactId)
-                            .stream()
-                            .anyMatch(dir -> {
-                                VersionToConfigDirectoryIndex index = artifactIndexes.computeIfAbsent(dir, SingleModuleJsonVersionToConfigDirectoryIndex::new);
-                                Optional<DirectoryConfiguration> configuration;
-                                if (artifactQuery.getForcedConfig().isPresent()) {
-                                    String configVersion = artifactQuery.getForcedConfig().get();
-                                    logger.log(groupId, artifactId, version, "Configuration is forced to version " + configVersion);
-                                    configuration = index.findConfiguration(groupId, artifactId, configVersion);
-                                } else {
-                                    configuration = index.findConfiguration(groupId, artifactId, version);
-                                    if (!configuration.isPresent() && artifactQuery.isUseLatestVersion()) {
-                                        logger.log(groupId, artifactId, version,
-                                                "Configuration directory not found. Trying latest version.");
-                                        configuration = index.findLatestConfigurationFor(groupId, artifactId, version);
-                                        if (!configuration.isPresent()) {
-                                            logger.log(groupId, artifactId, version, "Latest version not found!");
-                                        }
-                                    }
-                                }
-                                if (configuration.isPresent()) {
-                                    Path path = configuration.get().getDirectory();
-                                    logger.log(groupId, artifactId, version,
-                                            "Configuration directory is " + rootDirectory.relativize(path));
-                                    return true;
-                                }
-                                if (index.isNotForNativeImage(groupId, artifactId, version)) {
-                                    logger.log(groupId, artifactId, version, "Artifact is marked as not for native-image.");
-                                    return true;
-                                }
-                                logger.log(groupId, artifactId, version, "missing.");
-                                return false;
-                            });
-                });
+        List<DefaultArtifactQuery> artifacts = query.getArtifacts();
+        Set<String> directlyQueriedModules = directlyQueriedModules(artifacts);
+        // Check the complete query as one graph so requires never preempts a direct module query. §FS-common-libraries.5.1.
+        for (DefaultArtifactQuery artifactQuery : artifacts) {
+            for (ModuleConfigurationDirectory candidate : moduleIndex.findConfigurationDirectories(
+                    artifactQuery.getGroupId(), artifactQuery.getArtifactId())) {
+                boolean direct = isSameModule(candidate, artifactQuery);
+                if (!direct && directlyQueriedModules.contains(moduleKey(candidate.getGroupId(), candidate.getArtifactId()))) {
+                    continue;
+                }
+                Optional<String> forcedConfig = direct ? artifactQuery.getForcedConfig() : Optional.empty();
+                if (isCovered(candidate, artifactQuery.getVersion(), artifactQuery.isUseLatestVersion(), forcedConfig)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private Optional<DirectoryConfiguration> selectConfiguration(ModuleConfigurationDirectory candidate,
+            String version, boolean useLatestVersion, Optional<String> forcedConfig) {
+        String groupId = candidate.getGroupId();
+        String artifactId = candidate.getArtifactId();
+        VersionToConfigDirectoryIndex index = artifactIndexes.computeIfAbsent(candidate.getDirectory(),
+                SingleModuleJsonVersionToConfigDirectoryIndex::new);
+        Optional<DirectoryConfiguration> configuration;
+        if (forcedConfig.isPresent()) {
+            String configVersion = forcedConfig.get();
+            logger.log(groupId, artifactId, version, "Configuration is forced to version " + configVersion);
+            configuration = index.findConfiguration(groupId, artifactId, configVersion);
+        } else {
+            configuration = index.findConfiguration(groupId, artifactId, version);
+            if (!configuration.isPresent() && useLatestVersion) {
+                logger.log(groupId, artifactId, version, "Configuration directory not found. Trying latest version.");
+                configuration = index.findLatestConfigurationFor(groupId, artifactId, version);
+                if (!configuration.isPresent()) {
+                    logger.log(groupId, artifactId, version, "Latest version not found!");
+                }
+            }
+        }
+        Optional<DirectoryConfiguration> result = configuration;
+        logger.log(groupId, artifactId, version, () -> result
+                .map(value -> "Configuration directory is " + rootDirectory.relativize(value.getDirectory()))
+                .orElse("missing."));
+        return configuration;
+    }
+
+    private boolean isCovered(ModuleConfigurationDirectory candidate, String version, boolean useLatestVersion,
+            Optional<String> forcedConfig) {
+        Optional<DirectoryConfiguration> configuration = selectConfiguration(candidate, version, useLatestVersion, forcedConfig);
+        if (configuration.isPresent()) {
+            return true;
+        }
+        VersionToConfigDirectoryIndex index = artifactIndexes.get(candidate.getDirectory());
+        if (index.isNotForNativeImage(candidate.getGroupId(), candidate.getArtifactId(), version)) {
+            logger.log(candidate.getGroupId(), candidate.getArtifactId(), version, "Artifact is marked as not for native-image.");
+            return true;
+        }
+        return false;
+    }
+
+    private static Set<String> directlyQueriedModules(List<DefaultArtifactQuery> artifacts) {
+        Set<String> modules = new LinkedHashSet<>();
+        for (DefaultArtifactQuery artifact : artifacts) {
+            modules.add(moduleKey(artifact.getGroupId(), artifact.getArtifactId()));
+        }
+        return modules;
+    }
+
+    private static boolean isSameModule(ModuleConfigurationDirectory candidate, DefaultArtifactQuery artifact) {
+        return candidate.getGroupId().equals(artifact.getGroupId()) && candidate.getArtifactId().equals(artifact.getArtifactId());
+    }
+
+    private static String moduleKey(String groupId, String artifactId) {
+        return groupId + ':' + artifactId;
+    }
+
+    private static String configurationKey(DirectoryConfiguration configuration) {
+        return moduleKey(configuration.getGroupId(), configuration.getArtifactId()) + ':' + configuration.getVersion()
+                + ':' + configuration.getDirectory().normalize() + ':' + configuration.isOverride();
     }
 
     public Path getRootDirectory() {

common/graalvm-reachability-metadata/src/main/java/org/graalvm/reachability/internal/index/modules/FileSystemModuleToConfigDirectoryIndex.java

@@ -55,6 +55,7 @@
  * Module-to-config index which:
  * - Resolves the primary module directory by conventional layout (groupId/artifactId),
  * - Reads requires from the inner metadata/group/artifact/index.json and adds their conventional directories.
+ * §FS-common-libraries.5.1.
  */
 public class FileSystemModuleToConfigDirectoryIndex implements ModuleToConfigDirectoryIndex {
     private final Path rootPath;
@@ -71,18 +72,18 @@ public FileSystemModuleToConfigDirectoryIndex(Path rootPath) {
      * - Only a single-level requires expansion is performed
      */
     @Override
-    public Set<Path> findConfigurationDirectories(String groupId, String artifactId) {
+    public Set<ModuleConfigurationDirectory> findConfigurationDirectories(String groupId, String artifactId) {
         Path base = rootPath.resolve(groupId + "/" + artifactId);
         if (!Files.isDirectory(base)) {
             return Collections.emptySet();
         }
 
         Path indexFile = base.resolve("index.json");
         if (Files.isRegularFile(indexFile)) {
-            Set<Path> result = new LinkedHashSet<>();
+            Set<ModuleConfigurationDirectory> result = new LinkedHashSet<>();
             // Always include the base directory so its index.json is parsed,
             // even if it doesn't contain configuration files itself.
-            result.add(base);
+            result.add(new ModuleConfigurationDirectory(groupId, artifactId, base));
             try {
                 String content = Files.readString(indexFile);
                 JSONArray entries = new JSONArray(content);
@@ -100,7 +101,7 @@ public Set<Path> findConfigurationDirectories(String groupId, String artifactId)
                             String reqArtifact = req.substring(sep + 1);
                             Path reqDir = rootPath.resolve(reqGroup + "/" + reqArtifact);
                             if (Files.isDirectory(reqDir)) {
-                                result.add(reqDir);
+                                result.add(new ModuleConfigurationDirectory(reqGroup, reqArtifact, reqDir));
                             }
                         }
                     }
@@ -111,6 +112,6 @@ public Set<Path> findConfigurationDirectories(String groupId, String artifactId)
             return result;
         }
 
-        return Collections.singleton(base);
+        return Collections.singleton(new ModuleConfigurationDirectory(groupId, artifactId, base));
     }
 }

common/graalvm-reachability-metadata/src/main/java/org/graalvm/reachability/internal/index/modules/ModuleConfigurationDirectory.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2026 Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package org.graalvm.reachability.internal.index.modules;
+
+import java.nio.file.Path;
+import java.util.Objects;
+
+/**
+ * A candidate metadata directory together with the module identity that owns it.
+ * §FS-common-libraries.5.1.
+ */
+public final class ModuleConfigurationDirectory {
+    private final String groupId;
+    private final String artifactId;
+    private final Path directory;
+
+    public ModuleConfigurationDirectory(String groupId, String artifactId, Path directory) {
+        this.groupId = groupId;
+        this.artifactId = artifactId;
+        this.directory = directory;
+    }
+
+    public String getGroupId() {
+        return groupId;
+    }
+
+    public String getArtifactId() {
+        return artifactId;
+    }
+
+    public Path getDirectory() {
+        return directory;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) {
+            return true;
+        }
+        if (!(other instanceof ModuleConfigurationDirectory)) {
+            return false;
+        }
+        ModuleConfigurationDirectory that = (ModuleConfigurationDirectory) other;
+        return groupId.equals(that.groupId) && artifactId.equals(that.artifactId) && directory.equals(that.directory);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(groupId, artifactId, directory);
+    }
+}