From 91656cfa50c13cfa9b1760e55898741c1365cd60 Mon Sep 17 00:00:00 2001 From: Juuz <6596629+Juuxel@users.noreply.github.com> Date: Tue, 18 Jan 2022 18:55:52 +0200 Subject: [PATCH] A lot of 0.11 stuff but nowhere near done --- build.gradle | 6 +- .../fabricmc/loom/LoomGradleExtension.java | 20 +- .../loom/api/LoomGradleExtensionAPI.java | 1 + .../configuration/CompileConfiguration.java | 23 +- .../configuration/LoomDependencyManager.java | 1 + .../providers/forge/DependencyProvider.java | 83 ++ .../providers/forge/DependencyProviders.java | 97 +++ .../providers/forge/ForgeProvider.java | 2 +- .../forge/ForgeUniversalProvider.java | 2 +- .../providers/forge/ForgeUserdevProvider.java | 2 +- .../providers/forge/McpConfigProvider.java | 2 +- .../forge/MinecraftPatchedProvider2.java | 778 ++++++++++++++++++ .../providers/forge/PatchProvider.java | 2 +- .../providers/forge/SrgProvider.java | 2 +- .../minecraft/MergedMinecraftProvider.java | 6 +- .../minecraft/MinecraftJarConfiguration.java | 3 +- .../ServerOnlyMinecraftProvider.java | 6 +- .../AbstractMappedMinecraftProvider.java | 4 +- .../mapped/IntermediaryMinecraftProvider.java | 2 +- .../mapped/NamedMinecraftProvider.java | 2 +- .../extension/LoomGradleExtensionApiImpl.java | 1 + .../extension/LoomGradleExtensionImpl.java | 14 + .../task/ArchitecturyGenerateSourcesTask.java | 8 +- .../loom/task/GenerateSourcesTask.java | 2 + .../loom/task/MigrateMappingsTask.java | 10 +- .../loom/task/PrepareJarRemapTask.java | 2 +- .../net/fabricmc/loom/task/RemapJarTask.java | 15 +- .../loom/task/ValidateAccessWidenerTask.java | 4 +- .../task/service/MixinMappingsService.java | 2 +- .../task/service/TinyRemapperService.java | 8 +- .../loom/util/FunnyTodoException.java | 12 + .../fabricmc/loom/util/SidedClassVisitor.java | 3 +- .../KotlinMetadataTinyRemapperExtension.kt | 4 +- 33 files changed, 1069 insertions(+), 60 deletions(-) create mode 100644 src/main/java/net/fabricmc/loom/configuration/providers/forge/DependencyProvider.java create mode 100644 src/main/java/net/fabricmc/loom/configuration/providers/forge/DependencyProviders.java create mode 100644 src/main/java/net/fabricmc/loom/configuration/providers/forge/MinecraftPatchedProvider2.java create mode 100644 src/main/java/net/fabricmc/loom/util/FunnyTodoException.java diff --git a/build.gradle b/build.gradle index 138eb3e8..0386453e 100644 --- a/build.gradle +++ b/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' diff --git a/src/main/java/net/fabricmc/loom/LoomGradleExtension.java b/src/main/java/net/fabricmc/loom/LoomGradleExtension.java index e710e511..553b43c5 100644 --- a/src/main/java/net/fabricmc/loom/LoomGradleExtension.java +++ b/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); } } diff --git a/src/main/java/net/fabricmc/loom/api/LoomGradleExtensionAPI.java b/src/main/java/net/fabricmc/loom/api/LoomGradleExtensionAPI.java index 0e5d5546..8033a314 100644 --- a/src/main/java/net/fabricmc/loom/api/LoomGradleExtensionAPI.java +++ b/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; diff --git a/src/main/java/net/fabricmc/loom/configuration/CompileConfiguration.java b/src/main/java/net/fabricmc/loom/configuration/CompileConfiguration.java index 0863eb7b..19a109f4 100644 --- a/src/main/java/net/fabricmc/loom/configuration/CompileConfiguration.java +++ b/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(); diff --git a/src/main/java/net/fabricmc/loom/configuration/LoomDependencyManager.java b/src/main/java/net/fabricmc/loom/configuration/LoomDependencyManager.java index 292a6806..523b6bad 100644 --- a/src/main/java/net/fabricmc/loom/configuration/LoomDependencyManager.java +++ b/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" : ""; diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/forge/DependencyProvider.java b/src/main/java/net/fabricmc/loom/configuration/providers/forge/DependencyProvider.java new file mode 100644 index 00000000..52eed4fc --- /dev/null +++ b/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 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; + } +} diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/forge/DependencyProviders.java b/src/main/java/net/fabricmc/loom/configuration/providers/forge/DependencyProviders.java new file mode 100644 index 00000000..b32e53d5 --- /dev/null +++ b/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 providers = new ArrayList<>(); + + ProviderList(String key) { + this.key = key; + } + } + + private final List dependencyProviderList = new ArrayList<>(); + + public 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 getProvider(Class clazz) { + for (DependencyProvider provider : dependencyProviderList) { + if (provider.getClass() == clazz) { + return (T) provider; + } + } + + return null; + } + + public void handleDependencies(Project project) { + List afterTasks = new ArrayList<>(); + + project.getLogger().info(":setting up loom dependencies"); + Map providerListMap = new HashMap<>(); + List 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(); + } + } +} diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/forge/ForgeProvider.java b/src/main/java/net/fabricmc/loom/configuration/providers/forge/ForgeProvider.java index 9e1e4a7a..31f97d46 100644 --- a/src/main/java/net/fabricmc/loom/configuration/providers/forge/ForgeProvider.java +++ b/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 { diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/forge/ForgeUniversalProvider.java b/src/main/java/net/fabricmc/loom/configuration/providers/forge/ForgeUniversalProvider.java index b51299fb..6abc7c8f 100644 --- a/src/main/java/net/fabricmc/loom/configuration/providers/forge/ForgeUniversalProvider.java +++ b/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 { diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/forge/ForgeUserdevProvider.java b/src/main/java/net/fabricmc/loom/configuration/providers/forge/ForgeUserdevProvider.java index e5b6cdfc..63063123 100644 --- a/src/main/java/net/fabricmc/loom/configuration/providers/forge/ForgeUserdevProvider.java +++ b/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; diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/forge/McpConfigProvider.java b/src/main/java/net/fabricmc/loom/configuration/providers/forge/McpConfigProvider.java index 7404cc0a..40d100b3 100644 --- a/src/main/java/net/fabricmc/loom/configuration/providers/forge/McpConfigProvider.java +++ b/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; diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/forge/MinecraftPatchedProvider2.java b/src/main/java/net/fabricmc/loom/configuration/providers/forge/MinecraftPatchedProvider2.java new file mode 100644 index 00000000..5ada3515 --- /dev/null +++ b/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 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 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::exists).negate()) + || !isPatchedJarUpToDate(minecraftMergedPatchedJar)) { + cleanAllCache(); + } else if (atDirty || Stream.of(getProjectCache()).anyMatch(((Predicate) 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 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) 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) 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 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 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 srgJar; + final Function patchedSrgJar; + + Environment(Function srgJar, + Function 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> 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 filter, Function> 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 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 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 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 getMinecraftJars() { + if (forgeMergedJar != null) { + return List.of(minecraftMergedPatchedJar.toPath(), forgeMergedJar.toPath()); + } else { + return List.of(minecraftMergedPatchedJar.toPath()); + } + } +} diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/forge/PatchProvider.java b/src/main/java/net/fabricmc/loom/configuration/providers/forge/PatchProvider.java index d49ae8b4..52eda3bd 100644 --- a/src/main/java/net/fabricmc/loom/configuration/providers/forge/PatchProvider.java +++ b/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 { diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/forge/SrgProvider.java b/src/main/java/net/fabricmc/loom/configuration/providers/forge/SrgProvider.java index 55a19fd6..2c048e93 100644 --- a/src/main/java/net/fabricmc/loom/configuration/providers/forge/SrgProvider.java +++ b/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; diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/MergedMinecraftProvider.java b/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/MergedMinecraftProvider.java index 008cd5c0..748ce1d7 100644 --- a/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/MergedMinecraftProvider.java +++ b/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(); diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/MinecraftJarConfiguration.java b/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/MinecraftJarConfiguration.java index df949173..270a799d 100644 --- a/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/MinecraftJarConfiguration.java +++ b/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, diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/ServerOnlyMinecraftProvider.java b/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/ServerOnlyMinecraftProvider.java index a12343f1..2cd8ff2f 100644 --- a/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/ServerOnlyMinecraftProvider.java +++ b/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; diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/mapped/AbstractMappedMinecraftProvider.java b/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/mapped/AbstractMappedMinecraftProvider.java index 68239f4d..0f943308 100644 --- a/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/mapped/AbstractMappedMinecraftProvider.java +++ b/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 implements MappedMinecraftProvider.ProviderImpl { protected final M minecraftProvider; diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/mapped/IntermediaryMinecraftProvider.java b/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/mapped/IntermediaryMinecraftProvider.java index 11ce20bf..e31abde1 100644 --- a/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/mapped/IntermediaryMinecraftProvider.java +++ b/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 extends AbstractMappedMinecraftProvider permits IntermediaryMinecraftProvider.MergedImpl, IntermediaryMinecraftProvider.ServerOnlyImpl, IntermediaryMinecraftProvider.SplitImpl { public IntermediaryMinecraftProvider(Project project, M minecraftProvider) { diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/mapped/NamedMinecraftProvider.java b/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/mapped/NamedMinecraftProvider.java index a143ae60..1d9d317a 100644 --- a/src/main/java/net/fabricmc/loom/configuration/providers/minecraft/mapped/NamedMinecraftProvider.java +++ b/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 extends AbstractMappedMinecraftProvider { public NamedMinecraftProvider(Project project, M minecraftProvider) { diff --git a/src/main/java/net/fabricmc/loom/extension/LoomGradleExtensionApiImpl.java b/src/main/java/net/fabricmc/loom/extension/LoomGradleExtensionApiImpl.java index e87f760d..0dc7ed87 100644 --- a/src/main/java/net/fabricmc/loom/extension/LoomGradleExtensionApiImpl.java +++ b/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; diff --git a/src/main/java/net/fabricmc/loom/extension/LoomGradleExtensionImpl.java b/src/main/java/net/fabricmc/loom/extension/LoomGradleExtensionImpl.java index b059474f..de448481 100644 --- a/src/main/java/net/fabricmc/loom/extension/LoomGradleExtensionImpl.java +++ b/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; + } } diff --git a/src/main/java/net/fabricmc/loom/task/ArchitecturyGenerateSourcesTask.java b/src/main/java/net/fabricmc/loom/task/ArchitecturyGenerateSourcesTask.java index 0ff32f28..49a7de93 100644 --- a/src/main/java/net/fabricmc/loom/task/ArchitecturyGenerateSourcesTask.java +++ b/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); } - } + }*/ } } diff --git a/src/main/java/net/fabricmc/loom/task/GenerateSourcesTask.java b/src/main/java/net/fabricmc/loom/task/GenerateSourcesTask.java index 9c493012..8d7f873b 100644 --- a/src/main/java/net/fabricmc/loom/task/GenerateSourcesTask.java +++ b/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; diff --git a/src/main/java/net/fabricmc/loom/task/MigrateMappingsTask.java b/src/main/java/net/fabricmc/loom/task/MigrateMappingsTask.java index 310aa6c7..e0d3690f 100644 --- a/src/main/java/net/fabricmc/loom/task/MigrateMappingsTask.java +++ b/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)); diff --git a/src/main/java/net/fabricmc/loom/task/PrepareJarRemapTask.java b/src/main/java/net/fabricmc/loom/task/PrepareJarRemapTask.java index f5761d0a..fb103b63 100644 --- a/src/main/java/net/fabricmc/loom/task/PrepareJarRemapTask.java +++ b/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. diff --git a/src/main/java/net/fabricmc/loom/task/RemapJarTask.java b/src/main/java/net/fabricmc/loom/task/RemapJarTask.java index fcaa8e49..4a3ef468 100644 --- a/src/main/java/net/fabricmc/loom/task/RemapJarTask.java +++ b/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) { diff --git a/src/main/java/net/fabricmc/loom/task/ValidateAccessWidenerTask.java b/src/main/java/net/fabricmc/loom/task/ValidateAccessWidenerTask.java index 5f2e79b9..17734cc2 100644 --- a/src/main/java/net/fabricmc/loom/task/ValidateAccessWidenerTask.java +++ b/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 diff --git a/src/main/java/net/fabricmc/loom/task/service/MixinMappingsService.java b/src/main/java/net/fabricmc/loom/task/service/MixinMappingsService.java index 37466a19..b9a3518f 100644 --- a/src/main/java/net/fabricmc/loom/task/service/MixinMappingsService.java +++ b/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; diff --git a/src/main/java/net/fabricmc/loom/task/service/TinyRemapperService.java b/src/main/java/net/fabricmc/loom/task/service/TinyRemapperService.java index 9e05d656..4bd7224c 100644 --- a/src/main/java/net/fabricmc/loom/task/service/TinyRemapperService.java +++ b/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) { diff --git a/src/main/java/net/fabricmc/loom/util/FunnyTodoException.java b/src/main/java/net/fabricmc/loom/util/FunnyTodoException.java new file mode 100644 index 00000000..24c6300c --- /dev/null +++ b/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); + } +} diff --git a/src/main/java/net/fabricmc/loom/util/SidedClassVisitor.java b/src/main/java/net/fabricmc/loom/util/SidedClassVisitor.java index 51fe9c51..d5e4e730 100644 --- a/src/main/java/net/fabricmc/loom/util/SidedClassVisitor.java +++ b/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. */ diff --git a/src/main/kotlin/net/fabricmc/loom/kotlin/remapping/KotlinMetadataTinyRemapperExtension.kt b/src/main/kotlin/net/fabricmc/loom/kotlin/remapping/KotlinMetadataTinyRemapperExtension.kt index 1ba80919..ca43eea6 100644 --- a/src/main/kotlin/net/fabricmc/loom/kotlin/remapping/KotlinMetadataTinyRemapperExtension.kt +++ b/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 {