Fix/multi project leaking

common/src/test/java/net/neoforged/gradle/common/util/ConfigurationUtilsTest.java

@@ -52,9 +52,9 @@
 
         when(compileClasspath.getExtendsFrom()).thenReturn(buildConfigurationSet(implementation));
 
-        final List<Configuration> result = ConfigurationUtils.findCompileOnlyConfigurationForSourceSet(project, implementation);
+        final List<Configuration> result = ConfigurationUtils.findCompileOnlyConfigurationForSourceSetReplacement(project, implementation);
 
         Assertions.assertEquals(buildConfigurationList(compileClasspath), result);
     }
 
     @Test
@@ -91,9 +91,9 @@
 
         when(runtimeClasspath.getExtendsFrom()).thenReturn(buildConfigurationSet(implementation));
 
-        final List<Configuration> result = ConfigurationUtils.findRuntimeOnlyConfigurationFromSourceSet(project, implementation);
+        final List<Configuration> result = ConfigurationUtils.findRuntimeOnlyConfigurationFromSourceSetReplacement(project, implementation);
 
         Assertions.assertEquals(buildConfigurationList(runtimeClasspath), result);
     }
 
     @Test

dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/util/ConfigurationUtils.groovy

@@ -63,13 +63,13 @@ class ConfigurationUtils {
     static List<Configuration> findReplacementConfigurations(final Project project, final Configuration configuration) {
         final Set<Configuration> resultContainer = new HashSet<>();
 
-        resultContainer.addAll(findCompileOnlyConfigurationForSourceSet(project, configuration))
-        resultContainer.addAll(findRuntimeOnlyConfigurationFromSourceSet(project, configuration))
+        resultContainer.addAll(findCompileOnlyConfigurationForSourceSetReplacement(project, configuration))
+        resultContainer.addAll(findRuntimeOnlyConfigurationFromSourceSetReplacement(project, configuration))
 
         return resultContainer.toList()
     }
 
-    static List<Configuration> findCompileOnlyConfigurationForSourceSet(final Project project, final Configuration configuration) {
+    static List<Configuration> findCompileOnlyConfigurationForSourceSetReplacement(final Project project, final Configuration configuration) {
         final SourceSetContainer sourceSetContainer = project.getExtensions().getByType(SourceSetContainer.class)
         final List<Configuration> targets = new ArrayList<>();
 
@@ -94,7 +94,7 @@ class ConfigurationUtils {
         return targets
     }
 
-    static List<Configuration> findRuntimeOnlyConfigurationFromSourceSet(final Project project, final Configuration configuration) {
+    static List<Configuration> findRuntimeOnlyConfigurationFromSourceSetReplacement(final Project project, final Configuration configuration) {
         final SourceSetContainer sourceSetContainer = project.getExtensions().getByType(SourceSetContainer.class)
         final List<Configuration> targets = new ArrayList<>();
 
@@ -112,7 +112,13 @@ class ConfigurationUtils {
 
             final Set<Configuration> supers = getAllSuperConfigurations(runtimeClasspath)
             if (supers.contains(runtimeOnly) && supers.contains(configuration)) {
-                targets.add(runtimeOnly)
+                //Runtime is a special bunny, we need to make our own configuration in this state to handle it.
+                //TODO: Once we add the conventions subsystem use its standardized approach.
+                final Configuration reallyRuntimeOnly = project.getConfigurations().maybeCreate(
+                    GradleInternalUtils.getSourceSetName(sourceSet, "runtimeNotPublished")
+                )
+                runtimeClasspath.extendsFrom(reallyRuntimeOnly)
+                targets.add(reallyRuntimeOnly)
             }
         }}
 

dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/util/GradleInternalUtils.groovy

@@ -0,0 +1,32 @@
+package net.neoforged.gradle.dsl.common.util
+
+import org.gradle.api.internal.tasks.DefaultSourceSet
+import org.gradle.api.tasks.SourceSet
+
+/**
+ * Internal utilities for Gradle used in the DSL
+ */
+class GradleInternalUtils {
+
+    private GradleInternalUtils() {
+        throw new IllegalStateException("Can not instantiate an instance of: GradleInternalUtils. This is a utility class")
+    }
+
+    /**
+     * Gets the name of the source set with the given post fix
+     *
+     * @param sourceSet The source set to get the name of
+     * @param postFix The post fix to append to the source set name
+     * @return The name of the source set with the post fix
+     */
+    static String getSourceSetName(SourceSet sourceSet, String postFix) {
+        if (sourceSet instanceof DefaultSourceSet) {
+            return ((DefaultSourceSet) sourceSet).configurationNameOf(postFix);
+        }
+
+        final String capitalized = postFix.capitalize()
+        final String name = sourceSet.getName() == SourceSet.MAIN_SOURCE_SET_NAME ? "" : sourceSet.getName().capitalize()
+
+        return (name + capitalized).uncapitalize()
+    }
+}

userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/ConfigurationTests.groovy

@@ -1,5 +1,6 @@
 package net.neoforged.gradle.userdev
 
+import net.neoforged.gradle.common.extensions.repository.IvyDummyRepositoryEntry
 import net.neoforged.trainingwheels.gradle.functional.BuilderBasedTestSpecification
 import net.neoforged.trainingwheels.gradle.functional.builder.Runtime
 import org.gradle.testkit.runner.TaskOutcome
@@ -60,4 +61,58 @@ No dependencies
 '''
         )
     }
+
+    def "a mod with userdev in the implementation configuration does not leak it via publishing"() {
+        given:
+        def project = create("userdev_in_implementation_does_not_leak_via_publishing", {
+            it.plugin('maven-publish')
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+            }
+
+            runs {
+                client {
+                    modSources.add(project.getSourceSets().main)
+                }
+            }
+
+            publishing {
+                publications {
+                    maven(MavenPublication) {
+                        from components.java
+                    }
+                }
+            }
+            """)
+            it.file("src/main/java/net/neoforged/gradle/userdev/FunctionalTests.java", """
+                package net.neoforged.gradle.userdev;
+
+                import net.minecraft.client.Minecraft;
+
+                public class FunctionalTests {
+                    public static void main(String[] args) {
+                        System.out.println(Minecraft.getInstance().getClass().toString());
+                    }
+                }
+            """)
+            it.withToolchains()
+        })
+
+        when:
+        def run = project.run {
+            it.tasks('generateMetadataFileForMavenPublication', 'generatePomFileForMavenPublication')
+        }
+
+        then:
+        run.task(':generateMetadataFileForMavenPublication').outcome == TaskOutcome.SUCCESS
+        !run.file('build/publications/maven/module.json').text.contains(IvyDummyRepositoryEntry.NG_DUMMY_NG_MARKER)
+        !run.file('build/publications/maven/pom-default.xml').text.contains(IvyDummyRepositoryEntry.NG_DUMMY_NG_MARKER)
+    }
 }