diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/forge/FieldMigratedMappingsProvider.java b/src/main/java/net/fabricmc/loom/configuration/providers/forge/FieldMigratedMappingsProvider.java index 22b56382..4e45dd64 100644 --- a/src/main/java/net/fabricmc/loom/configuration/providers/forge/FieldMigratedMappingsProvider.java +++ b/src/main/java/net/fabricmc/loom/configuration/providers/forge/FieldMigratedMappingsProvider.java @@ -113,7 +113,7 @@ public class FieldMigratedMappingsProvider extends MappingsProvider { if (getExtension().shouldGenerateSrgTiny()) { if (Files.notExists(rawTinyMappingsWithSrg) || isRefreshDeps()) { // Merge tiny mappings with srg - SrgMerger.mergeSrg(getRawSrgFile(), rawTinyMappings, rawTinyMappingsWithSrg, true); + SrgMerger.mergeSrg(this::getMojmapSrgFileIfPossible, getRawSrgFile(), rawTinyMappings, rawTinyMappingsWithSrg, true); } } 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 303fb841..cbd9d035 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 @@ -24,16 +24,22 @@ package net.fabricmc.loom.configuration.providers.forge; +import java.io.BufferedWriter; import java.io.File; +import java.io.IOException; import java.io.Reader; +import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.StandardCopyOption; +import java.nio.file.StandardOpenOption; import java.util.function.Consumer; import com.google.gson.Gson; import com.google.gson.JsonObject; +import org.apache.commons.io.IOUtils; import org.gradle.api.Project; +import org.zeroturnaround.zip.ZipUtil; import net.fabricmc.loom.configuration.DependencyProvider; import net.fabricmc.loom.util.Constants; @@ -42,6 +48,7 @@ import net.fabricmc.loom.util.FileSystemUtil; public class McpConfigProvider extends DependencyProvider { private File mcp; private Path configJson; + private Path mappings; private Boolean official; private String mappingsPath; @@ -73,9 +80,28 @@ public class McpConfigProvider extends DependencyProvider { mappingsPath = json.get("data").getAsJsonObject().get("mappings").getAsString(); } - private void init(String version) { + private void init(String version) throws IOException { mcp = new File(getExtension().getUserCache(), "mcp-" + version + ".zip"); configJson = getExtension().getUserCache().toPath().resolve("mcp-config-" + version + ".json"); + mappings = getExtension().getUserCache().toPath().resolve("mcp-config-mappings-" + version + ".txt"); + + if (isRefreshDeps()) { + Files.deleteIfExists(mappings); + } + } + + public Path getMappings() { + if (Files.notExists(mappings)) { + if (!ZipUtil.handle(getMcp(), getMappingsPath(), (in, zipEntry) -> { + try (BufferedWriter writer = Files.newBufferedWriter(mappings, StandardCharsets.UTF_8, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)) { + IOUtils.copy(in, writer, StandardCharsets.UTF_8); + } + })) { + throw new IllegalStateException("Failed to find mappings '" + getMappingsPath() + "' in " + getMcp().getAbsolutePath() + "!"); + } + } + + return mappings; } public File getMcp() { diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/forge/MinecraftPatchedProvider.java b/src/main/java/net/fabricmc/loom/configuration/providers/forge/MinecraftPatchedProvider.java index 71571ac9..af513e72 100644 --- a/src/main/java/net/fabricmc/loom/configuration/providers/forge/MinecraftPatchedProvider.java +++ b/src/main/java/net/fabricmc/loom/configuration/providers/forge/MinecraftPatchedProvider.java @@ -94,6 +94,7 @@ import org.objectweb.asm.Opcodes; import org.objectweb.asm.tree.ClassNode; import org.zeroturnaround.zip.ZipUtil; +import net.fabricmc.loom.LoomGradleExtension; import net.fabricmc.loom.configuration.DependencyProvider; import net.fabricmc.loom.configuration.providers.MinecraftProvider; import net.fabricmc.loom.configuration.providers.mappings.MappingNamespace; @@ -103,6 +104,7 @@ import net.fabricmc.loom.configuration.providers.minecraft.MinecraftMappedProvid import net.fabricmc.loom.util.Constants; import net.fabricmc.loom.util.DependencyDownloader; import net.fabricmc.loom.util.FileSystemUtil; +import net.fabricmc.loom.util.MappingsProviderVerbose; import net.fabricmc.loom.util.ThreadingUtils; import net.fabricmc.loom.util.TinyRemapperMappingsHelper; import net.fabricmc.loom.util.function.FsPathConsumer; @@ -110,6 +112,7 @@ import net.fabricmc.loom.util.srg.InnerClassRemapper; import net.fabricmc.loom.util.srg.SpecialSourceExecutor; import net.fabricmc.loom.util.srg.Tsrg2Utils; import net.fabricmc.mapping.tree.TinyTree; +import net.fabricmc.mappingio.MappingVisitor; public class MinecraftPatchedProvider extends DependencyProvider { private static final String LOOM_PATCH_VERSION_KEY = "Loom-Patch-Version"; @@ -297,13 +300,18 @@ public class MinecraftPatchedProvider extends DependencyProvider { if (dirty) { remapPatchedJar(getProject().getLogger()); - fillClientExtraJar(); + + if (getExtension().isForgeAndOfficial()) { + fillClientExtraJar(); + } } this.filesDirty = dirty; this.dirty = false; - addDependency(minecraftClientExtra, Constants.Configurations.FORGE_EXTRA); + if (getExtension().isForgeAndOfficial()) { + addDependency(minecraftClientExtra, Constants.Configurations.FORGE_EXTRA); + } } private void fillClientExtraJar() throws IOException { @@ -326,6 +334,10 @@ public class MinecraftPatchedProvider extends DependencyProvider { .fixPackageAccess(true) .build(); + if (getProject().getGradle().getStartParameter().getLogLevel().compareTo(LogLevel.LIFECYCLE) < 0) { + MappingsProviderVerbose.saveFile(remapper); + } + remapper.readClassPath(libraries); remapper.prepareClasses(); return remapper; @@ -364,7 +376,7 @@ public class MinecraftPatchedProvider extends DependencyProvider { // processTsrg2(file); } - return getMcpConfigMappings(); + return getExtension().getMcpConfigProvider().getMappings(); } private void processTsrg2(Path[] srg) throws IOException { @@ -379,49 +391,46 @@ public class MinecraftPatchedProvider extends DependencyProvider { } } - public Path getMcpConfigMappings() throws IOException { - if (mcpConfigMappings == null) { - Path configMappings = Files.createTempFile("mcp-config-mappings", null); - McpConfigProvider mcpProvider = getExtension().getMcpConfigProvider(); + private static void visitMojmap(MappingVisitor visitor, LoomGradleExtension extension) { + try { + MojangMappingLayer layer = new MojangMappingsSpec(() -> true).createLayer(extension.createMappingContext(() -> "layered+mojang")); + layer.visit(visitor); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + } - if (!ZipUtil.handle(mcpProvider.getMcp(), mcpProvider.getMappingsPath(), (in, zipEntry) -> { - try (BufferedWriter writer = Files.newBufferedWriter(configMappings, StandardCharsets.UTF_8, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)) { - IOUtils.copy(in, writer, StandardCharsets.UTF_8); - } - })) { - throw new IllegalStateException("Failed to find mappings '" + mcpProvider.getMappingsPath() + "' in " + mcpProvider.getMcp().getAbsolutePath() + "!"); - } + public static Path getMojmapTsrg(LoomGradleExtension extension) throws IOException { + Path mojmap = Files.createTempFile("mojang-in-tsrg", null); - return mcpConfigMappings = configMappings; + try (BufferedWriter writer = Files.newBufferedWriter(mojmap, StandardCharsets.UTF_8, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)) { + Tsrg2Utils.writeTsrg(visitor -> visitMojmap(visitor, extension), MappingNamespace.NAMED.stringValue(), false, writer); } - return mcpConfigMappings; + return mojmap; + } + + public static Path getMojmapTsrg2(LoomGradleExtension extension) throws IOException { + Path mojmap = Files.createTempFile("mojang-in-tsrg2", null); + + try (BufferedWriter writer = Files.newBufferedWriter(mojmap, StandardCharsets.UTF_8, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)) { + Tsrg2Utils.writeTsrg2(visitor -> visitMojmap(visitor, extension), writer); + } + + return mojmap; } public Path getMojmapTSrg2EpicWhyDoesThisExist(boolean hasParameters) throws IOException { if (mojmapTSrg2EpicWhyDoesThisExist == null) { - Path mojmap = Files.createTempFile("mojang-in-srg", null); - - try (BufferedWriter writer = Files.newBufferedWriter(mojmap, StandardCharsets.UTF_8, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)) { - Tsrg2Utils.writeTsrg(visitor -> { - try { - MojangMappingLayer layer = new MojangMappingsSpec(() -> true).createLayer(getExtension().createMappingContext(() -> "layered+mojang")); - layer.visit(visitor); - } catch (IOException e) { - throw new UncheckedIOException(e); - } - }, MappingNamespace.NAMED.stringValue(), false, writer); - } - Path out = Files.createTempFile("merged-mojang-tsrg2", null); Path outTrimmed = Files.createTempFile("merged-mojang-tsrg2-trimmed", null); net.minecraftforge.installertools.ConsoleTool.main(new String[]{ "--task", "MERGE_MAPPING", "--left", - getMcpConfigMappings().toAbsolutePath().toString(), + getExtension().getMcpConfigProvider().getMappings().toAbsolutePath().toString(), "--right", - mojmap.toAbsolutePath().toString(), + getMojmapTsrg(getExtension()).toAbsolutePath().toString(), "--classes", "--output", out.toAbsolutePath().toString() diff --git a/src/main/java/net/fabricmc/loom/configuration/providers/mappings/MappingsProvider.java b/src/main/java/net/fabricmc/loom/configuration/providers/mappings/MappingsProvider.java index 931fc7cf..3b5fd063 100644 --- a/src/main/java/net/fabricmc/loom/configuration/providers/mappings/MappingsProvider.java +++ b/src/main/java/net/fabricmc/loom/configuration/providers/mappings/MappingsProvider.java @@ -27,6 +27,7 @@ package net.fabricmc.loom.configuration.providers.mappings; import java.io.BufferedReader; import java.io.File; import java.io.IOException; +import java.io.UncheckedIOException; import java.net.URL; import java.nio.charset.StandardCharsets; import java.nio.file.FileSystem; @@ -238,7 +239,7 @@ public class MappingsProvider extends DependencyProvider { if (getExtension().shouldGenerateSrgTiny()) { if (Files.notExists(tinyMappingsWithSrg) || isRefreshDeps()) { // Merge tiny mappings with srg - SrgMerger.mergeSrg(getRawSrgFile(), tinyMappings.toPath(), tinyMappingsWithSrg, true); + SrgMerger.mergeSrg(this::getMojmapSrgFileIfPossible, getRawSrgFile(), tinyMappings.toPath(), tinyMappingsWithSrg, true); } } @@ -311,6 +312,15 @@ public class MappingsProvider extends DependencyProvider { return extension.getSrgProvider().getSrg().toPath(); } + protected Path getMojmapSrgFileIfPossible() { + try { + LoomGradleExtension extension = getExtension(); + return MinecraftPatchedProvider.getMojmapTsrg2(extension); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + } + public void manipulateMappings(Path mappingsJar) throws IOException { } private void storeMappings(Project project, MinecraftProvider minecraftProvider, Path yarnJar, Consumer postPopulationScheduler) diff --git a/src/main/java/net/fabricmc/loom/util/MappingsProviderVerbose.java b/src/main/java/net/fabricmc/loom/util/MappingsProviderVerbose.java index dd25b9fe..575f4e5f 100644 --- a/src/main/java/net/fabricmc/loom/util/MappingsProviderVerbose.java +++ b/src/main/java/net/fabricmc/loom/util/MappingsProviderVerbose.java @@ -1,19 +1,33 @@ package net.fabricmc.loom.util; import java.io.IOException; +import java.lang.reflect.Field; import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.StandardOpenOption; import java.util.Arrays; import java.util.HashMap; +import java.util.Set; import dev.architectury.mappingslayers.api.mutable.MutableTinyMetadata; import dev.architectury.mappingslayers.api.mutable.MutableTinyTree; import dev.architectury.mappingslayers.api.utils.MappingsUtils; import dev.architectury.tinyremapper.IMappingProvider; +import dev.architectury.tinyremapper.TinyRemapper; public class MappingsProviderVerbose { + public static void saveFile(TinyRemapper providers) throws IOException { + try { + Field field = TinyRemapper.class.getDeclaredField("mappingProviders"); + field.setAccessible(true); + Set mappingProviders = (Set) field.get(providers); + saveFile(mappingProviders); + } catch (IllegalAccessException | NoSuchFieldException e) { + e.printStackTrace(); + } + } + public static void saveFile(Iterable providers) throws IOException { MutableTinyTree tree = MappingsUtils.create(MutableTinyMetadata.create(2, 0, Arrays.asList("from", "to"), new HashMap<>())); @@ -52,5 +66,6 @@ public class MappingsProviderVerbose { Path check = Files.createTempFile("CHECK", null); Files.write(check, MappingsUtils.serializeToString(tree).getBytes(StandardCharsets.UTF_8), StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING); + System.out.println("Saved debug check mappings to " + check); } } diff --git a/src/main/java/net/fabricmc/loom/util/srg/SrgMerger.java b/src/main/java/net/fabricmc/loom/util/srg/SrgMerger.java index cac15bd6..9d5086f6 100644 --- a/src/main/java/net/fabricmc/loom/util/srg/SrgMerger.java +++ b/src/main/java/net/fabricmc/loom/util/srg/SrgMerger.java @@ -27,14 +27,24 @@ package net.fabricmc.loom.util.srg; import java.io.BufferedReader; import java.io.IOException; import java.io.StringReader; +import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; import java.util.ArrayList; import java.util.Collections; +import java.util.HashMap; import java.util.List; +import java.util.Map; import java.util.function.Consumer; import java.util.function.Supplier; +import com.google.common.base.MoreObjects; +import dev.architectury.mappingslayers.api.mutable.MutableClassDef; +import dev.architectury.mappingslayers.api.mutable.MutableDescriptored; +import dev.architectury.mappingslayers.api.mutable.MutableFieldDef; +import dev.architectury.mappingslayers.api.mutable.MutableMethodDef; +import dev.architectury.mappingslayers.api.mutable.MutableTinyTree; +import dev.architectury.mappingslayers.api.utils.MappingsUtils; import org.apache.commons.io.IOUtils; import org.cadixdev.lorenz.MappingSet; import org.cadixdev.lorenz.io.srg.tsrg.TSrgReader; @@ -76,8 +86,9 @@ public final class SrgMerger { * @throws MappingException if the input tiny tree's default namespace is not 'official' * or if an element mentioned in the SRG file does not have tiny mappings */ - public static void mergeSrg(Path srg, Path tiny, Path out, boolean lenient) throws IOException, MappingException { - MappingSet arr = readSrg(srg); + public static void mergeSrg(Supplier mojmap, Path srg, Path tiny, Path out, boolean lenient) throws IOException, MappingException { + Map> addRegardlessSrgs = new HashMap<>(); + MappingSet arr = readSrg(srg, mojmap, addRegardlessSrgs); TinyTree foss; try (BufferedReader reader = Files.newBufferedReader(tiny)) { @@ -96,19 +107,19 @@ public final class SrgMerger { List classes = new ArrayList<>(); for (TopLevelClassMapping klass : arr.getTopLevelClassMappings()) { - classToTiny(foss, namespaces, klass, classes::add, lenient); + classToTiny(addRegardlessSrgs, foss, namespaces, klass, classes::add, lenient); } TinyFile file = new TinyFile(header, classes); TinyV2Writer.write(file, out); } - private static MappingSet readSrg(Path srg) throws IOException { + private static MappingSet readSrg(Path srg, Supplier mojmap, Map> addRegardlessSrgs) throws IOException { try (BufferedReader reader = Files.newBufferedReader(srg)) { String content = IOUtils.toString(reader); if (content.startsWith("tsrg2")) { - return readTsrg2(content); + return readTsrg2(content, mojmap, addRegardlessSrgs); } else { try (TSrgReader srgReader = new TSrgReader(new StringReader(content))) { return srgReader.read(); @@ -117,18 +128,45 @@ public final class SrgMerger { } } - private static MappingSet readTsrg2(String content) throws IOException { + private static MappingSet readTsrg2(String content, Supplier mojmap, Map> addRegardlessSrgs) throws IOException { MappingSet set; try (Tsrg2Utils.MappingsIO2LorenzWriter lorenzWriter = new Tsrg2Utils.MappingsIO2LorenzWriter(0, false)) { TsrgReader.read(new StringReader(content), lorenzWriter); set = lorenzWriter.read(); + MutableTinyTree mojmapTree = readTsrg2ToTinyTree(mojmap.get()); + + for (MutableClassDef classDef : mojmapTree.getClassesMutable()) { + for (MutableMethodDef methodDef : classDef.getMethodsMutable()) { + String name = methodDef.getName(0); + + if (name.indexOf('<') != 0 && name.equals(methodDef.getName(1))) { + addRegardlessSrgs.computeIfAbsent(classDef.getName(0), $ -> new ArrayList<>()).add(methodDef); + } + } + + for (MutableFieldDef fieldDef : classDef.getFieldsMutable()) { + if (fieldDef.getName(0).equals(fieldDef.getName(1))) { + addRegardlessSrgs.computeIfAbsent(classDef.getName(0), $ -> new ArrayList<>()).add(fieldDef); + } + } + } } return set; } - private static void classToTiny(TinyTree foss, List namespaces, ClassMapping klass, Consumer classConsumer, boolean lenient) { + private static MutableTinyTree readTsrg2ToTinyTree(Path path) throws IOException { + MutableTinyTree tree; + + try (BufferedReader reader = Files.newBufferedReader(path, StandardCharsets.UTF_8)) { + tree = MappingsUtils.deserializeFromTsrg2(IOUtils.toString(reader)); + } + + return tree; + } + + private static void classToTiny(Map> addRegardlessSrgs, TinyTree foss, List namespaces, ClassMapping klass, Consumer classConsumer, boolean lenient) { String obf = klass.getFullObfuscatedName(); String srg = klass.getFullDeobfuscatedName(); ClassDef classDef = foss.getDefaultNamespaceClassMap().get(obf); @@ -153,9 +191,17 @@ public final class SrgMerger { MethodDef def = CollectionUtil.find( classDef.getMethods(), m -> m.getName("official").equals(method.getObfuscatedName()) && m.getDescriptor("official").equals(method.getObfuscatedDescriptor()) - ).orElse(nullOrThrow(lenient, () -> new MappingException("Missing method: " + method.getFullObfuscatedName() + " (srg: " + method.getFullDeobfuscatedName() + ")"))); + ).orElse(null); - if (def == null) continue; + if (def == null) { + if (tryMatchRegardlessSrgs(addRegardlessSrgs, namespaces, obf, methods, method)) continue; + + if (!lenient) { + throw new MappingException("Missing method: " + method.getFullObfuscatedName() + " (srg: " + method.getFullDeobfuscatedName() + ")"); + } + + continue; + } List methodNames = CollectionUtil.map( namespaces, @@ -190,10 +236,36 @@ public final class SrgMerger { classConsumer.accept(tinyClass); for (InnerClassMapping innerKlass : klass.getInnerClassMappings()) { - classToTiny(foss, namespaces, innerKlass, classConsumer, lenient); + classToTiny(addRegardlessSrgs, foss, namespaces, innerKlass, classConsumer, lenient); } } + private static boolean tryMatchRegardlessSrgs(Map> addRegardlessSrgs, List namespaces, String obf, + List methods, MethodMapping method) { + List mutableDescriptoredList = addRegardlessSrgs.get(obf); + + if (!method.getDeobfuscatedName().equals(method.getObfuscatedName())) { + for (MutableDescriptored descriptored : MoreObjects.firstNonNull(mutableDescriptoredList, Collections.emptyList())) { + if (descriptored.isMethod() && descriptored.getName(0).equals(method.getObfuscatedName()) && descriptored.getDescriptor(0).equals(method.getObfuscatedDescriptor())) { + List methodNames = CollectionUtil.map( + namespaces, + namespace -> "srg".equals(namespace) ? method.getDeobfuscatedName() : method.getObfuscatedName() + ); + + methods.add(new TinyMethod( + method.getObfuscatedDescriptor(), methodNames, + /* parameters */ Collections.emptyList(), + /* locals */ Collections.emptyList(), + /* comments */ Collections.emptyList() + )); + return true; + } + } + } + + return false; + } + @Nullable private static T nullOrThrow(boolean lenient, Supplier exception) throws X { if (lenient) { diff --git a/src/main/java/net/fabricmc/loom/util/srg/Tsrg2Utils.java b/src/main/java/net/fabricmc/loom/util/srg/Tsrg2Utils.java index f8474045..911f5015 100644 --- a/src/main/java/net/fabricmc/loom/util/srg/Tsrg2Utils.java +++ b/src/main/java/net/fabricmc/loom/util/srg/Tsrg2Utils.java @@ -5,9 +5,18 @@ import java.io.Reader; import java.io.UncheckedIOException; import java.io.Writer; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import java.util.Map; import java.util.function.Consumer; +import dev.architectury.mappingslayers.api.mutable.MutableClassDef; +import dev.architectury.mappingslayers.api.mutable.MutableFieldDef; +import dev.architectury.mappingslayers.api.mutable.MutableMethodDef; +import dev.architectury.mappingslayers.api.mutable.MutableParameterDef; +import dev.architectury.mappingslayers.api.mutable.MutableTinyMetadata; +import dev.architectury.mappingslayers.api.mutable.MutableTinyTree; +import dev.architectury.mappingslayers.api.utils.MappingsUtils; import org.cadixdev.lorenz.MappingSet; import org.cadixdev.lorenz.io.srg.tsrg.TSrgWriter; import org.cadixdev.lorenz.model.ClassMapping; @@ -31,7 +40,8 @@ public class Tsrg2Utils { }, "srg", false, writer); } - public static void writeTsrg(Consumer visitorConsumer, String dstNamespace, boolean applyParameterMappings, Writer writer) throws IOException { + public static void writeTsrg(Consumer visitorConsumer, String dstNamespace, boolean applyParameterMappings, Writer writer) + throws IOException { MappingSet set; try (MappingsIO2LorenzWriter lorenzWriter = new MappingsIO2LorenzWriter(dstNamespace, applyParameterMappings)) { @@ -44,20 +54,54 @@ public class Tsrg2Utils { } } + public static void writeTsrg2(Consumer visitorConsumer, Writer writer) + throws IOException { + MutableTinyTree tree; + + try (MappingsIO2MappingsUtils w = new MappingsIO2MappingsUtils()) { + visitorConsumer.accept(w); + tree = w.read(); + } + + writer.write(MappingsUtils.serializeToTsrg2(tree)); + } + // TODO Move this elsewhere - public static class MappingsIO2LorenzWriter extends ForwardingMappingVisitor implements MappingWriter { + public abstract static class MappingsIO2Others extends ForwardingMappingVisitor implements MappingWriter { + public MappingsIO2Others() { + super(new MemoryMappingTree()); + } + + public MappingTree tree() { + return (MappingTree) next; + } + + @Override + public void close() throws IOException { + MappingTree tree = tree(); + List names = new ArrayList<>(); + + for (MappingTree.ClassMapping aClass : tree.getClasses()) { + names.add(aClass.getSrcName()); + } + + for (String name : names) { + tree.removeClass(name); + } + } + } + + public static class MappingsIO2LorenzWriter extends MappingsIO2Others { private final Object dstNamespaceUnresolved; private int dstNamespace; private boolean applyParameterMappings; public MappingsIO2LorenzWriter(int dstNamespace, boolean applyParameterMappings) { - super(new MemoryMappingTree()); this.dstNamespaceUnresolved = dstNamespace; this.applyParameterMappings = applyParameterMappings; } public MappingsIO2LorenzWriter(String dstNamespace, boolean applyParameterMappings) { - super(new MemoryMappingTree()); this.dstNamespaceUnresolved = dstNamespace; this.applyParameterMappings = applyParameterMappings; } @@ -73,7 +117,7 @@ public class Tsrg2Utils { } public MappingSet read(final MappingSet mappings) throws IOException { - MappingTree tree = (MappingTree) next; + MappingTree tree = tree(); for (MappingTree.ClassMapping aClass : tree.getClasses()) { ClassMapping lClass = mappings.getOrCreateClassMapping(aClass.getSrcName()) @@ -106,19 +150,60 @@ public class Tsrg2Utils { return mappings; } + } - @Override - public void close() throws IOException { - MappingTree tree = (MappingTree) next; - List names = new ArrayList<>(); + public static class MappingsIO2MappingsUtils extends MappingsIO2Others { + public MutableTinyTree read() { + MappingTree tree = tree(); + int dstNamesSize = tree.getDstNamespaces().size(); + List namespaces = new ArrayList<>(); + namespaces.add(tree.getSrcNamespace()); + namespaces.addAll(tree.getDstNamespaces()); + Map properties = new HashMap<>(); + + for (Map.Entry entry : tree.getMetadata()) { + properties.put(entry.getKey(), entry.getValue()); + } + + MutableTinyTree out = MappingsUtils.create(MutableTinyMetadata.create(2, 0, namespaces, properties)); for (MappingTree.ClassMapping aClass : tree.getClasses()) { - names.add(aClass.getSrcName()); + MutableClassDef classDef = out.getOrCreateClass(aClass.getSrcName()); + classDef.setComment(aClass.getComment()); + + for (int i = 0; i < dstNamesSize; i++) { + classDef.setName(i + 1, aClass.getDstName(i)); + } + + for (MappingTree.MethodMapping aMethod : aClass.getMethods()) { + MutableMethodDef methodDef = classDef.getOrCreateMethod(aMethod.getSrcName(), aMethod.getSrcDesc()); + methodDef.setComment(aMethod.getComment()); + + for (int i = 0; i < dstNamesSize; i++) { + methodDef.setName(i + 1, aMethod.getDstName(i)); + } + + for (MappingTree.MethodArgMapping aMethodArg : aMethod.getArgs()) { + MutableParameterDef parameterDef = methodDef.getOrCreateParameter(aMethodArg.getLvIndex(), aMethodArg.getSrcName()); + parameterDef.setComment(aMethodArg.getComment()); + + for (int i = 0; i < dstNamesSize; i++) { + parameterDef.setName(i + 1, aMethodArg.getDstName(i)); + } + } + } + + for (MappingTree.FieldMapping aField : aClass.getFields()) { + MutableFieldDef fieldDef = classDef.getOrCreateField(aField.getSrcName(), aField.getSrcDesc()); + fieldDef.setComment(aField.getComment()); + + for (int i = 0; i < dstNamesSize; i++) { + fieldDef.setName(i + 1, aField.getDstName(i)); + } + } } - for (String name : names) { - tree.removeClass(name); - } + return out; } } }