From 527a8980b3da08fa72d40597fb1716db0f7fda6e Mon Sep 17 00:00:00 2001 From: NebelNidas Date: Sat, 24 Sep 2022 12:59:23 +0200 Subject: [PATCH 1/6] Make "checkmappings" command support all readable formats --- .../enigma/command/CheckMappingsCommand.java | 4 +-- .../java/cuchaz/enigma/command/Command.java | 30 ++++++++++++++----- .../mapping/serde/MappingFormat.java | 16 ++++++++++ 3 files changed, 40 insertions(+), 10 deletions(-) diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/CheckMappingsCommand.java b/enigma-cli/src/main/java/cuchaz/enigma/command/CheckMappingsCommand.java index 922d66884..6645d1000 100644 --- a/enigma-cli/src/main/java/cuchaz/enigma/command/CheckMappingsCommand.java +++ b/enigma-cli/src/main/java/cuchaz/enigma/command/CheckMappingsCommand.java @@ -10,7 +10,6 @@ import cuchaz.enigma.analysis.index.JarIndex; import cuchaz.enigma.classprovider.ClasspathClassProvider; import cuchaz.enigma.translation.mapping.EntryMapping; -import cuchaz.enigma.translation.mapping.serde.MappingFormat; import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters; import cuchaz.enigma.translation.mapping.tree.EntryTree; import cuchaz.enigma.translation.representation.entry.ClassEntry; @@ -43,10 +42,9 @@ public void run(String... args) throws Exception { System.out.println("Reading mappings..."); - MappingFormat format = chooseEnigmaFormat(fileMappings); MappingSaveParameters saveParameters = enigma.getProfile().getMappingSaveParameters(); - EntryTree mappings = format.read(fileMappings, ProgressListener.none(), saveParameters); + EntryTree mappings = readMappings(fileMappings, ProgressListener.none(), saveParameters); project.setMappings(mappings); JarIndex idx = project.getJarIndex(); diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/Command.java b/enigma-cli/src/main/java/cuchaz/enigma/command/Command.java index 04d49f2fa..a6712111f 100644 --- a/enigma-cli/src/main/java/cuchaz/enigma/command/Command.java +++ b/enigma-cli/src/main/java/cuchaz/enigma/command/Command.java @@ -4,6 +4,8 @@ import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.List; import com.google.common.io.MoreFiles; @@ -41,7 +43,7 @@ protected static EnigmaProject openProject(Path fileJarIn, Path fileMappings) th System.out.println("Reading mappings..."); MappingSaveParameters saveParameters = enigma.getProfile().getMappingSaveParameters(); - EntryTree mappings = chooseEnigmaFormat(fileMappings).read(fileMappings, progress, saveParameters); + EntryTree mappings = readMappings(fileMappings, progress, saveParameters); project.setMappings(mappings); } @@ -49,14 +51,28 @@ protected static EnigmaProject openProject(Path fileJarIn, Path fileMappings) th return project; } - protected static MappingFormat chooseEnigmaFormat(Path path) { - if (Files.isDirectory(path)) { - return MappingFormat.ENIGMA_DIRECTORY; - } else if ("zip".equalsIgnoreCase(MoreFiles.getFileExtension(path))) { - return MappingFormat.ENIGMA_ZIP; + protected static EntryTree readMappings(Path path, ProgressListener progress, MappingSaveParameters saveParameters) throws Exception { + List suppressed = new ArrayList<>(); + + if ("zip".equalsIgnoreCase(MoreFiles.getFileExtension(path))) { + return MappingFormat.ENIGMA_ZIP.read(path, progress, saveParameters); } else { - return MappingFormat.ENIGMA_FILE; + for (MappingFormat format : MappingFormat.getReadableFormats()) { + try { + return format.read(path, progress, saveParameters); + } catch (Exception e) { + suppressed.add(e); + } + } + } + + RuntimeException exception = new RuntimeException("Unable to parse mappings!"); + + for (Exception suppressedException : suppressed) { + exception.addSuppressed(suppressedException); } + + throw exception; } protected static File getWritableFile(String path) { diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java index 3be804810..ea37db28e 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java @@ -2,6 +2,8 @@ import java.io.IOException; import java.nio.file.Path; +import java.util.Arrays; +import java.util.List; import javax.annotation.Nullable; @@ -66,4 +68,18 @@ public MappingsWriter getWriter() { public MappingsReader getReader() { return reader; } + + public static List getWritableFormats() { + return Arrays.asList(values()) + .stream() + .filter(format -> format.getWriter() != null) + .toList(); + } + + public static List getReadableFormats() { + return Arrays.asList(values()) + .stream() + .filter(format -> format.getReader() != null) + .toList(); + } } From abf42fe48c4f6666cb0e956b9c5ecf630a93718a Mon Sep 17 00:00:00 2001 From: ByMartrixX Date: Thu, 28 Oct 2021 15:52:02 -0300 Subject: [PATCH 2/6] Drop empty mappings when dropping invalid mappings --- .../java/cuchaz/enigma/EnigmaProject.java | 20 ++++++-- .../translation/mapping/MappingsChecker.java | 50 ++++++++++++++++--- 2 files changed, 59 insertions(+), 11 deletions(-) diff --git a/enigma/src/main/java/cuchaz/enigma/EnigmaProject.java b/enigma/src/main/java/cuchaz/enigma/EnigmaProject.java index 15d5e9809..65c3bd6e6 100644 --- a/enigma/src/main/java/cuchaz/enigma/EnigmaProject.java +++ b/enigma/src/main/java/cuchaz/enigma/EnigmaProject.java @@ -7,6 +7,7 @@ import java.nio.file.Files; import java.nio.file.Path; import java.util.Collection; +import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Objects; @@ -110,15 +111,26 @@ public void dropMappings(ProgressListener progress) { private Collection> dropMappings(EntryTree mappings, ProgressListener progress) { // drop mappings that don't match the jar MappingsChecker checker = new MappingsChecker(jarIndex, mappings); - MappingsChecker.Dropped dropped = checker.dropBrokenMappings(progress); + MappingsChecker.Dropped droppedBroken = checker.dropBrokenMappings(progress); - Map, String> droppedMappings = dropped.getDroppedMappings(); + Map, String> droppedBrokenMappings = droppedBroken.getDroppedMappings(); - for (Map.Entry, String> mapping : droppedMappings.entrySet()) { + for (Map.Entry, String> mapping : droppedBrokenMappings.entrySet()) { System.out.println("WARNING: Couldn't find " + mapping.getKey() + " (" + mapping.getValue() + ") in jar. Mapping was dropped."); } - return droppedMappings.keySet(); + MappingsChecker.Dropped droppedEmpty = checker.dropEmptyMappings(progress); + + Map, String> droppedEmptyMappings = droppedEmpty.getDroppedMappings(); + + for (Map.Entry, String> mapping : droppedEmptyMappings.entrySet()) { + System.out.println("WARNING: " + mapping.getKey() + " (" + mapping.getValue() + ") was empty. Mapping was dropped."); + } + + Collection> droppedMappings = new HashSet<>(); + droppedMappings.addAll(droppedBrokenMappings.keySet()); + droppedMappings.addAll(droppedEmptyMappings.keySet()); + return droppedMappings; } public boolean isRenamable(Entry obfEntry) { diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java index dc8055b79..4067d7ddf 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java @@ -14,6 +14,9 @@ import java.util.Collection; import java.util.HashMap; import java.util.Map; +import java.util.function.BiConsumer; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; import cuchaz.enigma.ProgressListener; import cuchaz.enigma.analysis.index.JarIndex; @@ -34,10 +37,14 @@ public MappingsChecker(JarIndex index, EntryTree mappings) { this.mappings = mappings; } - public Dropped dropBrokenMappings(ProgressListener progress) { + private Dropped dropMappings(ProgressListener progress, BiConsumer> dropper) { Dropped dropped = new Dropped(); - Collection> obfEntries = mappings.getAllEntries().filter(e -> e instanceof ClassEntry || e instanceof MethodEntry || e instanceof FieldEntry || e instanceof LocalVariableEntry).toList(); + // HashEntryTree#getAllEntries filters out empty classes + Stream> allEntries = StreamSupport.stream(mappings.spliterator(), false).map(EntryTreeNode::getEntry); + Collection> obfEntries = allEntries + .filter(e -> e instanceof ClassEntry || e instanceof MethodEntry || e instanceof FieldEntry || e instanceof LocalVariableEntry) + .toList(); progress.init(obfEntries.size(), "Checking for dropped mappings"); @@ -45,7 +52,7 @@ public Dropped dropBrokenMappings(ProgressListener progress) { for (Entry entry : obfEntries) { progress.step(steps++, entry.toString()); - tryDropEntry(dropped, entry); + dropper.accept(dropped, entry); } dropped.apply(mappings); @@ -53,8 +60,12 @@ public Dropped dropBrokenMappings(ProgressListener progress) { return dropped; } - private void tryDropEntry(Dropped dropped, Entry entry) { - if (shouldDropEntry(entry)) { + public Dropped dropBrokenMappings(ProgressListener progress) { + return dropMappings(progress, this::tryDropBrokenEntry); + } + + private void tryDropBrokenEntry(Dropped dropped, Entry entry) { + if (shouldDropBrokenEntry(entry)) { EntryMapping mapping = mappings.get(entry); if (mapping != null) { @@ -63,14 +74,14 @@ private void tryDropEntry(Dropped dropped, Entry entry) { } } - private boolean shouldDropEntry(Entry entry) { + private boolean shouldDropBrokenEntry(Entry entry) { if (!index.getEntryIndex().hasEntry(entry)) { return true; } if (entry instanceof LocalVariableEntry localVariableEntry) { // Drop local variables only if the method entry is to be dropped - return shouldDropEntry(localVariableEntry.getParent()); + return shouldDropBrokenEntry(localVariableEntry.getParent()); } Collection> resolvedEntries = index.getEntryResolver().resolveEntry(entry, ResolutionStrategy.RESOLVE_ROOT); @@ -92,6 +103,31 @@ private boolean shouldDropEntry(Entry entry) { return true; } + public Dropped dropEmptyMappings(ProgressListener progress) { + return dropMappings(progress, this::tryDropEmptyEntry); + } + + private void tryDropEmptyEntry(Dropped dropped, Entry entry) { + if (shouldDropEmptyMapping(entry)) { + EntryMapping mapping = mappings.get(entry); + if (mapping != null) { + dropped.drop(entry, mapping); + } + } + } + + private boolean shouldDropEmptyMapping(Entry entry) { + EntryMapping mapping = mappings.get(entry); + if (mapping != null) { + boolean isEmpty = mapping.targetName() == null && mapping.javadoc() == null && mapping.accessModifier() == AccessModifier.UNCHANGED; + if (isEmpty) { + return mappings.getChildren(entry).isEmpty(); + } + } + + return false; + } + public static class Dropped { private final Map, String> droppedMappings = new HashMap<>(); From 923d86b49954f4409e4a326435e84b0a10216114 Mon Sep 17 00:00:00 2001 From: ByMartrixx Date: Sat, 30 Oct 2021 13:22:39 -0300 Subject: [PATCH 3/6] Don't drop static shadow mappings --- .../cuchaz/enigma/translation/mapping/IndexEntryResolver.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/IndexEntryResolver.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/IndexEntryResolver.java index 8dc565996..844817de2 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/IndexEntryResolver.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/IndexEntryResolver.java @@ -53,7 +53,7 @@ public > Collection resolveEntry(E entry, ResolutionStrate return Collections.singleton(entry); } - if (access == null || !access.isPrivate()) { + if (access == null || (!access.isPrivate() && !access.isStatic())) { Collection> resolvedChildren = resolveChildEntry(classChild, strategy); if (!resolvedChildren.isEmpty()) { From d572e99803c0ba53c4cf2365353ce62a65261bc3 Mon Sep 17 00:00:00 2001 From: ByMartrixx Date: Tue, 7 Dec 2021 17:35:54 -0300 Subject: [PATCH 4/6] Drop invalid parameters even when the method is valid --- .../cuchaz/enigma/translation/mapping/MappingsChecker.java | 5 ----- 1 file changed, 5 deletions(-) diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java index 4067d7ddf..369012321 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java @@ -79,11 +79,6 @@ private boolean shouldDropBrokenEntry(Entry entry) { return true; } - if (entry instanceof LocalVariableEntry localVariableEntry) { - // Drop local variables only if the method entry is to be dropped - return shouldDropBrokenEntry(localVariableEntry.getParent()); - } - Collection> resolvedEntries = index.getEntryResolver().resolveEntry(entry, ResolutionStrategy.RESOLVE_ROOT); if (resolvedEntries.isEmpty()) { From fba87e5089485330665bebf7cafa039c59f8c2ae Mon Sep 17 00:00:00 2001 From: ByMartrixx Date: Sat, 27 Nov 2021 21:37:07 -0300 Subject: [PATCH 5/6] Add drop invalid mappings command --- .../java/cuchaz/enigma/command/Command.java | 25 ++++++ .../command/DropInvalidMappingsCommand.java | 88 +++++++++++++++++++ 2 files changed, 113 insertions(+) create mode 100644 enigma-cli/src/main/java/cuchaz/enigma/command/DropInvalidMappingsCommand.java diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/Command.java b/enigma-cli/src/main/java/cuchaz/enigma/command/Command.java index a6712111f..bc193e305 100644 --- a/enigma-cli/src/main/java/cuchaz/enigma/command/Command.java +++ b/enigma-cli/src/main/java/cuchaz/enigma/command/Command.java @@ -75,6 +75,31 @@ protected static EntryTree readMappings(Path path, ProgressListene throw exception; } + protected static void writeMappings(EntryTree mappings, Path path, ProgressListener progress, MappingSaveParameters saveParameters) throws Exception { + List suppressed = new ArrayList<>(); + + if ("zip".equalsIgnoreCase(MoreFiles.getFileExtension(path))) { + MappingFormat.ENIGMA_ZIP.write(mappings, path, progress, saveParameters); + } else { + for (MappingFormat format : MappingFormat.getWritableFormats()) { + try { + format.write(mappings, path, progress, saveParameters); + return; + } catch (Exception e) { + suppressed.add(e); + } + } + } + + RuntimeException exception = new RuntimeException("Unable to write mappings!"); + + for (Exception suppressedException : suppressed) { + exception.addSuppressed(suppressedException); + } + + throw exception; + } + protected static File getWritableFile(String path) { if (path == null) { return null; diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/DropInvalidMappingsCommand.java b/enigma-cli/src/main/java/cuchaz/enigma/command/DropInvalidMappingsCommand.java new file mode 100644 index 000000000..b508c1c46 --- /dev/null +++ b/enigma-cli/src/main/java/cuchaz/enigma/command/DropInvalidMappingsCommand.java @@ -0,0 +1,88 @@ +package cuchaz.enigma.command; + +import cuchaz.enigma.Enigma; +import cuchaz.enigma.EnigmaProject; +import cuchaz.enigma.ProgressListener; +import cuchaz.enigma.classprovider.ClasspathClassProvider; +import cuchaz.enigma.translation.mapping.EntryMapping; +import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters; +import cuchaz.enigma.translation.mapping.tree.EntryTree; + +import java.io.IOException; +import java.nio.file.FileVisitResult; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.SimpleFileVisitor; +import java.nio.file.attribute.BasicFileAttributes; + +public class DropInvalidMappingsCommand extends Command { + public DropInvalidMappingsCommand() { + super("drop-invalid-mappings"); + } + + @Override + public String getUsage() { + return " []"; + } + + @Override + public boolean isValidArgument(int length) { + return length==3; + } + + @Override + public void run(String... args) throws Exception { + Path fileJarIn = getReadableFile(getArg(args, 0, "in jar", true)).toPath(); + Path fileMappingsIn = getReadablePath(getArg(args, 1, "mappings in", true)); + if (fileMappingsIn == null) { + System.out.println("No mappings input specified, skipping."); + return; + } + + String mappingsOut = getArg(args, 2, "mappings out", false); + Path fileMappingsOut = mappingsOut != null && !mappingsOut.isEmpty() ? getReadablePath(mappingsOut) : fileMappingsIn; + + Enigma enigma = Enigma.create(); + + System.out.println("Reading JAR..."); + + EnigmaProject project = enigma.openJar(fileJarIn, new ClasspathClassProvider(), ProgressListener.none()); + + System.out.println("Reading mappings..."); + + MappingSaveParameters saveParameters = enigma.getProfile().getMappingSaveParameters(); + + EntryTree mappings = readMappings(fileMappingsIn, ProgressListener.none(), saveParameters); + project.setMappings(mappings); + + System.out.println("Dropping invalid mappings..."); + + project.dropMappings(ProgressListener.none()); + + System.out.println("Writing mappings..."); + + if (fileMappingsOut == fileMappingsIn) { + System.out.println("Overwriting input mappings"); + Files.walkFileTree(fileMappingsIn, new SimpleFileVisitor<>() { + @Override + public FileVisitResult postVisitDirectory( + Path dir, IOException exc) throws IOException { + Files.delete(dir); + return FileVisitResult.CONTINUE; + } + + @Override + public FileVisitResult visitFile( + Path file, BasicFileAttributes attrs) + throws IOException { + Files.delete(file); + return FileVisitResult.CONTINUE; + } + }); + + Files.deleteIfExists(fileMappingsIn); + } + + writeMappings(project.getMapper().getObfToDeobf(), fileMappingsOut, ProgressListener.none(), saveParameters); + } +} From cf90562083314a59532552c6e9e28a8c135253f6 Mon Sep 17 00:00:00 2001 From: NebelNidas Date: Sat, 24 Sep 2022 15:53:17 +0200 Subject: [PATCH 6/6] Fix checkstyle --- .../command/DropInvalidMappingsCommand.java | 148 +++++++++--------- .../translation/mapping/MappingsChecker.java | 3 + 2 files changed, 75 insertions(+), 76 deletions(-) diff --git a/enigma-cli/src/main/java/cuchaz/enigma/command/DropInvalidMappingsCommand.java b/enigma-cli/src/main/java/cuchaz/enigma/command/DropInvalidMappingsCommand.java index b508c1c46..9a6e204d1 100644 --- a/enigma-cli/src/main/java/cuchaz/enigma/command/DropInvalidMappingsCommand.java +++ b/enigma-cli/src/main/java/cuchaz/enigma/command/DropInvalidMappingsCommand.java @@ -1,5 +1,12 @@ package cuchaz.enigma.command; +import java.io.IOException; +import java.nio.file.FileVisitResult; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.SimpleFileVisitor; +import java.nio.file.attribute.BasicFileAttributes; + import cuchaz.enigma.Enigma; import cuchaz.enigma.EnigmaProject; import cuchaz.enigma.ProgressListener; @@ -8,81 +15,70 @@ import cuchaz.enigma.translation.mapping.serde.MappingSaveParameters; import cuchaz.enigma.translation.mapping.tree.EntryTree; -import java.io.IOException; -import java.nio.file.FileVisitResult; -import java.nio.file.Files; -import java.nio.file.Path; -import java.nio.file.SimpleFileVisitor; -import java.nio.file.attribute.BasicFileAttributes; - public class DropInvalidMappingsCommand extends Command { - public DropInvalidMappingsCommand() { - super("drop-invalid-mappings"); - } - - @Override - public String getUsage() { - return " []"; - } - - @Override - public boolean isValidArgument(int length) { - return length==3; - } - - @Override - public void run(String... args) throws Exception { - Path fileJarIn = getReadableFile(getArg(args, 0, "in jar", true)).toPath(); - Path fileMappingsIn = getReadablePath(getArg(args, 1, "mappings in", true)); - if (fileMappingsIn == null) { - System.out.println("No mappings input specified, skipping."); - return; - } - - String mappingsOut = getArg(args, 2, "mappings out", false); - Path fileMappingsOut = mappingsOut != null && !mappingsOut.isEmpty() ? getReadablePath(mappingsOut) : fileMappingsIn; - - Enigma enigma = Enigma.create(); - - System.out.println("Reading JAR..."); - - EnigmaProject project = enigma.openJar(fileJarIn, new ClasspathClassProvider(), ProgressListener.none()); - - System.out.println("Reading mappings..."); - - MappingSaveParameters saveParameters = enigma.getProfile().getMappingSaveParameters(); - - EntryTree mappings = readMappings(fileMappingsIn, ProgressListener.none(), saveParameters); - project.setMappings(mappings); - - System.out.println("Dropping invalid mappings..."); - - project.dropMappings(ProgressListener.none()); - - System.out.println("Writing mappings..."); - - if (fileMappingsOut == fileMappingsIn) { - System.out.println("Overwriting input mappings"); - Files.walkFileTree(fileMappingsIn, new SimpleFileVisitor<>() { - @Override - public FileVisitResult postVisitDirectory( - Path dir, IOException exc) throws IOException { - Files.delete(dir); - return FileVisitResult.CONTINUE; - } - - @Override - public FileVisitResult visitFile( - Path file, BasicFileAttributes attrs) - throws IOException { - Files.delete(file); - return FileVisitResult.CONTINUE; - } - }); - - Files.deleteIfExists(fileMappingsIn); - } - - writeMappings(project.getMapper().getObfToDeobf(), fileMappingsOut, ProgressListener.none(), saveParameters); - } + public DropInvalidMappingsCommand() { + super("drop-invalid-mappings"); + } + + @Override + public String getUsage() { + return " []"; + } + + @Override + public boolean isValidArgument(int length) { + return length == 3; + } + + @Override + public void run(String... args) throws Exception { + Path fileJarIn = getReadableFile(getArg(args, 0, "in jar", true)).toPath(); + Path fileMappingsIn = getReadablePath(getArg(args, 1, "mappings in", true)); + + if (fileMappingsIn == null) { + System.out.println("No mappings input specified, skipping."); + return; + } + + String mappingsOut = getArg(args, 2, "mappings out", false); + Path fileMappingsOut = mappingsOut != null && !mappingsOut.isEmpty() ? getReadablePath(mappingsOut) : fileMappingsIn; + Enigma enigma = Enigma.create(); + + System.out.println("Reading JAR..."); + EnigmaProject project = enigma.openJar(fileJarIn, new ClasspathClassProvider(), ProgressListener.none()); + + System.out.println("Reading mappings..."); + MappingSaveParameters saveParameters = enigma.getProfile().getMappingSaveParameters(); + EntryTree mappings = readMappings(fileMappingsIn, ProgressListener.none(), saveParameters); + project.setMappings(mappings); + + System.out.println("Dropping invalid mappings..."); + project.dropMappings(ProgressListener.none()); + + System.out.println("Writing mappings..."); + + if (fileMappingsOut == fileMappingsIn) { + System.out.println("Overwriting input mappings"); + Files.walkFileTree(fileMappingsIn, new SimpleFileVisitor<>() { + @Override + public FileVisitResult postVisitDirectory( + Path dir, IOException exc) throws IOException { + Files.delete(dir); + return FileVisitResult.CONTINUE; + } + + @Override + public FileVisitResult visitFile( + Path file, BasicFileAttributes attrs) + throws IOException { + Files.delete(file); + return FileVisitResult.CONTINUE; + } + }); + + Files.deleteIfExists(fileMappingsIn); + } + + writeMappings(project.getMapper().getObfToDeobf(), fileMappingsOut, ProgressListener.none(), saveParameters); + } } diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java index 369012321..f860d4519 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java @@ -105,6 +105,7 @@ public Dropped dropEmptyMappings(ProgressListener progress) { private void tryDropEmptyEntry(Dropped dropped, Entry entry) { if (shouldDropEmptyMapping(entry)) { EntryMapping mapping = mappings.get(entry); + if (mapping != null) { dropped.drop(entry, mapping); } @@ -113,8 +114,10 @@ private void tryDropEmptyEntry(Dropped dropped, Entry entry) { private boolean shouldDropEmptyMapping(Entry entry) { EntryMapping mapping = mappings.get(entry); + if (mapping != null) { boolean isEmpty = mapping.targetName() == null && mapping.javadoc() == null && mapping.accessModifier() == AccessModifier.UNCHANGED; + if (isEmpty) { return mappings.getChildren(entry).isEmpty(); }