A lot of 0.11 stuff but nowhere near done

build.gradle

@@ -10,7 +10,7 @@ plugins {
 	id 'codenarc'
 	id "org.jetbrains.kotlin.jvm" version "1.5.31" // Must match the version included with gradle.
 	id "com.diffplug.spotless" version "5.14.1"
-	id 'net.kyori.blossom' version '1.3.0'
+	//id 'net.kyori.blossom' version '1.3.0'
 	id 'me.shedaniel.java-version-bridge' version '1.0-SNAPSHOT'
 }
 
@@ -145,9 +145,9 @@ dependencies {
 	compileOnly 'org.jetbrains:annotations:23.0.0'
 }
 
-blossom {
+/*blossom {
 	replaceToken '$LOOM_VERSION', version
-}
+}*/
 
 jar {
 	classifier 'jar'

src/main/java/net/fabricmc/loom/LoomGradleExtension.java

@@ -43,8 +43,7 @@ import net.fabricmc.loom.configuration.InstallerData;
 import net.fabricmc.loom.configuration.LoomDependencyManager;
 import net.fabricmc.loom.configuration.accesswidener.AccessWidenerFile;
 import net.fabricmc.loom.configuration.processors.JarProcessorManager;
-import net.fabricmc.loom.configuration.providers.MinecraftProviderImpl;
-import net.fabricmc.loom.configuration.providers.forge.FieldMigratedMappingsProvider;
+import net.fabricmc.loom.configuration.providers.forge.DependencyProviders;
 import net.fabricmc.loom.configuration.providers.forge.ForgeProvider;
 import net.fabricmc.loom.configuration.providers.forge.ForgeUniversalProvider;
 import net.fabricmc.loom.configuration.providers.forge.ForgeUserdevProvider;
@@ -57,6 +56,7 @@ import net.fabricmc.loom.configuration.providers.minecraft.mapped.IntermediaryMi
 import net.fabricmc.loom.configuration.providers.minecraft.mapped.NamedMinecraftProvider;
 import net.fabricmc.loom.extension.LoomFiles;
 import net.fabricmc.loom.extension.MixinExtension;
+import net.fabricmc.loom.util.FunnyTodoException;
 
 public interface LoomGradleExtension extends LoomGradleExtensionAPI {
 	static LoomGradleExtension get(Project project) {
@@ -113,6 +113,7 @@ public interface LoomGradleExtension extends LoomGradleExtensionAPI {
 		case NAMED -> getNamedMinecraftProvider().getMinecraftJars();
 		case INTERMEDIARY -> getIntermediaryMinecraftProvider().getMinecraftJars();
 		case OFFICIAL -> getMinecraftProvider().getMinecraftJars();
+		case SRG -> throw new FunnyTodoException("SRG minecraft jars");
 		};
 	}
 
@@ -135,11 +136,11 @@ public interface LoomGradleExtension extends LoomGradleExtensionAPI {
 	//  Architectury Loom
 	// ===================
 	default PatchProvider getPatchProvider() {
-		return getDependencyManager().getProvider(PatchProvider.class);
+		return getDependencyProviders().getProvider(PatchProvider.class);
 	}
 
 	default McpConfigProvider getMcpConfigProvider() {
-		return getDependencyManager().getProvider(McpConfigProvider.class);
+		return getDependencyProviders().getProvider(McpConfigProvider.class);
 	}
 
 	default boolean isDataGenEnabled() {
@@ -156,19 +157,22 @@ public interface LoomGradleExtension extends LoomGradleExtensionAPI {
 
 	boolean supportsInclude();
 
+	DependencyProviders getDependencyProviders();
+	void setDependencyProviders(DependencyProviders dependencyProviders);
+
 	default SrgProvider getSrgProvider() {
-		return getDependencyManager().getProvider(SrgProvider.class);
+		return getDependencyProviders().getProvider(SrgProvider.class);
 	}
 
 	default ForgeUniversalProvider getForgeUniversalProvider() {
-		return getDependencyManager().getProvider(ForgeUniversalProvider.class);
+		return getDependencyProviders().getProvider(ForgeUniversalProvider.class);
 	}
 
 	default ForgeUserdevProvider getForgeUserdevProvider() {
-		return getDependencyManager().getProvider(ForgeUserdevProvider.class);
+		return getDependencyProviders().getProvider(ForgeUserdevProvider.class);
 	}
 
 	default ForgeProvider getForgeProvider() {
-		return getDependencyManager().getProvider(ForgeProvider.class);
+		return getDependencyProviders().getProvider(ForgeProvider.class);
 	}
 }

src/main/java/net/fabricmc/loom/api/LoomGradleExtensionAPI.java

@@ -28,6 +28,7 @@ import java.util.List;
 import java.util.function.Consumer;
 
 import org.gradle.api.Action;
+import org.gradle.api.DomainObjectCollection;
 import org.gradle.api.NamedDomainObjectContainer;
 import org.gradle.api.artifacts.Dependency;
 import org.gradle.api.file.ConfigurableFileCollection;

src/main/java/net/fabricmc/loom/configuration/CompileConfiguration.java

@@ -45,11 +45,12 @@ import net.fabricmc.loom.configuration.accesswidener.AccessWidenerJarProcessor;
 import net.fabricmc.loom.configuration.accesswidener.TransitiveAccessWidenerJarProcessor;
 import net.fabricmc.loom.configuration.ifaceinject.InterfaceInjectionProcessor;
 import net.fabricmc.loom.configuration.processors.JarProcessorManager;
-import net.fabricmc.loom.configuration.providers.forge.FieldMigratedMappingsProvider;
+import net.fabricmc.loom.configuration.providers.forge.DependencyProviders;
 import net.fabricmc.loom.configuration.providers.forge.ForgeProvider;
 import net.fabricmc.loom.configuration.providers.forge.ForgeUniversalProvider;
 import net.fabricmc.loom.configuration.providers.forge.ForgeUserdevProvider;
 import net.fabricmc.loom.configuration.providers.forge.McpConfigProvider;
+import net.fabricmc.loom.configuration.providers.forge.MinecraftPatchedProvider2;
 import net.fabricmc.loom.configuration.providers.forge.PatchProvider;
 import net.fabricmc.loom.configuration.providers.forge.SrgProvider;
 import net.fabricmc.loom.configuration.providers.mappings.MappingsProviderImpl;
@@ -204,24 +205,27 @@ public final class CompileConfiguration {
 				throw new RuntimeException("Failed to setup minecraft", e);
 			}
 
+			DependencyProviders dependencyProviders = new DependencyProviders();
 			LoomDependencyManager dependencyManager = new LoomDependencyManager();
+			extension.setDependencyProviders(dependencyProviders);
 			extension.setDependencyManager(dependencyManager);
 
 			if (extension.isForge()) {
-				dependencyManager.addProvider(new ForgeProvider(project));
-				dependencyManager.addProvider(new ForgeUserdevProvider(project));
+				dependencyProviders.addProvider(new ForgeProvider(project));
+				dependencyProviders.addProvider(new ForgeUserdevProvider(project));
 			}
 
 			if (extension.shouldGenerateSrgTiny()) {
-				dependencyManager.addProvider(new SrgProvider(project));
+				dependencyProviders.addProvider(new SrgProvider(project));
 			}
 
 			if (extension.isForge()) {
-				dependencyManager.addProvider(new McpConfigProvider(project));
-				dependencyManager.addProvider(new PatchProvider(project));
-				dependencyManager.addProvider(new ForgeUniversalProvider(project));
+				dependencyProviders.addProvider(new McpConfigProvider(project));
+				dependencyProviders.addProvider(new PatchProvider(project));
+				dependencyProviders.addProvider(new ForgeUniversalProvider(project));
 			}
 
+			dependencyProviders.handleDependencies(project);
 			dependencyManager.handleDependencies(project);
 
 			extension.getRemapArchives().finalizeValue();
@@ -261,6 +265,11 @@ public final class CompileConfiguration {
 
 		// Provide the vanilla mc jars -- TODO share across projects.
 		final MinecraftProvider minecraftProvider = jarConfiguration.getMinecraftProviderFunction().apply(project);
+
+		if (extension.isForge() && !(minecraftProvider instanceof MinecraftPatchedProvider2)) {
+			throw new UnsupportedOperationException("Using Forge with split or server-only jars is not currently supported!");
+		}
+
 		extension.setMinecraftProvider(minecraftProvider);
 		minecraftProvider.provide();
 

src/main/java/net/fabricmc/loom/configuration/LoomDependencyManager.java

@@ -75,6 +75,7 @@ public class LoomDependencyManager {
 					}
 				}
 			}
+		}
 
 		SourceRemapper sourceRemapper = new SourceRemapper(project, true);
 		String platformSuffix = extension.isForge() ? "_forge" : "";

src/main/java/net/fabricmc/loom/configuration/providers/forge/DependencyProvider.java

@@ -0,0 +1,83 @@
+/*
+ * This file is part of fabric-loom, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2016-2022 FabricMC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package net.fabricmc.loom.configuration.providers.forge;
+
+import java.io.File;
+import java.util.function.Consumer;
+
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.Dependency;
+
+import net.fabricmc.loom.LoomGradleExtension;
+import net.fabricmc.loom.LoomGradlePlugin;
+import net.fabricmc.loom.configuration.DependencyInfo;
+import net.fabricmc.loom.configuration.providers.minecraft.MinecraftProvider;
+import net.fabricmc.loom.extension.LoomFiles;
+
+public abstract class DependencyProvider {
+	private final Project project;
+	private final LoomGradleExtension extension;
+
+	public DependencyProvider(Project project) {
+		this.project = project;
+		this.extension = LoomGradleExtension.get(project);
+	}
+
+	public abstract void provide(DependencyInfo dependency, Consumer<Runnable> postPopulationScheduler) throws Exception;
+
+	public abstract String getTargetConfig();
+
+	public Dependency addDependency(Object object, String target) {
+		return addDependency(project, object, target);
+	}
+
+	static Dependency addDependency(Project project, Object object, String target) {
+		if (object instanceof File) {
+			object = project.files(object);
+		}
+
+		return project.getDependencies().add(target, object);
+	}
+
+	public Project getProject() {
+		return project;
+	}
+
+	public LoomGradleExtension getExtension() {
+		return extension;
+	}
+
+	public LoomFiles getDirectories() {
+		return getExtension().getFiles();
+	}
+
+	public MinecraftProvider getMinecraftProvider() {
+		return getExtension().getMinecraftProvider();
+	}
+
+	public boolean isRefreshDeps() {
+		return LoomGradlePlugin.refreshDeps;
+	}
+}

src/main/java/net/fabricmc/loom/configuration/providers/forge/DependencyProviders.java

@@ -0,0 +1,97 @@
+package net.fabricmc.loom.configuration.providers.forge;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.Dependency;
+import org.gradle.api.artifacts.DependencySet;
+
+import net.fabricmc.loom.configuration.DependencyInfo;
+
+public class DependencyProviders {
+	private static class ProviderList {
+		private final String key;
+		private final List<DependencyProvider> providers = new ArrayList<>();
+
+		ProviderList(String key) {
+			this.key = key;
+		}
+	}
+
+	private final List<DependencyProvider> dependencyProviderList = new ArrayList<>();
+
+	public <T extends DependencyProvider> T addProvider(T provider) {
+		if (dependencyProviderList.contains(provider)) {
+			throw new RuntimeException("Provider is already registered");
+		}
+
+		if (getProvider(provider.getClass()) != null) {
+			throw new RuntimeException("Provider of this type is already registered");
+		}
+
+		dependencyProviderList.add(provider);
+		return provider;
+	}
+
+	public <T> T getProvider(Class<T> clazz) {
+		for (DependencyProvider provider : dependencyProviderList) {
+			if (provider.getClass() == clazz) {
+				return (T) provider;
+			}
+		}
+
+		return null;
+	}
+
+	public void handleDependencies(Project project) {
+		List<Runnable> afterTasks = new ArrayList<>();
+
+		project.getLogger().info(":setting up loom dependencies");
+		Map<String, ProviderList> providerListMap = new HashMap<>();
+		List<ProviderList> targetProviders = new ArrayList<>();
+
+		for (DependencyProvider provider : dependencyProviderList) {
+			providerListMap.computeIfAbsent(provider.getTargetConfig(), (k) -> {
+				ProviderList list = new ProviderList(k);
+				targetProviders.add(list);
+				return list;
+			}).providers.add(provider);
+		}
+
+		for (ProviderList list : targetProviders) {
+			Configuration configuration = project.getConfigurations().getByName(list.key);
+			DependencySet dependencies = configuration.getDependencies();
+
+			if (dependencies.isEmpty()) {
+				throw new IllegalArgumentException(String.format("No '%s' dependency was specified!", list.key));
+			}
+
+			if (dependencies.size() > 1) {
+				throw new IllegalArgumentException(String.format("Only one '%s' dependency should be specified, but %d were!",
+						list.key,
+						dependencies.size())
+				);
+			}
+
+			for (Dependency dependency : dependencies) {
+				for (DependencyProvider provider : list.providers) {
+					DependencyInfo info = DependencyInfo.create(project, dependency, configuration);
+
+					try {
+						provider.provide(info, afterTasks::add);
+					} catch (Exception e) {
+						throw new RuntimeException("Failed to provide " + dependency.getGroup() + ":" + dependency.getName() + ":" + dependency.getVersion() + " : " + e.toString(), e);
+					}
+				}
+			}
+		}
+
+		for (Runnable runnable : afterTasks) {
+			runnable.run();
+		}
+	}
+}

src/main/java/net/fabricmc/loom/configuration/providers/forge/ForgeProvider.java

@@ -29,7 +29,7 @@ import java.util.function.Consumer;
 
 import org.gradle.api.Project;
 
-import net.fabricmc.loom.configuration.DependencyProvider;
+import net.fabricmc.loom.configuration.DependencyInfo;
 import net.fabricmc.loom.util.Constants;
 
 public class ForgeProvider extends DependencyProvider {

src/main/java/net/fabricmc/loom/configuration/providers/forge/ForgeUniversalProvider.java

@@ -30,7 +30,7 @@ import java.util.function.Consumer;
 import org.apache.commons.io.FileUtils;
 import org.gradle.api.Project;
 
-import net.fabricmc.loom.configuration.DependencyProvider;
+import net.fabricmc.loom.configuration.DependencyInfo;
 import net.fabricmc.loom.util.Constants;
 
 public class ForgeUniversalProvider extends DependencyProvider {

src/main/java/net/fabricmc/loom/configuration/providers/forge/ForgeUserdevProvider.java

@@ -60,7 +60,7 @@ import org.gradle.api.file.FileSystemLocation;
 import org.gradle.api.provider.Provider;
 
 import net.fabricmc.loom.api.ForgeLocalMod;
-import net.fabricmc.loom.configuration.DependencyProvider;
+import net.fabricmc.loom.configuration.DependencyInfo;
 import net.fabricmc.loom.configuration.ide.RunConfigSettings;
 import net.fabricmc.loom.configuration.launch.LaunchProviderSettings;
 import net.fabricmc.loom.util.Constants;

src/main/java/net/fabricmc/loom/configuration/providers/forge/McpConfigProvider.java

@@ -45,7 +45,7 @@ import com.google.gson.JsonObject;
 import org.gradle.api.Project;
 import org.gradle.api.file.FileCollection;
 
-import net.fabricmc.loom.configuration.DependencyProvider;
+import net.fabricmc.loom.configuration.DependencyInfo;
 import net.fabricmc.loom.util.Constants;
 import net.fabricmc.loom.util.DependencyDownloader;
 import net.fabricmc.loom.util.ZipUtils;

src/main/java/net/fabricmc/loom/configuration/providers/forge/MinecraftPatchedProvider2.java

@@ -0,0 +1,778 @@
+package net.fabricmc.loom.configuration.providers.forge;
+
+import java.io.ByteArrayInputStream;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.io.UncheckedIOException;
+import java.net.URI;
+import java.nio.file.FileSystem;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.jar.Attributes;
+import java.util.jar.Manifest;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.hash.Hashing;
+import com.google.common.io.ByteSource;
+import de.oceanlabs.mcp.mcinjector.adaptors.ParameterAnnotationFixer;
+import dev.architectury.tinyremapper.InputTag;
+import dev.architectury.tinyremapper.OutputConsumerPath;
+import dev.architectury.tinyremapper.TinyRemapper;
+import net.minecraftforge.binarypatcher.ConsoleTool;
+import org.apache.commons.io.output.NullOutputStream;
+import org.gradle.api.Project;
+import org.gradle.api.file.ConfigurableFileCollection;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.logging.LogLevel;
+import org.gradle.api.logging.Logger;
+import org.gradle.api.logging.configuration.ShowStacktrace;
+import org.gradle.api.plugins.JavaPluginConvention;
+import org.gradle.api.tasks.SourceSet;
+import org.jetbrains.annotations.Nullable;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.ClassNode;
+
+import net.fabricmc.loom.LoomGradleExtension;
+import net.fabricmc.loom.configuration.providers.minecraft.MergedMinecraftProvider;
+import net.fabricmc.loom.util.Constants;
+import net.fabricmc.loom.util.DependencyDownloader;
+import net.fabricmc.loom.util.FileSystemUtil;
+import net.fabricmc.loom.util.FunnyTodoException;
+import net.fabricmc.loom.util.MappingsProviderVerbose;
+import net.fabricmc.loom.util.ThreadingUtils;
+import net.fabricmc.loom.util.TinyRemapperHelper;
+import net.fabricmc.loom.util.ZipUtils;
+import net.fabricmc.loom.util.function.FsPathConsumer;
+import net.fabricmc.loom.util.srg.InnerClassRemapper;
+import net.fabricmc.loom.util.srg.SpecialSourceExecutor;
+import net.fabricmc.mappingio.tree.MemoryMappingTree;
+
+public class MinecraftPatchedProvider2 extends MergedMinecraftProvider {
+	private static final String LOOM_PATCH_VERSION_KEY = "Loom-Patch-Version";
+	private static final String CURRENT_LOOM_PATCH_VERSION = "5";
+	private static final String NAME_MAPPING_SERVICE_PATH = "/inject/META-INF/services/cpw.mods.modlauncher.api.INameMappingService";
+
+	// Step 1: Remap Minecraft to SRG (global)
+	private File minecraftClientSrgJar;
+	private File minecraftServerSrgJar;
+	// Step 2: Binary Patch (global)
+	private File minecraftClientPatchedSrgJar;
+	private File minecraftServerPatchedSrgJar;
+	// Step 3: Merge (global)
+	private File minecraftMergedPatchedSrgJar;
+	// Step 4: Access Transform (global or project)
+	private File minecraftMergedPatchedSrgAtJar;
+	// Step 5: Remap Patched AT & Forge to Official (global or project)
+	private File minecraftMergedPatchedJar;
+	@Nullable
+	private File forgeMergedJar;
+	private File minecraftClientExtra;
+
+	private boolean dirty;
+	private File projectAtHash;
+	private Set<File> projectAts = new HashSet<>();
+	private boolean atDirty = false;
+	private boolean filesDirty = false;
+
+	public static MergedMinecraftProvider getMergedMinecraftProvider(Project project) {
+		return LoomGradleExtension.get(project).isForge() ? new MinecraftPatchedProvider2(project) : new MergedMinecraftProvider(project);
+	}
+
+	public MinecraftPatchedProvider2(Project project) {
+		super(project);
+	}
+
+	@Override
+	protected void initFiles() {
+		super.initFiles();
+
+		PatchProvider patchProvider = getExtension().getPatchProvider();
+		String minecraftVersion = minecraftVersion();
+		String patchId = "forge-" + getExtension().getForgeProvider().getVersion().getCombined() + "-";
+
+		FunnyTodoException.yes("jar prefix");
+		//if (getExtension().isForgeAndOfficial()) {
+		//	minecraftProvider.setJarPrefix(patchId);
+		//}
+
+		File globalCache = getExtension().getForgeProvider().getGlobalCache();
+		File projectDir = usesProjectCache() ? getExtension().getForgeProvider().getProjectCache() : globalCache;
+		projectDir.mkdirs();
+
+		minecraftClientSrgJar = file("minecraft-client-srg.jar");
+		minecraftServerSrgJar = file("minecraft-server-srg.jar");
+		minecraftClientPatchedSrgJar = file("client-srg-patched.jar");
+		minecraftServerPatchedSrgJar = file("server-srg-patched.jar");
+		minecraftMergedPatchedSrgJar = file("merged-srg-patched.jar");
+		forgeMergedJar = getExtension().isForgeAndOfficial() ? null : file("forge-official.jar");
+		minecraftMergedPatchedSrgAtJar = file("merged-srg-at-patched.jar");
+		minecraftMergedPatchedJar = file("merged-patched.jar");
+		minecraftClientExtra = file("forge-client-extra.jar");
+	}
+
+	private byte[] getProjectAtsHash() throws IOException {
+		if (projectAts.isEmpty()) return ByteSource.empty().hash(Hashing.sha256()).asBytes();
+		List<ByteSource> currentBytes = new ArrayList<>();
+
+		for (File projectAt : projectAts) {
+			currentBytes.add(com.google.common.io.Files.asByteSource(projectAt));
+		}
+
+		return ByteSource.concat(currentBytes).hash(Hashing.sha256()).asBytes();
+	}
+
+	public void cleanAllCache() {
+		for (File file : getGlobalCaches()) {
+			file.delete();
+		}
+
+		cleanProjectCache();
+	}
+
+	private File[] getGlobalCaches() {
+		File[] files = {
+				minecraftClientSrgJar,
+				minecraftServerSrgJar,
+				minecraftClientPatchedSrgJar,
+				minecraftServerPatchedSrgJar,
+				minecraftMergedPatchedSrgJar,
+				minecraftClientExtra,
+		};
+
+		if (forgeMergedJar != null) {
+			Arrays.copyOf(files, files.length + 1);
+			files[files.length - 1] = forgeMergedJar;
+		}
+
+		return files;
+	}
+
+	public void cleanProjectCache() {
+		for (File file : getProjectCache()) {
+			file.delete();
+		}
+	}
+
+	private File[] getProjectCache() {
+		return new File[] {
+				minecraftMergedPatchedSrgAtJar,
+				minecraftMergedPatchedJar
+		};
+	}
+
+	private void checkAtAndCache() throws IOException {
+		filesDirty = false;
+		projectAtHash = new File(getExtension().getFiles().getProjectPersistentCache(), "at.sha256");
+		ConfigurableFileCollection accessTransformers = getExtension().getForge().getAccessTransformers();
+		accessTransformers.finalizeValue();
+		projectAts = accessTransformers.getFiles();
+
+		if (projectAts.isEmpty()) {
+			SourceSet main = getProject().getConvention().findPlugin(JavaPluginConvention.class).getSourceSets().getByName("main");
+
+			for (File srcDir : main.getResources().getSrcDirs()) {
+				File projectAt = new File(srcDir, Constants.Forge.ACCESS_TRANSFORMER_PATH);
+
+				if (projectAt.exists()) {
+					this.projectAts.add(projectAt);
+					break;
+				}
+			}
+		}
+
+		if (isRefreshDeps() || !projectAtHash.exists()) {
+			writeAtHash();
+			atDirty = !projectAts.isEmpty();
+		} else {
+			byte[] expected = com.google.common.io.Files.asByteSource(projectAtHash).read();
+			byte[] current = getProjectAtsHash();
+			boolean mismatched = !Arrays.equals(current, expected);
+
+			if (mismatched) {
+				writeAtHash();
+			}
+
+			atDirty = mismatched;
+		}
+
+		if (isRefreshDeps() || Stream.of(getGlobalCaches()).anyMatch(((Predicate<File>) File::exists).negate())
+				|| !isPatchedJarUpToDate(minecraftMergedPatchedJar)) {
+			cleanAllCache();
+		} else if (atDirty || Stream.of(getProjectCache()).anyMatch(((Predicate<File>) File::exists).negate())) {
+			cleanProjectCache();
+		}
+	}
+
+	@Override
+	public void provide() throws Exception {
+		super.provide();
+
+		this.dirty = false;
+
+		if (!minecraftClientSrgJar.exists() || !minecraftServerSrgJar.exists()) {
+			this.dirty = true;
+			// Remap official jars to MCPConfig remapped srg jars
+			createSrgJars(getProject().getLogger());
+		}
+
+		if (!minecraftClientPatchedSrgJar.exists() || !minecraftServerPatchedSrgJar.exists()) {
+			this.dirty = true;
+			patchJars(getProject().getLogger());
+		}
+
+		if (dirty || !minecraftMergedPatchedSrgJar.exists()) {
+			mergeJars(getProject().getLogger());
+		}
+
+		if (atDirty || !minecraftMergedPatchedSrgAtJar.exists()) {
+			this.dirty = true;
+			accessTransformForge(getProject().getLogger());
+		}
+
+		if (forgeMergedJar != null && !forgeMergedJar.exists()) {
+			this.dirty = true;
+		}
+
+		if (dirty) {
+			remapPatchedJar(getProject().getLogger());
+
+			if (getExtension().isForgeAndOfficial()) {
+				fillClientExtraJar();
+			}
+		}
+
+		this.filesDirty = dirty;
+		this.dirty = false;
+
+		if (getExtension().isForgeAndOfficial()) {
+			DependencyProvider.addDependency(getProject(), minecraftClientExtra, Constants.Configurations.FORGE_EXTRA);
+		}
+	}
+
+	@Override
+	protected void mergeJars() throws IOException {
+		// Don't merge jars in the superclass
+	}
+
+	private void fillClientExtraJar() throws IOException {
+		Files.deleteIfExists(minecraftClientExtra.toPath());
+		FileSystemUtil.getJarFileSystem(minecraftClientExtra, true).close();
+
+		copyNonClassFiles(getMinecraftClientJar(), minecraftClientExtra);
+	}
+
+	private TinyRemapper buildRemapper(Path input) throws IOException {
+		Path[] libraries = TinyRemapperHelper.getMinecraftDependencies(getProject());
+		MemoryMappingTree mappingsWithSrg = getExtension().getMappingsProvider().getMappingsWithSrg();
+
+		TinyRemapper remapper = TinyRemapper.newRemapper()
+				.logger(getProject().getLogger()::lifecycle)
+				.logUnknownInvokeDynamic(false)
+				.withMappings(TinyRemapperHelper.create(mappingsWithSrg, "srg", "official", true))
+				.withMappings(InnerClassRemapper.of(InnerClassRemapper.readClassNames(input), mappingsWithSrg, "srg", "official"))
+				.renameInvalidLocals(true)
+				.rebuildSourceFilenames(true)
+				.fixPackageAccess(true)
+				.build();
+
+		if (getProject().getGradle().getStartParameter().getLogLevel().compareTo(LogLevel.LIFECYCLE) < 0) {
+			MappingsProviderVerbose.saveFile(remapper);
+		}
+
+		remapper.readClassPath(libraries);
+		remapper.prepareClasses();
+		return remapper;
+	}
+
+	private void writeAtHash() throws IOException {
+		try (FileOutputStream out = new FileOutputStream(projectAtHash)) {
+			out.write(getProjectAtsHash());
+		}
+	}
+
+	private void createSrgJars(Logger logger) throws Exception {
+		produceSrgJar(getExtension().isForgeAndOfficial(), super.getMinecraftClientJar().toPath(), MoreObjects.firstNonNull(super.getMinecraftExtractedServerJar(), super.getMinecraftServerJar()).toPath());
+	}
+
+	private void produceSrgJar(boolean official, Path clientJar, Path serverJar) throws IOException {
+		Path tmpSrg = getToSrgMappings();
+		Set<File> mcLibs = getProject().getConfigurations().getByName(Constants.Configurations.MINECRAFT_DEPENDENCIES).resolve();
+
+		ThreadingUtils.run(() -> {
+			Files.copy(SpecialSourceExecutor.produceSrgJar(getExtension().getMcpConfigProvider().getRemapAction(), getProject(), "client", mcLibs, clientJar, tmpSrg), minecraftClientSrgJar.toPath());
+		}, () -> {
+			Files.copy(SpecialSourceExecutor.produceSrgJar(getExtension().getMcpConfigProvider().getRemapAction(), getProject(), "server", mcLibs, serverJar, tmpSrg), minecraftServerSrgJar.toPath());
+		});
+	}
+
+	private Path getToSrgMappings() throws IOException {
+		if (getExtension().getSrgProvider().isTsrgV2()) {
+			return getExtension().getSrgProvider().getMergedMojangRaw();
+		} else {
+			return getExtension().getMcpConfigProvider().getMappings();
+		}
+	}
+
+	private void fixParameterAnnotation(File jarFile) throws Exception {
+		getProject().getLogger().info(":fixing parameter annotations for " + jarFile.getAbsolutePath());
+		Stopwatch stopwatch = Stopwatch.createStarted();
+
+		try (FileSystem fs = FileSystems.newFileSystem(new URI("jar:" + jarFile.toURI()), ImmutableMap.of("create", false))) {
+			ThreadingUtils.TaskCompleter completer = ThreadingUtils.taskCompleter();
+
+			for (Path file : (Iterable<? extends Path>) Files.walk(fs.getPath("/"))::iterator) {
+				if (!file.toString().endsWith(".class")) continue;
+
+				completer.add(() -> {
+					byte[] bytes = Files.readAllBytes(file);
+					ClassReader reader = new ClassReader(bytes);
+					ClassNode node = new ClassNode();
+					ClassVisitor visitor = new ParameterAnnotationFixer(node, null);
+					reader.accept(visitor, 0);
+
+					ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+					node.accept(writer);
+					byte[] out = writer.toByteArray();
+
+					if (!Arrays.equals(bytes, out)) {
+						Files.delete(file);
+						Files.write(file, out);
+					}
+				});
+			}
+
+			completer.complete();
+		}
+
+		getProject().getLogger().info(":fixing parameter annotations for " + jarFile.getAbsolutePath() + " in " + stopwatch);
+	}
+
+	private void deleteParameterNames(File jarFile) throws Exception {
+		getProject().getLogger().info(":deleting parameter names for " + jarFile.getAbsolutePath());
+		Stopwatch stopwatch = Stopwatch.createStarted();
+
+		try (FileSystem fs = FileSystems.newFileSystem(new URI("jar:" + jarFile.toURI()), ImmutableMap.of("create", false))) {
+			ThreadingUtils.TaskCompleter completer = ThreadingUtils.taskCompleter();
+			Pattern vignetteParameters = Pattern.compile("p_[0-9a-zA-Z]+_(?:[0-9a-zA-Z]+_)?");
+
+			for (Path file : (Iterable<? extends Path>) Files.walk(fs.getPath("/"))::iterator) {
+				if (!file.toString().endsWith(".class")) continue;
+
+				completer.add(() -> {
+					byte[] bytes = Files.readAllBytes(file);
+					ClassReader reader = new ClassReader(bytes);
+					ClassWriter writer = new ClassWriter(0);
+
+					reader.accept(new ClassVisitor(Opcodes.ASM9, writer) {
+						@Override
+						public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
+							return new MethodVisitor(Opcodes.ASM9, super.visitMethod(access, name, descriptor, signature, exceptions)) {
+								@Override
+								public void visitParameter(String name, int access) {
+									if (vignetteParameters.matcher(name).matches()) {
+										super.visitParameter(null, access);
+									} else {
+										super.visitParameter(name, access);
+									}
+								}
+
+								@Override
+								public void visitLocalVariable(String name, String descriptor, String signature, Label start, Label end, int index) {
+									if (!vignetteParameters.matcher(name).matches()) {
+										super.visitLocalVariable(name, descriptor, signature, start, end, index);
+									}
+								}
+							};
+						}
+					}, 0);
+
+					byte[] out = writer.toByteArray();
+
+					if (!Arrays.equals(bytes, out)) {
+						Files.delete(file);
+						Files.write(file, out);
+					}
+				});
+			}
+
+			completer.complete();
+		}
+
+		getProject().getLogger().info(":deleting parameter names for " + jarFile.getAbsolutePath() + " in " + stopwatch);
+	}
+
+	private File getForgeJar() {
+		return getExtension().getForgeUniversalProvider().getForge();
+	}
+
+	private File getForgeUserdevJar() {
+		return getExtension().getForgeUserdevProvider().getUserdevJar();
+	}
+
+	private boolean isPatchedJarUpToDate(File jar) throws IOException {
+		if (!jar.exists()) return false;
+
+		byte[] manifestBytes = ZipUtils.unpackNullable(jar.toPath(), "META-INF/MANIFEST.MF");
+
+		if (manifestBytes == null) {
+			return false;
+		}
+
+		Manifest manifest = new Manifest(new ByteArrayInputStream(manifestBytes));
+		Attributes attributes = manifest.getMainAttributes();
+		String value = attributes.getValue(LOOM_PATCH_VERSION_KEY);
+
+		if (Objects.equals(value, CURRENT_LOOM_PATCH_VERSION)) {
+			return true;
+		} else {
+			getProject().getLogger().lifecycle(":forge patched jars not up to date. current version: " + value);
+			return false;
+		}
+	}
+
+	private void accessTransformForge(Logger logger) throws Exception {
+		List<File> toDelete = new ArrayList<>();
+		String atDependency = Constants.Dependencies.ACCESS_TRANSFORMERS + (getServerBundleMetadata() != null ? Constants.Dependencies.Versions.ACCESS_TRANSFORMERS_NEW : Constants.Dependencies.Versions.ACCESS_TRANSFORMERS);
+		FileCollection classpath = DependencyDownloader.download(getProject(), atDependency);
+		Stopwatch stopwatch = Stopwatch.createStarted();
+
+		logger.lifecycle(":access transforming minecraft");
+
+		File input = minecraftMergedPatchedSrgJar;
+		File target = minecraftMergedPatchedSrgAtJar;
+		Files.deleteIfExists(target.toPath());
+
+		List<String> args = new ArrayList<>();
+		args.add("--inJar");
+		args.add(input.getAbsolutePath());
+		args.add("--outJar");
+		args.add(target.getAbsolutePath());
+
+		for (File jar : ImmutableList.of(getForgeJar(), getForgeUserdevJar(), minecraftMergedPatchedSrgJar)) {
+			byte[] atBytes = ZipUtils.unpackNullable(jar.toPath(), Constants.Forge.ACCESS_TRANSFORMER_PATH);
+
+			if (atBytes != null) {
+				File tmpFile = File.createTempFile("at-conf", ".cfg");
+				toDelete.add(tmpFile);
+				Files.write(tmpFile.toPath(), atBytes, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
+				args.add("--atFile");
+				args.add(tmpFile.getAbsolutePath());
+			}
+		}
+
+		if (usesProjectCache()) {
+			for (File projectAt : projectAts) {
+				args.add("--atFile");
+				args.add(projectAt.getAbsolutePath());
+			}
+		}
+
+		getProject().javaexec(spec -> {
+			spec.getMainClass().set("net.minecraftforge.accesstransformer.TransformerProcessor");
+			spec.setArgs(args);
+			spec.setClasspath(classpath);
+
+			// if running with INFO or DEBUG logging
+			if (getProject().getGradle().getStartParameter().getShowStacktrace() != ShowStacktrace.INTERNAL_EXCEPTIONS
+					|| getProject().getGradle().getStartParameter().getLogLevel().compareTo(LogLevel.LIFECYCLE) < 0) {
+				spec.setStandardOutput(System.out);
+				spec.setErrorOutput(System.err);
+			} else {
+				spec.setStandardOutput(NullOutputStream.NULL_OUTPUT_STREAM);
+				spec.setErrorOutput(NullOutputStream.NULL_OUTPUT_STREAM);
+			}
+		}).rethrowFailure().assertNormalExitValue();
+
+		for (File file : toDelete) {
+			file.delete();
+		}
+
+		logger.lifecycle(":access transformed minecraft in " + stopwatch.stop());
+	}
+
+	public enum Environment {
+		CLIENT(provider -> provider.minecraftClientSrgJar,
+				provider -> provider.minecraftClientPatchedSrgJar
+		),
+		SERVER(provider -> provider.minecraftServerSrgJar,
+				provider -> provider.minecraftServerPatchedSrgJar
+		);
+
+		final Function<MinecraftPatchedProvider2, File> srgJar;
+		final Function<MinecraftPatchedProvider2, File> patchedSrgJar;
+
+		Environment(Function<MinecraftPatchedProvider2, File> srgJar,
+					Function<MinecraftPatchedProvider2, File> patchedSrgJar) {
+			this.srgJar = srgJar;
+			this.patchedSrgJar = patchedSrgJar;
+		}
+
+		public String side() {
+			return name().toLowerCase(Locale.ROOT);
+		}
+	}
+
+	private void remapPatchedJar(Logger logger) throws Exception {
+		getProject().getLogger().lifecycle(":remapping minecraft (TinyRemapper, srg -> official)");
+		Path mcInput = minecraftMergedPatchedSrgAtJar.toPath();
+		Path mcOutput = minecraftMergedPatchedJar.toPath();
+		Path forgeJar = getForgeJar().toPath();
+		Path forgeUserdevJar = getForgeUserdevJar().toPath();
+		Path forgeOutput = null;
+		Files.deleteIfExists(mcOutput);
+		boolean splitJars = forgeMergedJar != null;
+
+		if (splitJars) {
+			forgeOutput = forgeMergedJar.toPath();
+			Files.deleteIfExists(forgeOutput);
+		}
+
+		TinyRemapper remapper = buildRemapper(mcInput);
+
+		try (OutputConsumerPath outputConsumer = new OutputConsumerPath.Builder(mcOutput).build();
+				Closeable outputConsumerForge = !splitJars ? () -> {
+				} : new OutputConsumerPath.Builder(forgeOutput).build()) {
+			outputConsumer.addNonClassFiles(mcInput);
+
+			InputTag mcTag = remapper.createInputTag();
+			InputTag forgeTag = remapper.createInputTag();
+			List<CompletableFuture<?>> futures = new ArrayList<>();
+			futures.add(remapper.readInputsAsync(mcTag, mcInput));
+			futures.add(remapper.readInputsAsync(forgeTag, forgeJar, forgeUserdevJar));
+			CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
+			remapper.apply(outputConsumer, mcTag);
+			remapper.apply(splitJars ? (OutputConsumerPath) outputConsumerForge : outputConsumer, forgeTag);
+		} finally {
+			remapper.finish();
+		}
+
+		copyNonClassFiles(forgeJar.toFile(), splitJars ? forgeMergedJar : minecraftMergedPatchedJar);
+		copyUserdevFiles(forgeUserdevJar.toFile(), splitJars ? forgeMergedJar : minecraftMergedPatchedJar);
+		applyLoomPatchVersion(mcOutput);
+	}
+
+	private void patchJars(Logger logger) throws IOException {
+		Stopwatch stopwatch = Stopwatch.createStarted();
+		logger.lifecycle(":patching jars");
+
+		PatchProvider patchProvider = getExtension().getPatchProvider();
+		patchJars(minecraftClientSrgJar, minecraftClientPatchedSrgJar, patchProvider.clientPatches);
+		patchJars(minecraftServerSrgJar, minecraftServerPatchedSrgJar, patchProvider.serverPatches);
+
+		ThreadingUtils.run(MinecraftPatchedProvider2.Environment.values(), environment -> {
+			copyMissingClasses(environment.srgJar.apply(this), environment.patchedSrgJar.apply(this));
+			deleteParameterNames(environment.patchedSrgJar.apply(this));
+
+			if (getExtension().isForgeAndNotOfficial()) {
+				fixParameterAnnotation(environment.patchedSrgJar.apply(this));
+			}
+		});
+
+		logger.lifecycle(":patched jars in " + stopwatch.stop());
+	}
+
+	private void patchJars(File clean, File output, Path patches) throws IOException {
+		PrintStream previous = System.out;
+
+		try {
+			System.setOut(new PrintStream(NullOutputStream.NULL_OUTPUT_STREAM));
+		} catch (SecurityException ignored) {
+			// Failed to replace logger filter, just ignore
+		}
+
+		ConsoleTool.main(new String[] {
+				"--clean", clean.getAbsolutePath(),
+				"--output", output.getAbsolutePath(),
+				"--apply", patches.toAbsolutePath().toString()
+		});
+
+		try {
+			System.setOut(previous);
+		} catch (SecurityException ignored) {
+			// Failed to replace logger filter, just ignore
+		}
+	}
+
+	private void mergeJars(Logger logger) throws IOException {
+		// FIXME: Hack here: There are no server-only classes so we can just copy the client JAR.
+		//   This will change if upstream Loom adds the possibility for separate projects/source sets per environment.
+		Files.copy(minecraftClientPatchedSrgJar.toPath(), minecraftMergedPatchedSrgJar.toPath());
+
+		logger.lifecycle(":copying resources");
+
+		// Copy resources
+		if (getExtension().isForgeAndNotOfficial()) {
+			// Copy resources
+			copyNonClassFiles(super.getMinecraftClientJar(), minecraftMergedPatchedSrgJar);
+			copyNonClassFiles(MoreObjects.firstNonNull(super.getMinecraftExtractedServerJar(), super.getMinecraftServerJar()), minecraftMergedPatchedSrgJar);
+		}
+	}
+
+	private void walkFileSystems(File source, File target, Predicate<Path> filter, Function<FileSystem, Iterable<Path>> toWalk, FsPathConsumer action)
+			throws IOException {
+		try (FileSystemUtil.Delegate sourceFs = FileSystemUtil.getJarFileSystem(source, false);
+				FileSystemUtil.Delegate targetFs = FileSystemUtil.getJarFileSystem(target, false)) {
+			for (Path sourceDir : toWalk.apply(sourceFs.get())) {
+				Path dir = sourceDir.toAbsolutePath();
+				if (!Files.exists(dir)) continue;
+				Files.walk(dir)
+						.filter(Files::isRegularFile)
+						.filter(filter)
+						.forEach(it -> {
+							boolean root = dir.getParent() == null;
+
+							try {
+								Path relativeSource = root ? it : dir.relativize(it);
+								Path targetPath = targetFs.get().getPath(relativeSource.toString());
+								action.accept(sourceFs.get(), targetFs.get(), it, targetPath);
+							} catch (IOException e) {
+								throw new UncheckedIOException(e);
+							}
+						});
+			}
+		}
+	}
+
+	private void walkFileSystems(File source, File target, Predicate<Path> filter, FsPathConsumer action) throws IOException {
+		walkFileSystems(source, target, filter, FileSystem::getRootDirectories, action);
+	}
+
+	private void copyAll(File source, File target) throws IOException {
+		walkFileSystems(source, target, it -> true, this::copyReplacing);
+	}
+
+	private void copyMissingClasses(File source, File target) throws IOException {
+		walkFileSystems(source, target, it -> it.toString().endsWith(".class"), (sourceFs, targetFs, sourcePath, targetPath) -> {
+			if (Files.exists(targetPath)) return;
+			Path parent = targetPath.getParent();
+
+			if (parent != null) {
+				Files.createDirectories(parent);
+			}
+
+			Files.copy(sourcePath, targetPath);
+		});
+	}
+
+	private void copyNonClassFiles(File source, File target) throws IOException {
+		Predicate<Path> filter = getExtension().isForgeAndOfficial() ? file -> {
+			String s = file.toString();
+			return !s.endsWith(".class");
+		} : file -> {
+			String s = file.toString();
+			return !s.endsWith(".class") || (s.startsWith("META-INF") && !s.startsWith("META-INF/services"));
+		};
+
+		walkFileSystems(source, target, filter, this::copyReplacing);
+	}
+
+	private void copyReplacing(FileSystem sourceFs, FileSystem targetFs, Path sourcePath, Path targetPath) throws IOException {
+		Path parent = targetPath.getParent();
+
+		if (parent != null) {
+			Files.createDirectories(parent);
+		}
+
+		Files.copy(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);
+	}
+
+	private void copyUserdevFiles(File source, File target) throws IOException {
+		// Removes the Forge name mapping service definition so that our own is used.
+		// If there are multiple name mapping services with the same "understanding" pair
+		// (source -> target namespace pair), modlauncher throws a fit and will crash.
+		// To use our YarnNamingService instead of MCPNamingService, we have to remove this file.
+		Predicate<Path> filter = file -> !file.toString().endsWith(".class") && !file.toString().equals(NAME_MAPPING_SERVICE_PATH);
+
+		walkFileSystems(source, target, filter, fs -> Collections.singleton(fs.getPath("inject")), (sourceFs, targetFs, sourcePath, targetPath) -> {
+			Path parent = targetPath.getParent();
+
+			if (parent != null) {
+				Files.createDirectories(parent);
+			}
+
+			Files.copy(sourcePath, targetPath);
+		});
+	}
+
+	public void applyLoomPatchVersion(Path target) throws IOException {
+		try (FileSystemUtil.Delegate delegate = FileSystemUtil.getJarFileSystem(target, false)) {
+			Path manifestPath = delegate.get().getPath("META-INF/MANIFEST.MF");
+
+			Preconditions.checkArgument(Files.exists(manifestPath), "META-INF/MANIFEST.MF does not exist in patched srg jar!");
+			Manifest manifest = new Manifest();
+
+			if (Files.exists(manifestPath)) {
+				try (InputStream stream = Files.newInputStream(manifestPath)) {
+					manifest.read(stream);
+					manifest.getMainAttributes().putValue(LOOM_PATCH_VERSION_KEY, CURRENT_LOOM_PATCH_VERSION);
+				}
+			}
+
+			try (OutputStream stream = Files.newOutputStream(manifestPath, StandardOpenOption.CREATE)) {
+				manifest.write(stream);
+			}
+		}
+	}
+
+	@Override
+	public Path getMergedJar() {
+		return minecraftMergedPatchedJar.toPath();
+	}
+
+	public File getForgeMergedJar() {
+		return forgeMergedJar;
+	}
+
+	public boolean usesProjectCache() {
+		if (!projectAts.isEmpty()) FunnyTodoException.yes("project ATs");
+		return false;
+	}
+
+	public boolean isAtDirty() {
+		return atDirty || filesDirty;
+	}
+
+	@Override
+	public String getTargetConfig() {
+		return Constants.Configurations.MINECRAFT;
+	}
+
+	@Override
+	public List<Path> getMinecraftJars() {
+		if (forgeMergedJar != null) {
+			return List.of(minecraftMergedPatchedJar.toPath(), forgeMergedJar.toPath());
+		} else {
+			return List.of(minecraftMergedPatchedJar.toPath());
+		}
+	}
+}

src/main/java/net/fabricmc/loom/configuration/providers/forge/PatchProvider.java

@@ -37,7 +37,7 @@ import java.util.function.Consumer;
 import com.google.common.collect.ImmutableMap;
 import org.gradle.api.Project;
 
-import net.fabricmc.loom.configuration.DependencyProvider;
+import net.fabricmc.loom.configuration.DependencyInfo;
 import net.fabricmc.loom.util.Constants;
 
 public class PatchProvider extends DependencyProvider {

src/main/java/net/fabricmc/loom/configuration/providers/forge/SrgProvider.java

@@ -53,7 +53,7 @@ import org.gradle.api.logging.LogLevel;
 import net.fabricmc.loom.LoomGradleExtension;
 import net.fabricmc.loom.LoomGradlePlugin;
 import net.fabricmc.loom.api.mappings.layered.MappingsNamespace;
-import net.fabricmc.loom.configuration.DependencyProvider;
+import net.fabricmc.loom.configuration.DependencyInfo;
 import net.fabricmc.loom.configuration.providers.mappings.GradleMappingContext;
 import net.fabricmc.loom.configuration.providers.mappings.mojmap.MojangMappingLayer;
 import net.fabricmc.loom.configuration.providers.mappings.mojmap.MojangMappingsSpec;

src/main/java/net/fabricmc/loom/configuration/providers/minecraft/MergedMinecraftProvider.java

@@ -36,8 +36,8 @@ import org.gradle.api.Project;
 import net.fabricmc.loom.util.HashedDownloadUtil;
 import net.fabricmc.stitch.merge.JarMerger;
 
-public final class MergedMinecraftProvider extends MinecraftProvider {
-	private Path minecraftMergedJar;
+public class MergedMinecraftProvider extends MinecraftProvider {
+	protected Path minecraftMergedJar;
 
 	public MergedMinecraftProvider(Project project) {
 		super(project);
@@ -72,7 +72,7 @@ public final class MergedMinecraftProvider extends MinecraftProvider {
 		}
 	}
 
-	private void mergeJars() throws IOException {
+	protected void mergeJars() throws IOException {
 		getLogger().info(":merging jars");
 
 		File jarToMerge = getMinecraftServerJar();

src/main/java/net/fabricmc/loom/configuration/providers/minecraft/MinecraftJarConfiguration.java

@@ -34,6 +34,7 @@ import net.fabricmc.loom.configuration.decompile.DecompileConfiguration;
 import net.fabricmc.loom.configuration.decompile.SingleJarDecompileConfiguration;
 import net.fabricmc.loom.configuration.decompile.SplitDecompileConfiguration;
 import net.fabricmc.loom.configuration.processors.JarProcessorManager;
+import net.fabricmc.loom.configuration.providers.forge.MinecraftPatchedProvider2;
 import net.fabricmc.loom.configuration.providers.minecraft.mapped.IntermediaryMinecraftProvider;
 import net.fabricmc.loom.configuration.providers.minecraft.mapped.MappedMinecraftProvider;
 import net.fabricmc.loom.configuration.providers.minecraft.mapped.NamedMinecraftProvider;
@@ -41,7 +42,7 @@ import net.fabricmc.loom.configuration.providers.minecraft.mapped.ProcessedNamed
 
 public enum MinecraftJarConfiguration {
 	MERGED(
-		MergedMinecraftProvider::new,
+		MinecraftPatchedProvider2::getMergedMinecraftProvider,
 		IntermediaryMinecraftProvider.MergedImpl::new,
 		NamedMinecraftProvider.MergedImpl::new,
 		ProcessedNamedMinecraftProvider.MergedImpl::new,

src/main/java/net/fabricmc/loom/configuration/providers/minecraft/ServerOnlyMinecraftProvider.java

@@ -28,12 +28,12 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.List;
 
+import dev.architectury.tinyremapper.NonClassCopyMode;
+import dev.architectury.tinyremapper.OutputConsumerPath;
+import dev.architectury.tinyremapper.TinyRemapper;
 import org.gradle.api.Project;
 
 import net.fabricmc.loom.configuration.providers.BundleMetadata;
-import net.fabricmc.tinyremapper.NonClassCopyMode;
-import net.fabricmc.tinyremapper.OutputConsumerPath;
-import net.fabricmc.tinyremapper.TinyRemapper;
 
 public final class ServerOnlyMinecraftProvider extends MinecraftProvider {
 	private Path minecraftServerOnlyJar;

src/main/java/net/fabricmc/loom/configuration/providers/minecraft/mapped/AbstractMappedMinecraftProvider.java

@@ -31,6 +31,8 @@ import java.util.List;
 import java.util.Map;
 import java.util.function.BiConsumer;
 
+import dev.architectury.tinyremapper.OutputConsumerPath;
+import dev.architectury.tinyremapper.TinyRemapper;
 import org.gradle.api.Project;
 
 import net.fabricmc.loom.LoomGradleExtension;
@@ -40,8 +42,6 @@ import net.fabricmc.loom.configuration.providers.mappings.MappingsProviderImpl;
 import net.fabricmc.loom.configuration.providers.minecraft.MinecraftProvider;
 import net.fabricmc.loom.configuration.providers.minecraft.SignatureFixerApplyVisitor;
 import net.fabricmc.loom.util.TinyRemapperHelper;
-import net.fabricmc.tinyremapper.OutputConsumerPath;
-import net.fabricmc.tinyremapper.TinyRemapper;
 
 public abstract class AbstractMappedMinecraftProvider<M extends MinecraftProvider> implements MappedMinecraftProvider.ProviderImpl {
 	protected final M minecraftProvider;

src/main/java/net/fabricmc/loom/configuration/providers/minecraft/mapped/IntermediaryMinecraftProvider.java

@@ -27,6 +27,7 @@ package net.fabricmc.loom.configuration.providers.minecraft.mapped;
 import java.nio.file.Path;
 import java.util.List;
 
+import dev.architectury.tinyremapper.TinyRemapper;
 import org.gradle.api.Project;
 
 import net.fabricmc.loom.api.mappings.layered.MappingsNamespace;
@@ -35,7 +36,6 @@ import net.fabricmc.loom.configuration.providers.minecraft.MinecraftProvider;
 import net.fabricmc.loom.configuration.providers.minecraft.ServerOnlyMinecraftProvider;
 import net.fabricmc.loom.configuration.providers.minecraft.SplitMinecraftProvider;
 import net.fabricmc.loom.util.SidedClassVisitor;
-import net.fabricmc.tinyremapper.TinyRemapper;
 
 public abstract sealed class IntermediaryMinecraftProvider<M extends MinecraftProvider> extends AbstractMappedMinecraftProvider<M> permits IntermediaryMinecraftProvider.MergedImpl, IntermediaryMinecraftProvider.ServerOnlyImpl, IntermediaryMinecraftProvider.SplitImpl {
 	public IntermediaryMinecraftProvider(Project project, M minecraftProvider) {

src/main/java/net/fabricmc/loom/configuration/providers/minecraft/mapped/NamedMinecraftProvider.java

@@ -28,6 +28,7 @@ import java.nio.file.Path;
 import java.util.List;
 import java.util.function.BiConsumer;
 
+import dev.architectury.tinyremapper.TinyRemapper;
 import org.gradle.api.Project;
 
 import net.fabricmc.loom.api.mappings.layered.MappingsNamespace;
@@ -37,7 +38,6 @@ import net.fabricmc.loom.configuration.providers.minecraft.ServerOnlyMinecraftPr
 import net.fabricmc.loom.configuration.providers.minecraft.SplitMinecraftProvider;
 import net.fabricmc.loom.util.Constants;
 import net.fabricmc.loom.util.SidedClassVisitor;
-import net.fabricmc.tinyremapper.TinyRemapper;
 
 public abstract class NamedMinecraftProvider<M extends MinecraftProvider> extends AbstractMappedMinecraftProvider<M> {
 	public NamedMinecraftProvider(Project project, M minecraftProvider) {

src/main/java/net/fabricmc/loom/extension/LoomGradleExtensionApiImpl.java

@@ -33,6 +33,7 @@ import java.util.function.Consumer;
 
 import com.google.common.base.Suppliers;
 import org.gradle.api.Action;
+import org.gradle.api.DomainObjectCollection;
 import org.gradle.api.NamedDomainObjectContainer;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Dependency;

src/main/java/net/fabricmc/loom/extension/LoomGradleExtensionImpl.java

@@ -33,6 +33,9 @@ import java.util.Objects;
 import java.util.function.Supplier;
 
 import com.google.common.base.Suppliers;
+
+import net.fabricmc.loom.configuration.providers.forge.DependencyProviders;
+
 import org.cadixdev.lorenz.MappingSet;
 import org.cadixdev.mercury.Mercury;
 import org.gradle.api.Action;
@@ -81,6 +84,7 @@ public class LoomGradleExtensionImpl extends LoomGradleExtensionApiImpl implemen
 	// +-------------------+
 	private static final String INCLUDE_PROPERTY = "loom.forge.include";
 	private final LazyBool supportsInclude;
+	private DependencyProviders dependencyProviders;
 
 	public LoomGradleExtensionImpl(Project project, LoomFiles files) {
 		super(project, files);
@@ -257,4 +261,14 @@ public class LoomGradleExtensionImpl extends LoomGradleExtensionApiImpl implemen
 	public boolean supportsInclude() {
 		return !isForge() || supportsInclude.getAsBoolean();
 	}
+
+	@Override
+	public DependencyProviders getDependencyProviders() {
+		return dependencyProviders;
+	}
+
+	@Override
+	public void setDependencyProviders(DependencyProviders dependencyProviders) {
+		this.dependencyProviders = dependencyProviders;
+	}
 }

src/main/java/net/fabricmc/loom/task/ArchitecturyGenerateSourcesTask.java

@@ -39,8 +39,7 @@ import org.gradle.api.tasks.TaskAction;
 
 import net.fabricmc.loom.api.decompilers.DecompilationMetadata;
 import net.fabricmc.loom.api.decompilers.architectury.ArchitecturyLoomDecompiler;
-import net.fabricmc.loom.util.Constants;
-import net.fabricmc.loom.util.OperatingSystem;
+import net.fabricmc.loom.util.FunnyTodoException;
 
 public abstract class ArchitecturyGenerateSourcesTask extends AbstractLoomTask {
 	private final ArchitecturyLoomDecompiler decompiler;
@@ -60,7 +59,8 @@ public abstract class ArchitecturyGenerateSourcesTask extends AbstractLoomTask {
 
 	@TaskAction
 	public void run() throws IOException {
-		if (!OperatingSystem.is64Bit()) {
+		FunnyTodoException.yes("Architectury decompiler API");
+		/*if (!OperatingSystem.is64Bit()) {
 			throw new UnsupportedOperationException("GenSources task requires a 64bit JVM to run due to the memory requirements.");
 		}
 
@@ -90,6 +90,6 @@ public abstract class ArchitecturyGenerateSourcesTask extends AbstractLoomTask {
 			} catch (Exception e) {
 				throw new RuntimeException("Could not remap line numbers", e);
 			}
-		}
+		}*/
 	}
 }

src/main/java/net/fabricmc/loom/task/GenerateSourcesTask.java

@@ -43,6 +43,7 @@ import javax.inject.Inject;
 
 import org.gradle.api.Project;
 import org.gradle.api.file.ConfigurableFileCollection;
+import org.gradle.api.file.FileCollection;
 import org.gradle.api.file.RegularFileProperty;
 import org.gradle.api.provider.Property;
 import org.gradle.api.tasks.InputFile;
@@ -54,6 +55,7 @@ import org.gradle.workers.WorkerExecutor;
 import org.gradle.workers.internal.WorkerDaemonClientsManager;
 import org.jetbrains.annotations.Nullable;
 
+import net.fabricmc.loom.LoomGradleExtension;
 import net.fabricmc.loom.api.decompilers.DecompilationMetadata;
 import net.fabricmc.loom.api.decompilers.DecompilerOptions;
 import net.fabricmc.loom.api.decompilers.LoomDecompiler;

src/main/java/net/fabricmc/loom/task/MigrateMappingsTask.java

@@ -34,6 +34,9 @@ import java.util.Set;
 
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Iterables;
+
+import net.fabricmc.loom.util.FunnyTodoException;
+
 import org.cadixdev.lorenz.MappingSet;
 import org.cadixdev.mercury.Mercury;
 import org.cadixdev.mercury.remapper.MercuryRemapper;
@@ -100,7 +103,7 @@ public class MigrateMappingsTask extends AbstractLoomTask {
 		try {
 			MemoryMappingTree currentMappings = mappingsProvider.getMappings();
 			MemoryMappingTree targetMappings = getMappings(mappings);
-			migrateMappings(project, extension, extension, inputDir, outputDir, currentMappings, targetMappings);
+			migrateMappings(project, extension, inputDir, outputDir, currentMappings, targetMappings);
 			project.getLogger().lifecycle(":remapped project written to " + outputDir.toAbsolutePath());
 		} catch (IOException e) {
 			throw new IllegalArgumentException("Error while loading mappings", e);
@@ -181,7 +184,8 @@ public class MigrateMappingsTask extends AbstractLoomTask {
 			mercury.getClassPath().add(intermediaryJar);
 		}
 
-		if (extension.isForge()) {
+		FunnyTodoException.yes("Forge jars");
+		/*if (extension.isForge()) {
 			mercury.getClassPath().add(minecraftMappedProvider.getSrgJar().toPath());
 
 			if (extension.isForgeAndNotOfficial()) {
@@ -189,7 +193,7 @@ public class MigrateMappingsTask extends AbstractLoomTask {
 				mercury.getClassPath().add(minecraftMappedProvider.getForgeIntermediaryJar().toPath());
 				mercury.getClassPath().add(minecraftMappedProvider.getForgeSrgJar().toPath());
 			}
-		}
+		}*/
 
 		mercury.getProcessors().add(MercuryRemapper.create(mappingSet));
 

src/main/java/net/fabricmc/loom/task/PrepareJarRemapTask.java

@@ -28,6 +28,7 @@ import java.nio.file.Path;
 
 import javax.inject.Inject;
 
+import dev.architectury.tinyremapper.TinyRemapper;
 import org.gradle.api.file.RegularFileProperty;
 import org.gradle.api.provider.Property;
 import org.gradle.api.tasks.InputFile;
@@ -39,7 +40,6 @@ import org.gradle.workers.WorkerExecutor;
 
 import net.fabricmc.loom.task.service.TinyRemapperService;
 import net.fabricmc.loom.util.service.UnsafeWorkQueueHelper;
-import net.fabricmc.tinyremapper.TinyRemapper;
 
 /**
  * The prepare remap task runs before all other jar remap tasks, should be used to setup tiny remapper.

src/main/java/net/fabricmc/loom/task/RemapJarTask.java

@@ -27,6 +27,7 @@ package net.fabricmc.loom.task;
 import java.io.BufferedReader;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
+import java.io.File;
 import java.io.IOException;
 import java.io.Serializable;
 import java.io.Writer;
@@ -50,10 +51,13 @@ import javax.inject.Inject;
 import com.google.common.base.Preconditions;
 import com.google.common.base.Suppliers;
 import com.google.gson.JsonObject;
-import dev.architectury.tinyremapper.InputTag;
 import dev.architectury.tinyremapper.OutputConsumerPath;
 import dev.architectury.tinyremapper.TinyRemapper;
-import dev.architectury.tinyremapper.TinyUtils;
+
+import net.fabricmc.loom.task.service.MappingsService;
+
+import net.fabricmc.loom.util.FunnyTodoException;
+
 import org.cadixdev.at.AccessTransformSet;
 import org.cadixdev.at.io.AccessTransformFormats;
 import org.cadixdev.lorenz.MappingSet;
@@ -91,8 +95,6 @@ import net.fabricmc.loom.util.ZipUtils;
 import net.fabricmc.loom.util.aw2at.Aw2At;
 import net.fabricmc.lorenztiny.TinyMappingsReader;
 import net.fabricmc.loom.util.service.UnsafeWorkQueueHelper;
-import net.fabricmc.tinyremapper.OutputConsumerPath;
-import net.fabricmc.tinyremapper.TinyRemapper;
 
 public abstract class RemapJarTask extends AbstractRemapJarTask {
 	private static final String MANIFEST_PATH = "META-INF/MANIFEST.MF";
@@ -307,7 +309,8 @@ public abstract class RemapJarTask extends AbstractRemapJarTask {
 		}
 
 		private void convertAwToAt() throws IOException {
-			if (!this.getParameters().getAtAccessWideners().isPresent()) {
+			FunnyTodoException.yes("AW2AT");
+			/*if (!this.getParameters().getAtAccessWideners().isPresent()) {
 				return;
 			}
 
@@ -359,7 +362,7 @@ public abstract class RemapJarTask extends AbstractRemapJarTask {
 				try (Writer writer = new LfWriter(Files.newBufferedWriter(atPath))) {
 					AccessTransformFormats.FML.write(writer, at);
 				}
-			}
+			}*/
 		}
 
 		private byte[] remapAccessWidener(byte[] input) {

src/main/java/net/fabricmc/loom/task/ValidateAccessWidenerTask.java

@@ -33,6 +33,8 @@ import java.nio.file.Files;
 
 import javax.inject.Inject;
 
+import dev.architectury.tinyremapper.TinyRemapper;
+import dev.architectury.tinyremapper.api.TrEnvironment;
 import org.gradle.api.DefaultTask;
 import org.gradle.api.file.ConfigurableFileCollection;
 import org.gradle.api.file.RegularFileProperty;
@@ -46,8 +48,6 @@ import net.fabricmc.accesswidener.AccessWidenerReader;
 import net.fabricmc.accesswidener.AccessWidenerVisitor;
 import net.fabricmc.loom.LoomGradleExtension;
 import net.fabricmc.loom.api.mappings.layered.MappingsNamespace;
-import net.fabricmc.tinyremapper.TinyRemapper;
-import net.fabricmc.tinyremapper.api.TrEnvironment;
 
 public abstract class ValidateAccessWidenerTask extends DefaultTask {
 	@SkipWhenEmpty

src/main/java/net/fabricmc/loom/task/service/MixinMappingsService.java

@@ -27,13 +27,13 @@ package net.fabricmc.loom.task.service;
 import java.io.File;
 import java.util.HashSet;
 
+import dev.architectury.tinyremapper.IMappingProvider;
 import org.gradle.api.Project;
 import org.gradle.api.tasks.SourceSet;
 
 import net.fabricmc.loom.LoomGradleExtension;
 import net.fabricmc.loom.util.service.SharedService;
 import net.fabricmc.loom.util.service.SharedServiceManager;
-import net.fabricmc.tinyremapper.IMappingProvider;
 
 public final class MixinMappingsService implements SharedService {
 	private final SharedServiceManager sharedServiceManager;

src/main/java/net/fabricmc/loom/task/service/TinyRemapperService.java

@@ -34,6 +34,9 @@ import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 
+import dev.architectury.tinyremapper.IMappingProvider;
+import dev.architectury.tinyremapper.InputTag;
+import dev.architectury.tinyremapper.TinyRemapper;
 import org.gradle.api.Project;
 
 import net.fabricmc.loom.LoomGradleExtension;
@@ -41,9 +44,6 @@ import net.fabricmc.loom.kotlin.remapping.KotlinMetadataTinyRemapperExtension;
 import net.fabricmc.loom.task.AbstractRemapJarTask;
 import net.fabricmc.loom.util.service.SharedService;
 import net.fabricmc.loom.util.service.SharedServiceManager;
-import net.fabricmc.tinyremapper.IMappingProvider;
-import net.fabricmc.tinyremapper.InputTag;
-import net.fabricmc.tinyremapper.TinyRemapper;
 
 public class TinyRemapperService implements SharedService {
 	public static synchronized TinyRemapperService getOrCreate(AbstractRemapJarTask remapJarTask) {
@@ -88,7 +88,7 @@ public class TinyRemapperService implements SharedService {
 		}
 
 		if (useMixinExtension) {
-			builder.extension(new net.fabricmc.tinyremapper.extension.mixin.MixinExtension());
+			builder.extension(new dev.architectury.tinyremapper.extension.mixin.MixinExtension());
 		}
 
 		if (useKotlinExtension) {

src/main/java/net/fabricmc/loom/util/FunnyTodoException.java

@@ -0,0 +1,12 @@
+package net.fabricmc.loom.util;
+
+@Deprecated
+public class FunnyTodoException extends UnsupportedOperationException {
+	public FunnyTodoException(String message) {
+		super("TODO: " + message);
+	}
+
+	public static void yes(String message) {
+		throw new FunnyTodoException(message);
+	}
+}

src/main/java/net/fabricmc/loom/util/SidedClassVisitor.java

@@ -26,11 +26,10 @@ package net.fabricmc.loom.util;
 
 import java.util.Locale;
 
+import dev.architectury.tinyremapper.TinyRemapper;
 import org.objectweb.asm.AnnotationVisitor;
 import org.objectweb.asm.ClassVisitor;
 
-import net.fabricmc.tinyremapper.TinyRemapper;
-
 /**
  * Applies the @Environment annotation to all classes.
  */

src/main/kotlin/net/fabricmc/loom/kotlin/remapping/KotlinMetadataTinyRemapperExtension.kt

@@ -24,8 +24,8 @@
 
 package net.fabricmc.loom.kotlin.remapping
 
-import net.fabricmc.tinyremapper.TinyRemapper
-import net.fabricmc.tinyremapper.api.TrClass
+import dev.architectury.tinyremapper.TinyRemapper
+import dev.architectury.tinyremapper.api.TrClass
 import org.objectweb.asm.ClassVisitor
 
 object KotlinMetadataTinyRemapperExtension : TinyRemapper.ApplyVisitorProvider, TinyRemapper.Extension {