Resolve the issue where Mixin Extras does not appear on the CP

Add support for rich versions

Closes: #84

common/src/main/java/net/neoforged/gradle/common/extensions/dependency/replacement/ReplacementLogic.java

@@ -335,7 +335,14 @@ Entry createDummyDependency(final Dependency dependency, final ReplacementResult
         }
 
         // Create a new repository entry for the dependency, using the replacement result.
-        final ExternalModuleDependency externalModuleDependency = (ExternalModuleDependency) dependency;
+        ExternalModuleDependency externalModuleDependency = (ExternalModuleDependency) dependency;
+        //Check if the result is replacement aware.
+        if (result instanceof ReplacementAware) {
+            final ReplacementAware replacementAware = (ReplacementAware) result;
+            //Let it alter the dependency, this allows support for version ranges, and strict versioning.
+            externalModuleDependency = replacementAware.getReplacementDependency(externalModuleDependency);
+        }
+
         final Repository extension = project.getExtensions().getByType(Repository.class);
         return extension.withEntry(
                 project.getObjects().newInstance(

common/src/main/java/net/neoforged/gradle/common/extensions/repository/IvyRepository.java

@@ -61,10 +61,15 @@ public Project getProject() {
     }
 
     private ArtifactRepository createRepositories() {
-        return project.getRepositories().ivy(repositoryConfiguration(
+        final ArtifactRepository repository = project.getRepositories().ivy(repositoryConfiguration(
                 "NeoGradle Artifacts",
                 getRepositoryDirectory()
         ));
+
+        project.getRepositories().remove(repository);
+        project.getRepositories().addFirst(repository);
+
+        return repository;
     }
 
     @Override

dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/dependency/replacement/ReplacementAware.groovy

@@ -1,6 +1,7 @@
 package net.neoforged.gradle.dsl.common.extensions.dependency.replacement
 
 import net.neoforged.gradle.dsl.common.tasks.WithOutput
+import org.gradle.api.artifacts.ExternalModuleDependency
 import org.gradle.api.tasks.TaskProvider
 
 /**
@@ -18,4 +19,12 @@ interface ReplacementAware {
             TaskProvider<? extends WithOutput> copiesRawJar,
             TaskProvider<? extends WithOutput> copiesMappedJar
     );
+
+    /**
+     * Gets the replacement dependency for the given dependency.
+     *
+     * @param externalModuleDependency The dependency to get the replacement for.
+     * @return The replacement dependency.
+     */
+     ExternalModuleDependency getReplacementDependency(ExternalModuleDependency externalModuleDependency)
 }

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

@@ -38,6 +38,125 @@ class FunctionalTests extends BuilderBasedTestSpecification {
         run.task(':neoFormRecompile').outcome == TaskOutcome.SUCCESS
     }
 
+    def "userdev supports version range resolution"() {
+        given:
+        def project = create("userdev_supports_version_ranges", {
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:[20,)'
+            }
+            """)
+            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('dependencies', "--configuration", "compileClasspath")
+        }
+
+        then:
+        run.task(':dependencies').outcome == TaskOutcome.SUCCESS
+        run.output.contains("\\--- net.neoforged:neoforge:")
+    }
+
+    def "userdev supports complex version resolution"() {
+        given:
+        def project = create("userdev_supports_complex_versions", {
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            dependencies {
+                implementation ('net.neoforged:neoforge') {
+                    version {
+                        strictly '[20.4.167, 20.5)'
+                        require '20.4.188'
+                    }
+                }
+            }
+            """)
+            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('dependencies', "--configuration", "compileClasspath")
+        }
+
+        then:
+        run.task(':dependencies').outcome == TaskOutcome.SUCCESS
+        run.output.contains("\\--- net.neoforged:neoforge:20.4.188")
+    }
+
+    def "a mod with userdev as dependency has a mixin-extra dependency on the compile classpath"() {
+        given:
+        def project = create("userdev_adds_mixin_extra_on_compile_classpath", {
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+            }
+            """)
+            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('dependencies', "--configuration", "compileClasspath")
+        }
+
+        then:
+        run.task(':dependencies').outcome == TaskOutcome.SUCCESS
+        run.output.contains("+--- io.github.llamalad7:mixinextras-neoforge")
+    }
+
     def "a mod with userdev as dependency and official mappings can compile through gradle"() {
         given:
         def project = create("compile_with_gradle_and_official_mappings", {

userdev/src/main/java/net/neoforged/gradle/userdev/UserDevProjectPlugin.java

@@ -3,10 +3,8 @@
 import net.neoforged.gradle.common.extensions.DefaultJarJarFeature;
 import net.neoforged.gradle.common.extensions.JarJarExtension;
 import net.neoforged.gradle.dsl.common.extensions.JarJar;
-import net.neoforged.gradle.dsl.userdev.extension.UserDev;
 import net.neoforged.gradle.neoform.NeoFormPlugin;
 import net.neoforged.gradle.userdev.dependency.UserDevDependencyManager;
-import net.neoforged.gradle.userdev.extension.UserDevExtension;
 import net.neoforged.gradle.userdev.runtime.extension.UserDevRuntimeExtension;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
@@ -22,7 +20,6 @@ public class UserDevProjectPlugin implements Plugin<Project> {
     public void apply(Project project) {
         project.getPlugins().apply(NeoFormPlugin.class);
 
-        project.getExtensions().create(UserDev.class, "userDev", UserDevExtension.class, project);
         project.getExtensions().create("userDevRuntime", UserDevRuntimeExtension.class, project);
 
         UserDevDependencyManager.getInstance().apply(project);

userdev/src/main/java/net/neoforged/gradle/userdev/dependency/UserDevDependencyManager.java

@@ -1,20 +1,12 @@
 package net.neoforged.gradle.userdev.dependency;
 
-import com.google.common.collect.Sets;
-import net.neoforged.gradle.dsl.common.util.ConfigurationUtils;
 import net.neoforged.gradle.dsl.common.extensions.dependency.replacement.DependencyReplacement;
-import net.neoforged.gradle.dsl.common.extensions.dependency.replacement.ReplacementResult;
-import net.neoforged.gradle.dsl.common.util.CommonRuntimeUtils;
+import net.neoforged.gradle.dsl.common.util.ConfigurationUtils;
 import net.neoforged.gradle.dsl.common.util.DistributionType;
-import net.neoforged.gradle.dsl.userdev.extension.UserDev;
 import net.neoforged.gradle.userdev.runtime.definition.UserDevRuntimeDefinition;
 import net.neoforged.gradle.userdev.runtime.extension.UserDevRuntimeExtension;
 import org.gradle.api.Project;
-import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.artifacts.Dependency;
-import org.gradle.api.artifacts.DependencyArtifact;
-import org.gradle.api.artifacts.ExternalModuleDependency;
-import org.gradle.api.provider.Provider;
+import org.gradle.api.artifacts.*;
 
 import java.util.Collections;
 import java.util.Objects;
@@ -97,16 +89,21 @@ private static boolean hasSourcesArtifact(ExternalModuleDependency externalModul
 
     private static UserDevRuntimeDefinition buildForgeUserDevRuntimeFrom(Project project, ExternalModuleDependency dependency) {
         final UserDevRuntimeExtension forgeRuntimeExtension = project.getExtensions().getByType(UserDevRuntimeExtension.class);
-        final UserDev userDevExtension = project.getExtensions().getByType(UserDev.class);
-
+
         return forgeRuntimeExtension.maybeCreateFor(dependency, builder -> {
-            final Provider<String> version = project.provider(dependency::getVersion).orElse(userDevExtension.getDefaultForgeVersion());
-            final Provider<String> group = project.provider(dependency::getGroup).orElse(userDevExtension.getDefaultForgeGroup());
-            final Provider<String> name = project.provider(dependency::getName).orElse(userDevExtension.getDefaultForgeName());
-
-            builder.withForgeVersion(version);
-            builder.withForgeGroup(group);
-            builder.withForgeName(name);
+
+            final ExternalModuleDependency clone = dependency.copy();
+            clone.artifact(artifact -> {
+                artifact.setExtension("jar");
+                artifact.setClassifier("userdev");
+            });
+
+            final Configuration userdevLookup = ConfigurationUtils.temporaryUnhandledConfiguration(project.getConfigurations(), "ResolveRequestedNeoForgeVersion", clone);
+            final ResolvedArtifact resolvedArtifact = userdevLookup.getResolvedConfiguration().getFirstLevelModuleDependencies().iterator().next().getModuleArtifacts().iterator().next();
+
+            builder.withForgeVersion(resolvedArtifact.getModuleVersion().getId().getVersion());
+            builder.withForgeGroup(resolvedArtifact.getModuleVersion().getId().getGroup());
+            builder.withForgeName(resolvedArtifact.getModuleVersion().getId().getName());
             builder.withDistributionType(DistributionType.JOINED);
         });
     }

userdev/src/main/java/net/neoforged/gradle/userdev/dependency/UserDevReplacementResult.java

@@ -7,6 +7,8 @@
 import org.gradle.api.Project;
 import org.gradle.api.Task;
 import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.Dependency;
+import org.gradle.api.artifacts.ExternalModuleDependency;
 import org.gradle.api.tasks.TaskProvider;
 import org.jetbrains.annotations.Nullable;
 
@@ -36,4 +38,17 @@ public void onTasksCreated(TaskProvider<? extends WithOutput> copiesRawJar, Task
         //Register the classpath element producer
         definition.setUserdevClasspathElementProducer(copiesRawJar);
     }
+
+    @Override
+    public ExternalModuleDependency getReplacementDependency(ExternalModuleDependency externalModuleDependency) {
+        final Dependency resolvedExactVersionDependency = getProject().getDependencies()
+                .create(
+                        definition.getSpecification().getForgeGroup() + ":" + definition.getSpecification().getForgeName() + ":" + definition.getSpecification().getForgeVersion()
+                );
+
+        if (!(resolvedExactVersionDependency instanceof ExternalModuleDependency))
+            throw new IllegalStateException("Resolved dependency is not an ExternalModuleDependency");
+
+        return (ExternalModuleDependency) resolvedExactVersionDependency;
+    }
 }