Enhance NeoForgedRepositoryFilter: ensure dynamic module discovery clears stale state and applies content filter consistently

Author: Gu-ZT

src/main/java/net/neoforged/moddevgradle/internal/ModDevPlugin.java

@@ -16,6 +16,7 @@
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.ModuleDependency;
 import org.gradle.api.plugins.JavaLibraryPlugin;
+import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -87,9 +88,10 @@ public void enable(
                 versionCapabilities)
                 : ModdingDependencies.createVanillaOnly(neoForm, neoFormNotation);
 
-        if (neoForgeVersion != null) {
-            populateNeoForgeRepositoryFilter(project, neoForgeVersion);
-        }
+        // Always apply at least the stable baseline filter to the NeoForged
+        // repository. When a NeoForge version is selected we also discover
+        // additional game-library modules from its metadata.
+        populateNeoForgeRepositoryFilter(project, neoForgeVersion);
 
         ArtifactNamingStrategy artifactNamingStrategy;
         // It's helpful to be able to differentiate the Vanilla jar and the NeoForge jar in classic multiloader setups.
@@ -129,28 +131,29 @@ public void enable(
      * The HTTP download bypasses Gradle's dependency resolution so the repository content
      * descriptor stays unlocked and can receive its first {@code content()} call.
      */
-    private static void populateNeoForgeRepositoryFilter(Project project, String neoForgeVersion) {
-        // Regex to extract group:module pairs from Gradle Module Metadata JSON.
-        var depPattern = Pattern.compile("\"group\":\\s*\"([^\"]+)\",\\s*\"module\":\\s*\"([^\"]+)\"");
-
-        // 1. Discover game library modules from the NeoForge artifact metadata.
-        fetchModuleDependencies("net/neoforged/neoforge/" + neoForgeVersion
-                + "/neoforge-" + neoForgeVersion + ".module", depPattern);
-
-        // 2. Discover build tool modules from the NeoForm Runtime metadata.
-        //    NFRT ships external tools (DiffPatch, AutoRenamingTool, etc.) whose
-        //    transitive dependencies are also rehosted on the NeoForged Maven.
-        var nfrtVersion = NeoFormRuntimeExtension.getVersion(project);
-        fetchModuleDependencies("net/neoforged/neoform-runtime/" + nfrtVersion
-                + "/neoform-runtime-" + nfrtVersion + ".module", depPattern);
-
-        // Apply the content filter now — before any dependency resolution uses the
-        // NeoForge repository.
-        try {
-            RepositoriesPlugin.applyContentFilter(project);
-        } catch (Exception e) {
-            LOG.warn("Failed to apply NeoForge repository content filter: {}", e.getMessage());
+    private static void populateNeoForgeRepositoryFilter(Project project,
+            @Nullable String neoForgeVersion) {
+        // Clear any stale dynamic modules from a previous build in this daemon.
+        NeoForgedRepositoryFilter.clearGameLibraries();
+
+        if (neoForgeVersion != null) {
+            var depPattern = Pattern.compile("\"group\":\\s*\"([^\"]+)\",\\s*\"module\":\\s*\"([^\"]+)\"");
+
+            // Discover game library modules from the NeoForge artifact metadata.
+            fetchModuleDependencies("net/neoforged/neoforge/" + neoForgeVersion
+                    + "/neoforge-" + neoForgeVersion + ".module", depPattern);
+
+            // Discover build tool modules from the NeoForm Runtime metadata.
+            var nfrtVersion = NeoFormRuntimeExtension.getVersion(project);
+            fetchModuleDependencies("net/neoforged/neoform-runtime/" + nfrtVersion
+                    + "/neoform-runtime-" + nfrtVersion + ".module", depPattern);
         }
+
+        // Apply the content filter now — before any dependency resolution uses
+        // the NeoForge repository. In the vanilla-only case this installs the
+        // stable baseline; when a NeoForge version is selected it also includes
+        // any dynamically discovered modules.
+        RepositoriesPlugin.applyContentFilter(project);
     }
 
     private static void fetchModuleDependencies(String path, Pattern depPattern) {

src/main/java/net/neoforged/moddevgradle/internal/NeoForgedRepositoryFilter.java

@@ -224,6 +224,16 @@ public static void addGameLibrary(String group, String module) {
         gameLibraryModules.add(group + ":" + module);
     }
 
+    /**
+     * Clears all dynamically discovered modules. Called at the start of
+     * {@code populateNeoForgeRepositoryFilter} so that each build computes its
+     * own allowed-module set deterministically, avoiding cross-build leakage
+     * when the Gradle daemon persists static state.
+     */
+    static void clearGameLibraries() {
+        gameLibraryModules.clear();
+    }
+
     /**
      * Applies the full filter: stable known modules plus any dynamically discovered
      * game library modules for the selected NeoForge version.

src/main/java/net/neoforged/moddevgradle/internal/RepositoriesPlugin.java

@@ -10,6 +10,7 @@
 import org.gradle.api.initialization.Settings;
 import org.gradle.api.invocation.Gradle;
 import org.gradle.api.plugins.PluginAware;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * This plugin acts in different roles depending on where it is applied:
@@ -45,10 +46,13 @@ public void apply(PluginAware target) {
     }
 
     /**
-     * Returns the NeoForge repository. Exposed for dynamic filter population.
+     * Returns the NeoForge repository, or {@code null} when the repository was
+     * configured at the settings level and this project has no local reference.
      */
+    @Nullable
     static MavenArtifactRepository getNeoForgeRepository(Project project) {
-        return (MavenArtifactRepository) project.getExtensions().getByName(NEOFORGE_REPO_EXTENSION);
+        var ext = project.getExtensions().findByName(NEOFORGE_REPO_EXTENSION);
+        return (MavenArtifactRepository) ext;
     }
 
     /**
@@ -58,10 +62,15 @@ static MavenArtifactRepository getNeoForgeRepository(Project project) {
      * <p>
      * Must be called before any dependency resolution uses this repository —
      * Gradle locks the content descriptor on first use.
+     * <p>
+     * When the repository was configured at the settings level this is a safe
+     * no-op — the content filter is already installed from {@code apply()}.
      */
     static void applyContentFilter(Project project) {
         var neoRepo = getNeoForgeRepository(project);
-        neoRepo.content(NeoForgedRepositoryFilter::filter);
+        if (neoRepo != null) {
+            neoRepo.content(NeoForgedRepositoryFilter::filter);
+        }
     }
 
     private static MavenArtifactRepository applyRepositories(RepositoryHandler repositories, boolean applyContentFilter) {

src/test/java/net/neoforged/moddevgradle/internal/ModDevPluginTest.java

@@ -174,6 +174,68 @@ private void assertContainsModdingCompileDependencies(String version, String con
                         "net.neoforged:neoforge:" + version + "[net.neoforged:neoforge-dependencies]");
     }
 
+    @Nested
+    class RepositoryFilter {
+        @Test
+        void testContentFilterAppliedWhenNeoForgeVersionIsSet() {
+            extension.setVersion("21.10.48-beta");
+
+            var neoRepo = RepositoriesPlugin.getNeoForgeRepository(project);
+            assertThat(neoRepo).isNotNull();
+            // The content filter should be installed on the NeoForge repository.
+            // We cannot inspect the filter rules directly through public API, but we
+            // can verify the repository exists and is accessible.
+            assertThat(project.getRepositories().stream()
+                    .filter(r -> "NeoForged Releases".equals(r.getName()))
+                    .findFirst()).isPresent();
+        }
+
+        @Test
+        void testContentFilterAppliedInVanillaOnlyMode() {
+            extension.setNeoFormVersion("1.21.4-20240101.235959");
+
+            var neoRepo = RepositoriesPlugin.getNeoForgeRepository(project);
+            assertThat(neoRepo).isNotNull();
+            // The stable baseline filter must be installed even when no NeoForge
+            // version is selected, otherwise the NeoForged Maven (which mirrors
+            // Maven Central) would be unfiltered.
+            assertThat(project.getRepositories().stream()
+                    .filter(r -> "NeoForged Releases".equals(r.getName()))
+                    .findFirst()).isPresent();
+        }
+
+        @Test
+        void testApplyContentFilterIsNoOpWhenRepositoryNotOnProject() {
+            // Create a fresh project without ModDevPlugin — the NeoForge repository
+            // extension is never registered, so applyContentFilter must not throw.
+            var freshProject = ProjectBuilder.builder().build();
+            // Must not throw, even though there is no NeoForge repository extension.
+            RepositoriesPlugin.applyContentFilter(freshProject);
+        }
+
+        @Test
+        void testDynamicModuleDiscoveryClearsStaleState() {
+            // Simulate a first enable — should populate dynamic modules.
+            extension.setVersion("21.10.48-beta");
+
+            // Run a second enable on a fresh project with a different version.
+            // The dynamic set must be cleared first so the previous version's
+            // modules do not leak.
+            var project2 = ProjectBuilder.builder().build();
+            project2.getPlugins().apply(ModDevPlugin.class);
+            var ext2 = ExtensionUtils.getExtension(project2, "neoForge", NeoForgeExtension.class);
+            var java2 = ExtensionUtils.getExtension(project2, "java", JavaPluginExtension.class);
+            java2.getToolchain().getLanguageVersion().set(JavaLanguageVersion.current());
+
+            // If state leaked, this would carry modules from "21.10.48-beta".
+            // The filter should still be applied successfully.
+            ext2.setVersion("21.0.133-beta");
+
+            var neoRepo = RepositoriesPlugin.getNeoForgeRepository(project2);
+            assertThat(neoRepo).isNotNull();
+        }
+    }
+
     private void assertContainsModdingRuntimeDependencies(String version, String configurationName) {
         var configuration = project.getConfigurations().getByName(configurationName);