Configure binary patch mode ready for production.

Author: marchermans

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

@@ -58,6 +58,17 @@ class AdvancedFmlTests extends BuilderBasedTestSpecification {
                 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()
             it.withGlobalCacheDirectory(tempDir)
             it.withEnvironmentVariable("CI", "true")
@@ -70,13 +81,13 @@ class AdvancedFmlTests extends BuilderBasedTestSpecification {
         }
 
         then:
-        run.task(':compileJava').outcome == TaskOutcome.NO_SOURCE
+        run.task(':compileJava').outcome == TaskOutcome.SUCCESS
         run.task(":neoFormDecompile") == null
     }
 
     def "a mod with userdev as dependency can run the compile task for that dependency with the decompiler disabled"() {
         given:
-        def project = create("running_compile_in_ci", {
+        def project = create("running_compile_with_compiler_disabled", {
             it.build("""
             java {
                 toolchain {
@@ -88,6 +99,17 @@ class AdvancedFmlTests extends BuilderBasedTestSpecification {
                 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()
             it.withGlobalCacheDirectory(tempDir)
             it.property("neogradle.subsystems.decompiler.enabled", "false")
@@ -100,23 +122,13 @@ class AdvancedFmlTests extends BuilderBasedTestSpecification {
         }
 
         then:
-        run.task(':compileJava').outcome == TaskOutcome.NO_SOURCE
+        run.task(':compileJava').outcome == TaskOutcome.SUCCESS
         run.task(":neoFormDecompile") == null
     }
 
     def "a mod using a disabled decompiler should be able to run the game"() {
         given:
-        def project = create("version_libs_runnable", {
-            it.file("gradle/libs.versions.toml",
-                    """
-                    [versions]
-                    # Neoforge Settings
-                    neoforge = "+"
-                    
-                    [libraries]
-                    neoforge = { group = "net.neoforged", name = "neoforge", version.ref = "neoforge" }
-                    """.trim())
-
+        def project = create("disabled_decompiler_runs_game", {
             it.build("""
             java {
                 toolchain {
@@ -129,9 +141,32 @@ class AdvancedFmlTests extends BuilderBasedTestSpecification {
             }
                         
             dependencies {
-                implementation(libs.neoforge)
+                implementation 'net.neoforged:neoforge:+'
             }
             """)
+
+            it.file("src/main/resources/META-INF/neoforge.mods.toml", """
+            license="MIT"
+            [[mods]]
+            modId="neogradle_test"
+            version="1.0"
+            displayName="NeoGradle Test"
+            description='''Test Mod for NeoGradle'''
+            """.stripMargin())
+
+            it.file("src/main/java/net/neoforged/gradle/userdev/FunctionalTests.java", """
+                package net.neoforged.gradle.userdev;
+                
+                import net.minecraft.client.Minecraft;
+                import net.neoforged.fml.common.Mod;
+                
+                @Mod("neogradle_test")
+                public class FunctionalTests {
+                    public FunctionalTests() {
+                        System.out.println(Minecraft.class.toString());
+                    }
+                }
+            """.stripMargin())
             it.withToolchains()
             it.withGlobalCacheDirectory(tempDir)
             it.property("neogradle.subsystems.decompiler.enabled", "false")
@@ -140,14 +175,12 @@ class AdvancedFmlTests extends BuilderBasedTestSpecification {
         when:
         def run = project.run {
             it.tasks(':runClientData')
-            //We are expecting this test to fail, since there is a mod without any files included so it is fine.
-            it.shouldFail()
             it.stacktrace()
         }
 
         then:
         true
-        run.output.contains("is not a valid mod file")
+        run.output.contains("class net.minecraft.client.Minecraft")
         run.task(":neoFormDecompile") == null
     }
 }

userdev/src/main/java/net/neoforged/gradle/userdev/runtime/extension/UserDevRuntimeExtension.java

@@ -11,7 +11,6 @@
 import net.neoforged.gradle.dsl.common.runs.run.RunManager;
 import net.neoforged.gradle.dsl.common.runs.type.RunTypeManager;
 import net.neoforged.gradle.dsl.common.runtime.tasks.Runtime;
-import net.neoforged.gradle.dsl.common.runtime.tasks.RuntimeArguments;
 import net.neoforged.gradle.dsl.common.runtime.tasks.tree.TaskTreeAdapter;
 import net.neoforged.gradle.dsl.common.tasks.WithOutput;
 import net.neoforged.gradle.dsl.common.util.CommonRuntimeUtils;
@@ -62,7 +61,8 @@ public UserDevRuntimeExtension(Project project)
             "AdditionalDependenciesFor" + spec.getIdentifier()
         );
 
-        if (!useCombinedJarWithNeoForgeOnRecompile(spec)) {
+        if (!useCombinedJarWithNeoForgeOnRecompile(spec))
+        {
             //Create the client-extra jar dependency.
             final Dependency clientExtraJar = spec.getProject().getDependencies().create(
                 ExtraJarDependencyManager.generateClientCoordinateFor(spec.getMinecraftVersion())
@@ -72,7 +72,9 @@ public UserDevRuntimeExtension(Project project)
             userDevAdditionalDependenciesConfiguration.getDependencies().add(
                 clientExtraJar
             );
-        } else {
+        }
+        else
+        {
             userDevAdditionalDependenciesConfiguration.getDependencies().addLater(
                 userDevProfile.getUniversalJarArtifactCoordinate().map(spec.getProject().getDependencies()::create)
             );
@@ -92,7 +94,7 @@ public UserDevRuntimeExtension(Project project)
             builder.withNeoFormDependency(userDevProfile.getNeoForm().get())
                 .withDistributionType(DistributionType.JOINED)
                 .withAdditionalDependencies(getProject().files(userDevAdditionalDependenciesConfiguration))
-                .withStepsMutator(this.adaptNeoFormRuntime(spec));
+                .withStepsMutator(this.adaptNeoFormRuntime(spec, userDevProfile, userDevJar));
 
             final FileTree accessTransformerFiles =
                 userDevJar.matching(filter -> filter.include(userDevProfile.getAccessTransformerDirectory().get() + "/**"));
@@ -102,6 +104,7 @@ public UserDevRuntimeExtension(Project project)
             builder.withPostTaskAdapter("patch", createPatchAdapter(userDevJar, userDevProfile.getSourcePatchesDirectory().get()));
 
             if (!useCombinedJarWithNeoForgeOnRecompile(spec))
+            {
                 builder.withTaskCustomizer("inject", InjectZipContent.class, task -> {
                     FileTree injectionDirectoryTree;
                     if (userDevProfile.getInjectedFilesDirectory().isPresent())
@@ -120,6 +123,7 @@ public UserDevRuntimeExtension(Project project)
                         ConfigurationUtils.getArtifactProvider(getProject(), "NeoForgeRawLookupFor" + spec.getIdentifier(), userDevProfile.getUniversalJarArtifactCoordinate())
                     );
                 });
+            }
         });
 
         spec.setMinecraftVersion(neoFormRuntimeDefinition.getSpecification().getMinecraftVersion());
@@ -133,7 +137,10 @@ public UserDevRuntimeExtension(Project project)
         );
     }
 
-    private @NotNull BiConsumer<List<NeoFormConfigConfigurationSpecV1.Step>, Map<String, NeoFormConfigConfigurationSpecV1.Function>> adaptNeoFormRuntime(final UserDevRuntimeSpecification spec)
+    private @NotNull BiConsumer<List<NeoFormConfigConfigurationSpecV1.Step>, Map<String, NeoFormConfigConfigurationSpecV1.Function>> adaptNeoFormRuntime(
+        final UserDevRuntimeSpecification spec,
+        final UserdevProfile userDevProfile,
+        final FileTree userDevJar)
     {
         return (steps, functions) -> {
             if (!useCombinedJarWithNeoForgeOnRecompile(spec))
@@ -166,7 +173,11 @@ public UserDevRuntimeExtension(Project project)
             );
 
             final Subsystems parchment = spec.getProject().getExtensions().getByType(Subsystems.class);
-            final SetupConfiguration configuration = buildSetupConfiguration();
+            final SetupConfiguration configuration = buildSetupConfiguration(
+                spec,
+                userDevProfile,
+                userDevJar
+            );
 
             //Register the setup function:
             functions.put(
@@ -188,13 +199,15 @@ public UserDevRuntimeExtension(Project project)
         };
     }
 
-    private record SetupConfiguration(List<String> arguments, Map<String, String> values) {
-
-    }
+    private record SetupConfiguration(
+        List<String> arguments,
+        Map<String, String> values) {}
 
-    private SetupConfiguration buildSetupConfiguration(UserDevRuntimeDefinition definition) {
+    private SetupConfiguration buildSetupConfiguration(UserDevRuntimeSpecification spec, final UserdevProfile userDevProfile, final FileTree userDevJar)
+    {
         final Decompiler decompilerSubsystemConfiguration = getProject().getExtensions().getByType(Subsystems.class).getDecompiler();
-        if (decompilerSubsystemConfiguration.getIsDisabled().get() && useCombinedJarWithNeoForgeOnRecompile(definition.getSpecification())) {
+        if (decompilerSubsystemConfiguration.getIsDisabled().get() && useCombinedJarWithNeoForgeOnRecompile(spec))
+        {
             return new SetupConfiguration(
                 List.of(
                     "--task", "PROCESS_MINECRAFT_JAR",
@@ -210,7 +223,10 @@ private SetupConfiguration buildSetupConfiguration(UserDevRuntimeDefinition defi
                     "clientMappings", "{downloadClientMappingsOutput}",
                     "server", "{downloadServerOutput}",
                     "neoform", "{neoform}",
-                    "patches", "{patches}"
+                    "patches", userDevProfile.getBinaryPatchFile()
+                        .map(patchFilePath -> userDevJar
+                            .matching(matcher -> matcher.include(patchFilePath))
+                            .getSingleFile()).get().getAbsolutePath()
                 )
             );
         }
@@ -277,84 +293,17 @@ protected void afterRegistration(UserDevRuntimeDefinition runtime)
         );
     }
 
-    private void bakeDefinition(UserDevRuntimeDefinition definition) {
+    private void bakeDefinition(UserDevRuntimeDefinition definition)
+    {
         final Decompiler decompilerSubsystemConfiguration = this.getProject().getExtensions().getByType(Subsystems.class).getDecompiler();
-        if (decompilerSubsystemConfiguration.getIsDisabled().get() && useCombinedJarWithNeoForgeOnRecompile(definition.getSpecification())) {
-            final TaskProvider<? extends Runtime> binaryPatchedOutput = configureBinaryPatchMode(
-                definition,
-                definition.getNeoFormRuntimeDefinition().getTaskInputsByStepName(),
-                definition.getNeoFormRuntimeDefinition().getBakedSteps()
-            );
-
-            binaryPatchedOutput.configure(task -> {
-                NeoFormRuntimeExtension.configureMcpRuntimeTaskWithDefaults(
-                    definition.getNeoFormRuntimeDefinition(),
-                    task,
-                    new NeoFormConfigConfigurationSpecV1.Step("binPatch", "binPatch", Map.of())
-                    );
-            });
-
+        if (decompilerSubsystemConfiguration.getIsDisabled().get() && useCombinedJarWithNeoForgeOnRecompile(definition.getSpecification()))
+        {
             definition.getNeoFormRuntimeDefinition().getRawJarTask().configure(task -> {
-                task.getInput().set(binaryPatchedOutput.flatMap(WithOutput::getOutput));
+                task.getInput().set(definition.getNeoFormRuntimeDefinition().getTask("setup").flatMap(WithOutput::getOutput));
             });
         }
     }
 
-    private TaskProvider<? extends Runtime> configureBinaryPatchMode(
-        final UserDevRuntimeDefinition definition,
-        final Map<String, Optional<TaskProvider<? extends WithOutput>>> taskInputsByStepName,
-        final List<NeoFormConfigConfigurationSpecV1.Step> steps) {
-        final NeoFormConfigConfigurationSpecV1.Step step = ListUtils.find(
-            steps, s -> s.getType().equals("decompile")
-        );
-        if (step == null)
-            throw new IllegalArgumentException("Could not find the decompile step!");
-        final Provider<File> cleanFileProvider;
-        Optional<TaskProvider<? extends WithOutput>> decompilerInputOptional = taskInputsByStepName.get("decompile");
-        TaskProvider<? extends Runtime> decompileTask = definition.getSpecification().getProject().getTasks().named(
-            CommonRuntimeUtils.buildTaskName(definition.getNeoFormRuntimeDefinition(), "decompile"),
-            Runtime.class
-        );
-        if (decompilerInputOptional != null && decompilerInputOptional.isPresent()) {
-            cleanFileProvider = decompilerInputOptional.get().flatMap(WithOutput::getOutput)
-                .map(RegularFile::getAsFile);
-        } else {
-            cleanFileProvider = decompileTask.map(Runtime::getArguments)
-                .flatMap(arguments -> arguments.get("input"))
-                .map(File::new);
-        }
-
-        return definition.getSpecification().getProject().getTasks().register(CommonRuntimeUtils.buildTaskName(definition.getSpecification(), "binaryPatch"), DefaultExecute.class, task -> {
-            task.getExecutingJar().fileProvider(ToolUtilities.resolveTool(
-                task.getProject(),
-                definition.getUserdevConfiguration().getBinaryPatcher()
-                    .flatMap(UserdevProfile.ToolExecution::getTool)
-            ));
-            task.getJvmArguments().addAll(
-                definition.getUserdevConfiguration().getBinaryPatcher()
-                    .flatMap(UserdevProfile.ToolExecution::getJvmArguments)
-            );
-            task.getProgramArguments().addAll(
-                definition.getUserdevConfiguration().getBinaryPatcher()
-                    .flatMap(UserdevProfile.ToolExecution::getArguments)
-            );
-
-            task.getArguments().putFile(
-                "clean",
-                cleanFileProvider
-            );
-            task.getArguments().putFile(
-                "patch",
-                definition.getUserdevConfiguration().getBinaryPatchFile()
-                    .map(patchFilePath -> definition.getUnpackedUserDevJarDirectory()
-                        .matching(matcher -> matcher.include(patchFilePath))
-                        .getSingleFile())
-            );
-        });
-
-    }
-
-
     @Override
     protected UserDevRuntimeSpecification.Builder createBuilder()
     {

userdev/tests/runtime/disabled_decompiler_runs_game/build.gradle

@@ -0,0 +1,19 @@
+plugins {
+   id 'net.neoforged.gradle.userdev'
+} 
+
+
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+            
+            repositories {
+                mavenCentral()
+            }
+                        
+            dependencies {
+                implementation 'net.neoforged:neoforge:+'
+            }
+            

userdev/tests/runtime/disabled_decompiler_runs_game/gradle.properties

@@ -0,0 +1,4 @@
+neogradle.subsystems.decompiler.enabled=false
+net.neoforged.gradle.caching.cacheDirectory=/tmp/spock_a_mod_using_a_disab_0_tempDir6841875930781773787/.ng-cache
+org.gradle.console=rich
+org.gradle.jvmargs=-Xmx8000m

userdev/tests/runtime/disabled_decompiler_runs_game/runs/clientData/.cache/jij/51629231fe2baaddd60d570ef06ada2b2f1fe8a34133e63afdd748b9ef93f9f1/net.neoforged.neoforge-coremods-21.10.51-beta.jar

@@ -0,0 +1,30 @@
+#Disables File Watcher. Used to automatically update config if its file has been modified.
+disableConfigWatcher = false
+#Shows an early loading screen for mod loading which improves the user experience with early feedback about mod loading.
+earlyWindowControl = true
+#Max threads for early initialization parallelism,  -1 is based on processor count
+maxThreads = -1
+#Enable NeoForge global version checking
+versionCheck = true
+#Enable synchronous OpenGL debug output and object labeling
+debugOpenGl = false
+#Default config path for servers
+defaultConfigPath = "defaultconfigs"
+#Disables Optimized DFU client-side - already disabled on servers
+disableOptimizedDFU = true
+#Early window provider
+earlyWindowProvider = "fmlearlywindow"
+#Early window width
+earlyWindowWidth = 854
+#Early window height
+earlyWindowHeight = 480
+#Early window starts maximized
+earlyWindowMaximized = false
+#Force a given theme-id to be used for the early loading screen
+earlyLoadingScreenTheme = ""
+#Define dependency overrides below
+#Dependency overrides can be used to forcibly remove a dependency constraint from a mod or to force a mod to load AFTER another mod
+#Using dependency overrides can cause issues. Use at your own risk.
+#Example dependency override for the mod with the id 'targetMod': dependency constraints (incompatibility clauses or restrictive version ranges) against mod 'dep1' are removed, and the mod will now load after the mod 'dep2'
+#dependencyOverrides.targetMod = ["-dep1", "+dep2"]
+dependencyOverrides = {}