Merge branch '1.21.x' into reactionable-testing

Author: Matyrobbrt

.github/workflows/build-prs.yml

@@ -20,22 +20,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 1000
-          fetch-tags: true
-
-      # GradleUtils will append the branch name to the version,
-      # but for that we need a properly checked out branch
-      - name: Create branch for commit (PR)
-        if: ${{ github.event_name == 'pull_request' }}
-        run:
-          git switch -C pr-${{ github.event.pull_request.number }}-${{ github.event.pull_request.head.ref }}
-
-      - name: Create branch for commit
-        if: ${{ github.event_name != 'pull_request' }}
-        run:
-          git switch -C ${{ github.ref_name }}
+        uses: neoforged/actions/checkout@main
 
       - name: Setup JDK 21
         uses: neoforged/actions/setup-java@main

.github/workflows/check-local-changes.yml

@@ -13,16 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 1000
-          fetch-tags: true
-
-      # GradleUtils will append the branch name to the version,
-      # but for that we need a properly checked out branch
-      - name: Create branch for commit
-        run:
-          git switch -C pr-${{ github.event.pull_request.number }}-${{ github.event.pull_request.head.ref }}
+        uses: neoforged/actions/checkout@main
 
       - name: Setup JDK 21
         uses: neoforged/actions/setup-java@main

.github/workflows/test-prs.yml

@@ -17,16 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 1000
-          fetch-tags: true
-
-      # GradleUtils will append the branch name to the version,
-      # but for that we need a properly checked out branch
-      - name: Create branch for commit
-        run:
-          git switch -C pr-${{ github.event.pull_request.number }}-${{ github.event.pull_request.head.ref }}
+        uses: neoforged/actions/checkout@main
 
       - name: Setup JDK 21
         uses: neoforged/actions/setup-java@main

build.gradle

@@ -72,28 +72,22 @@ immaculate {
             return fileContents
         }
 
-        def interfaceChange = Pattern.compile('^[-+].*(implements|(interface.*extends)).*\$', Pattern.UNIX_LINES | Pattern.MULTILINE)
-        custom 'noInterfaceRemoval', { String fileContents ->
-            def interfaceChanges = fileContents.findAll(interfaceChange)
+        def interfaceChange = Pattern.compile('[-+].*(implements|(interface.*extends))(.*)\\{')
+        custom 'noInterfaceModifications', { String fileContents ->
+            def interfaceChanges = fileContents.lines().filter { it.matches(interfaceChange) }.toList()
             if (interfaceChanges.isEmpty()) return fileContents
-            String removalChange = ""
+            String oldInterfaces = ""
+            // we expect interface additions/removals in pairs of - and then +
             interfaceChanges.each { String change ->
+                final match = change =~ interfaceChange
+                match.find()
+                final values = match.group(3).trim()
                 if (change.startsWith('-')) {
-                    //Skip the - and the ending brace
-                    int implementsIndex = change.indexOf("implements")
-                    if (implementsIndex == -1) implementsIndex = change.indexOf("extends")
-                    //It should never still be -1 based on our initial matching regex, but if it does fail so we can figure out why
-                    if (implementsIndex == -1) implementsIndex = 1
-                    removalChange = change.substring(implementsIndex, change.length() - 1).trim()
-                } else if (!removalChange.isEmpty() && !change.contains(removalChange)) {
-                    throw new GradleException("Removal of interfaces via patches is not allowed!")
-                } else {
-                    removalChange = ""
+                    oldInterfaces = values
+                } else if (oldInterfaces != values) {
+                    throw new GradleException("Modification of interfaces via patches is not allowed!")
                 }
             }
-            if (!removalChange.isEmpty()) {
-                throw new GradleException("Removal of interfaces via patches is not allowed!")
-            }
             return fileContents
         }
 
@@ -148,6 +142,18 @@ immaculate {
             return sb.toString()
         }
 
+        // Disallow explicit not null in patches, it's always implied.
+        custom 'noNotNull', { String fileContents ->
+            fileContents.eachLine {
+                if (!it.startsWith("+")) return
+                if (it.contains('@NotNull') || it.contains('@Nonnull')
+                        || it.contains('@org.jetbrains.annotations.NotNull')
+                        || it.contains('@javax.annotation.Nonnull')) {
+                    throw new GradleException('@NotNull and @Nonnull are disallowed.')
+                }
+            }
+        }
+
         //Replace any FQN versions of javax.annotation.Nullable with the jetbrains variant
         custom 'jetbrainsNullablePatches', { String fileContents ->
             fileContents.replace('@javax.annotation.Nullable', '@org.jetbrains.annotations.Nullable')

buildSrc/build.gradle

@@ -14,14 +14,25 @@ repositories {
             includeGroup "net.neoforged"
         }
     }
+    maven {
+        name = "MojangMeta"
+        url = "https://maven.neoforged.net/mojang-meta"
+        content {
+            includeModule("net.neoforged", "minecraft-dependencies")
+        }
+    }
 }
 
 dependencies {
     // buildSrc is an includedbuild of the parent directory (gradle.parent)
     // ../settings.gradle sets these version properties accordingly
     implementation "net.neoforged:moddev-gradle:${gradle.parent.ext.moddevgradle_plugin_version}"
 
-    implementation "com.google.code.gson:gson:${gradle.parent.ext.gson_version}"
+    implementation(platform("net.neoforged:minecraft-dependencies:${gradle.parent.ext.minecraft_version}") {
+        exclude group: 'org.ow2.asm' // The platform requests a strictly lower version of ASM and we bump it
+    })
+
+    implementation "com.google.code.gson:gson"
     implementation "io.codechicken:DiffPatch:${gradle.parent.ext.diffpatch_version}"
 
     implementation "org.ow2.asm:asm:${gradle.parent.ext.asm_version}"

buildSrc/src/main/java/net/neoforged/neodev/GenerateSourcePatches.java

@@ -9,6 +9,8 @@
 import org.gradle.api.file.RegularFileProperty;
 import org.gradle.api.tasks.InputDirectory;
 import org.gradle.api.tasks.InputFile;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.OutputDirectory;
 import org.gradle.api.tasks.OutputFile;
 import org.gradle.api.tasks.PathSensitive;
 import org.gradle.api.tasks.PathSensitivity;
@@ -25,9 +27,14 @@ abstract class GenerateSourcePatches extends DefaultTask {
     @PathSensitive(PathSensitivity.RELATIVE)
     public abstract DirectoryProperty getModifiedSources();
 
+    @Optional
     @OutputFile
     public abstract RegularFileProperty getPatchesJar();
 
+    @Optional
+    @OutputDirectory
+    public abstract DirectoryProperty getPatchesFolder();
+
     @Inject
     public GenerateSourcePatches() {}
 
@@ -37,7 +44,7 @@ public void generateSourcePatches() throws IOException {
                 .logTo(getLogger()::lifecycle)
                 .baseInput(MultiInput.detectedArchive(getOriginalJar().get().getAsFile().toPath()))
                 .changedInput(MultiInput.folder(getModifiedSources().get().getAsFile().toPath()))
-                .patchesOutput(MultiOutput.detectedArchive(getPatchesJar().get().getAsFile().toPath()))
+                .patchesOutput(getPatchesJar().isPresent() ? MultiOutput.detectedArchive(getPatchesJar().get().getAsFile().toPath()) : MultiOutput.folder(getPatchesFolder().getAsFile().get().toPath()))
                 .autoHeader(true)
                 .level(io.codechicken.diffpatch.util.LogLevel.WARN)
                 .summary(false)

buildSrc/src/main/java/net/neoforged/neodev/NeoDevConfigurations.java

@@ -138,7 +138,7 @@ private NeoDevConfigurations(Project project) {
 
         // Libraries & module libraries & MC dependencies need to be available when compiling in NeoDev,
         // and on the runtime classpath too for IDE debugging support.
-        configurations.getByName("implementation").extendsFrom(libraries, moduleLibraries, neoFormDependencies);
+        configurations.getByName("api").extendsFrom(libraries, moduleLibraries, neoFormDependencies);
 
         // runtimeClasspath is our reference for all MC dependency versions.
         // Make sure that any classpath we resolve is consistent with it.

buildSrc/src/main/java/net/neoforged/neodev/NeoDevPlugin.java

@@ -37,6 +37,7 @@
 import java.io.File;
 import java.net.URI;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Consumer;
@@ -100,24 +101,39 @@ public void apply(Project project) {
         );
         var applyAt = configureAccessTransformer(
                 project,
-                configurations,
                 createSourceArtifacts,
                 neoDevBuildDir,
                 atFiles);
 
         applyAt.configure(task -> task.mustRunAfter(genAtsTask));
 
-        // 3. Apply patches to the source jar from 2.
+        // 3. Apply interface injections after the ATs
+        // this jar is only used for the patches in the repo
+        var applyInterfaceInjection = project.getTasks().register("applyInterfaceInjection", TransformSources.class, task -> {
+            task.getInputJar().set(applyAt.flatMap(TransformSources::getOutputJar));
+            task.getInterfaceInjectionData().from(project.getRootProject().file("src/main/resources/META-INF/injected-interfaces.json"));
+            task.getOutputJar().set(neoDevBuildDir.map(dir -> dir.file("artifacts/interface-injected-sources.jar")));
+        });
+
+        tasks.withType(TransformSources.class, task -> {
+            task.setGroup(INTERNAL_GROUP);
+            task.classpath(configurations.getExecutableTool(Tools.JST));
+
+            task.getLibraries().from(configurations.neoFormClasspath);
+            task.getLibrariesFile().set(neoDevBuildDir.map(dir -> dir.file("minecraft-libraries-for-" + task.getName() + ".txt")));
+        });
+
+        // 4. Apply patches to the source jar from 3.
         var patchesFolder = project.getRootProject().file("patches");
         var applyPatches = tasks.register("applyPatches", ApplyPatches.class, task -> {
             task.setGroup(INTERNAL_GROUP);
-            task.getOriginalJar().set(applyAt.flatMap(ApplyAccessTransformer::getOutputJar));
+            task.getOriginalJar().set(applyInterfaceInjection.flatMap(TransformSources::getOutputJar));
             task.getPatchesFolder().set(patchesFolder);
             task.getPatchedJar().set(neoDevBuildDir.map(dir -> dir.file("artifacts/patched-sources.jar")));
             task.getRejectsFolder().set(project.getRootProject().file("rejects"));
         });
 
-        // 4. Unpack jar from 3.
+        // 5. Unpack jar from 4.
         var mcSourcesPath = project.file("src/main/java");
         tasks.register("setup", Sync.class, task -> {
             task.setGroup(GROUP);
@@ -185,14 +201,22 @@ public void apply(Project project) {
          * OTHER TASKS
          */
 
-        // Generate source patches into a patch archive.
+        // Generate source patches into a patch archive, based on the jar with injected interfaces.
         var genSourcePatches = tasks.register("generateSourcePatches", GenerateSourcePatches.class, task -> {
             task.setGroup(INTERNAL_GROUP);
-            task.getOriginalJar().set(applyAt.flatMap(ApplyAccessTransformer::getOutputJar));
+            task.getOriginalJar().set(applyInterfaceInjection.flatMap(TransformSources::getOutputJar));
             task.getModifiedSources().set(project.file("src/main/java"));
             task.getPatchesJar().set(neoDevBuildDir.map(dir -> dir.file("source-patches.zip")));
         });
 
+        // Generate source patches that are based on the production environment (without separate interface injection)
+        var genProductionPatches = tasks.register("generateProductionSourcePatches", GenerateSourcePatches.class, task -> {
+            task.setGroup(INTERNAL_GROUP);
+            task.getOriginalJar().set(applyAt.flatMap(TransformSources::getOutputJar));
+            task.getModifiedSources().set(project.file("src/main/java"));
+            task.getPatchesFolder().set(neoDevBuildDir.map(dir -> dir.dir("production-source-patches")));
+        });
+
         // Update the patch/ folder with the current patches.
         tasks.register("genPatches", Sync.class, task -> {
             task.setGroup(GROUP);
@@ -245,9 +269,10 @@ public void apply(Project project) {
                 configurations,
                 createCleanArtifacts,
                 neoDevBuildDir,
-                patchesFolder
+                genProductionPatches.flatMap(GenerateSourcePatches::getPatchesFolder)
         );
 
+        var installerRepositoryUrls = getInstallerRepositoryUrls(project);
         // Launcher profile = the version.json file used by the Minecraft launcher.
         var createLauncherProfile = tasks.register("createLauncherProfile", CreateLauncherProfile.class, task -> {
             task.setGroup(INTERNAL_GROUP);
@@ -256,17 +281,7 @@ public void apply(Project project) {
             task.getNeoForgeVersion().set(neoForgeVersion);
             task.getRawNeoFormVersion().set(rawNeoFormVersion);
             task.setLibraries(configurations.launcherProfileClasspath);
-            task.getRepositoryURLs().set(project.provider(() -> {
-                List<URI> repos = new ArrayList<>();
-                for (var repo : project.getRepositories().withType(MavenArtifactRepository.class)) {
-                    var uri = repo.getUrl();
-                    if (!uri.toString().endsWith("/")) {
-                        uri = URI.create(uri + "/");
-                    }
-                    repos.add(uri);
-                }
-                return repos;
-            }));
+            task.getRepositoryURLs().set(installerRepositoryUrls);
             // ${version_name}.jar will be filled out by the launcher. It corresponds to the raw SRG Minecraft client jar.
             task.getIgnoreList().addAll("client-extra", "${version_name}.jar");
             task.setModules(configurations.modulePath);
@@ -285,17 +300,7 @@ public void apply(Project project) {
             task.addLibraries(configurations.launcherProfileClasspath);
             // We need the NeoForm zip for the SRG mappings.
             task.addLibraries(configurations.neoFormDataOnly);
-            task.getRepositoryURLs().set(project.provider(() -> {
-                List<URI> repos = new ArrayList<>();
-                for (var repo : project.getRepositories().withType(MavenArtifactRepository.class)) {
-                    var uri = repo.getUrl();
-                    if (!uri.toString().endsWith("/")) {
-                        uri = URI.create(uri + "/");
-                    }
-                    repos.add(uri);
-                }
-                return repos;
-            }));
+            task.getRepositoryURLs().set(installerRepositoryUrls);
             task.getUniversalJar().set(universalJar.flatMap(AbstractArchiveTask::getArchiveFile));
             task.getInstallerProfile().set(neoDevBuildDir.map(dir -> dir.file("installer-profile.json")));
 
@@ -411,7 +416,7 @@ public void apply(Project project) {
             task.from(binaryPatchOutputs.binaryPatchesForMerged(), spec -> {
                 spec.rename(s -> "joined.lzma");
             });
-            task.from(project.zipTree(genSourcePatches.flatMap(GenerateSourcePatches::getPatchesJar)), spec -> {
+            task.from(project.fileTree(genProductionPatches.flatMap(GenerateSourcePatches::getPatchesFolder)), spec -> {
                 spec.into("patches/");
             });
         });
@@ -444,32 +449,51 @@ public void apply(Project project) {
         setupProductionServerTest(project, installerJar);
     }
 
-    private static TaskProvider<ApplyAccessTransformer> configureAccessTransformer(
+    /**
+     * Get the list of Maven repositories that may contain artifacts for the installer.
+     */
+    private static Provider<List<URI>> getInstallerRepositoryUrls(Project project) {
+        return project.provider(() -> {
+            List<URI> repos = new ArrayList<>();
+            var projectRepos = project.getRepositories();
+            if (!projectRepos.isEmpty()) {
+                for (var repo : projectRepos.withType(MavenArtifactRepository.class)) {
+                    repos.add(repo.getUrl());
+                }
+            } else {
+                // If no project repos are defined, use the repository list we exposed in settings.gradle via an extension
+                // See the end of settings.gradle for details
+                Collections.addAll(repos, (URI[]) project.getGradle().getExtensions().getByName("repositoryBaseUrls"));
+            }
+
+            // Ensure all base urls end with a slash
+            repos.replaceAll(uri -> uri.toString().endsWith("/") ? uri : URI.create(uri + "/"));
+
+            return repos;
+        });
+    }
+
+    private static TaskProvider<TransformSources> configureAccessTransformer(
             Project project,
-            NeoDevConfigurations configurations,
             TaskProvider<CreateMinecraftArtifacts> createSourceArtifacts,
             Provider<Directory> neoDevBuildDir,
             List<File> atFiles) {
 
         // Pass -PvalidateAccessTransformers to validate ATs.
         var validateAts = project.getProviders().gradleProperty("validateAccessTransformers").map(p -> true).orElse(false);
-        return project.getTasks().register("applyAccessTransformer", ApplyAccessTransformer.class, task -> {
-            task.setGroup(INTERNAL_GROUP);
-            task.classpath(configurations.getExecutableTool(Tools.JST));
+        return project.getTasks().register("applyAccessTransformer", TransformSources.class, task -> {
             task.getInputJar().set(createSourceArtifacts.flatMap(CreateMinecraftArtifacts::getSourcesArtifact));
             task.getAccessTransformers().from(atFiles);
-            task.getValidate().set(validateAts);
+            task.getValidateAccessTransformers().set(validateAts);
             task.getOutputJar().set(neoDevBuildDir.map(dir -> dir.file("artifacts/access-transformed-sources.jar")));
-            task.getLibraries().from(configurations.neoFormClasspath);
-            task.getLibrariesFile().set(neoDevBuildDir.map(dir -> dir.file("minecraft-libraries-for-jst.txt")));
         });
     }
 
     private static BinaryPatchOutputs configureBinaryPatchCreation(Project project,
                                                                    NeoDevConfigurations configurations,
                                                                    TaskProvider<CreateCleanArtifacts> createCleanArtifacts,
                                                                    Provider<Directory> neoDevBuildDir,
-                                                                   File sourcesPatchesFolder) {
+                                                                   Provider<Directory> sourcesPatchesFolder) {
         var tasks = project.getTasks();
 
         var artConfig = configurations.getExecutableTool(Tools.AUTO_RENAMING_TOOL);