Merge pull request #463 from NebelNidas/mapping-io

Initial Mapping-IO support

12 files changed, 428 insertions, 64 deletions

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 367af3b..4521591 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
@@ -1,11 +1,22 @@
 package cuchaz.enigma.translation.mapping.serde;
 
 import java.io.IOException;
+import java.io.UncheckedIOException;
 import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.List;
 
 import javax.annotation.Nullable;
 
+import net.fabricmc.mappingio.MappingReader;
+import net.fabricmc.mappingio.MappingWriter;
+import net.fabricmc.mappingio.tree.MemoryMappingTree;
+import net.fabricmc.mappingio.tree.VisitOrder;
+import net.fabricmc.mappingio.tree.VisitableMappingTree;
+import org.jetbrains.annotations.ApiStatus;
+
 import cuchaz.enigma.ProgressListener;
+import cuchaz.enigma.analysis.index.JarIndex;
 import cuchaz.enigma.translation.mapping.EntryMapping;
 import cuchaz.enigma.translation.mapping.MappingDelta;
 import cuchaz.enigma.translation.mapping.serde.enigma.EnigmaMappingsReader;
@@ -19,23 +30,33 @@ import cuchaz.enigma.translation.mapping.serde.tiny.TinyMappingsWriter;
 import cuchaz.enigma.translation.mapping.serde.tinyv2.TinyV2Reader;
 import cuchaz.enigma.translation.mapping.serde.tinyv2.TinyV2Writer;
 import cuchaz.enigma.translation.mapping.tree.EntryTree;
+import cuchaz.enigma.utils.I18n;
 
 public enum MappingFormat {
-        ENIGMA_FILE(EnigmaMappingsWriter.FILE, EnigmaMappingsReader.FILE),
-        ENIGMA_DIRECTORY(EnigmaMappingsWriter.DIRECTORY, EnigmaMappingsReader.DIRECTORY),
-        ENIGMA_ZIP(EnigmaMappingsWriter.ZIP, EnigmaMappingsReader.ZIP),
-        TINY_V2(new TinyV2Writer("intermediary", "named"), new TinyV2Reader()),
-        TINY_FILE(TinyMappingsWriter.INSTANCE, TinyMappingsReader.INSTANCE),
-        SRG_FILE(SrgMappingsWriter.INSTANCE, null),
-        PROGUARD(null, ProguardMappingsReader.INSTANCE),
-        RECAF(RecafMappingsWriter.INSTANCE, RecafMappingsReader.INSTANCE);
+        ENIGMA_FILE(EnigmaMappingsWriter.FILE, EnigmaMappingsReader.FILE, net.fabricmc.mappingio.format.MappingFormat.ENIGMA_FILE, true),
+        ENIGMA_DIRECTORY(EnigmaMappingsWriter.DIRECTORY, EnigmaMappingsReader.DIRECTORY, net.fabricmc.mappingio.format.MappingFormat.ENIGMA_DIR, true),
+        ENIGMA_ZIP(EnigmaMappingsWriter.ZIP, EnigmaMappingsReader.ZIP, null, false),
+        TINY_V2(new TinyV2Writer("intermediary", "named"), new TinyV2Reader(), net.fabricmc.mappingio.format.MappingFormat.TINY_2_FILE, true),
+        TINY_FILE(TinyMappingsWriter.INSTANCE, TinyMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.TINY_FILE, true),
+        SRG_FILE(SrgMappingsWriter.INSTANCE, null, net.fabricmc.mappingio.format.MappingFormat.SRG_FILE, true),
+        XSRG_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.XSRG_FILE, true),
+        CSRG_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.CSRG_FILE, false),
+        TSRG_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG_FILE, false),
+        TSRG_2_FILE(null, null, net.fabricmc.mappingio.format.MappingFormat.TSRG_2_FILE, false),
+        PROGUARD(null, ProguardMappingsReader.INSTANCE, net.fabricmc.mappingio.format.MappingFormat.PROGUARD_FILE, true),
+        RECAF(RecafMappingsWriter.INSTANCE, RecafMappingsReader.INSTANCE, null, false);
 
         private final MappingsWriter writer;
         private final MappingsReader reader;
+        private final net.fabricmc.mappingio.format.MappingFormat mappingIoCounterpart;
+        private final boolean hasMappingIoWriter;
+        private boolean lastUsedMappingIoWriter;
 
-        MappingFormat(MappingsWriter writer, MappingsReader reader) {
+        MappingFormat(MappingsWriter writer, MappingsReader reader, net.fabricmc.mappingio.format.MappingFormat mappingIoCounterpart, boolean hasMappingIoWriter) {
                 this.writer = writer;
                 this.reader = reader;
+                this.mappingIoCounterpart = mappingIoCounterpart;
+                this.hasMappingIoWriter = hasMappingIoWriter;
         }
 
         public void write(EntryTree<EntryMapping> mappings, Path path, ProgressListener progressListener, MappingSaveParameters saveParameters) {
@@ -43,19 +64,56 @@ public enum MappingFormat {
         }
 
         public void write(EntryTree<EntryMapping> mappings, MappingDelta<EntryMapping> delta, Path path, ProgressListener progressListener, MappingSaveParameters saveParameters) {
-                if (writer == null) {
-                        throw new IllegalStateException(name() + " does not support writing");
+                if (!hasMappingIoWriter || !useMappingIo()) {
+                        if (writer == null) {
+                                throw new IllegalStateException(name() + " does not support writing");
+                        }
+
+                        writer.write(mappings, lastUsedMappingIoWriter ? MappingDelta.added(mappings) : delta, path, progressListener, saveParameters);
+                        lastUsedMappingIoWriter = false;
+                        return;
                 }
 
-                writer.write(mappings, delta, path, progressListener, saveParameters);
+                try {
+                        VisitableMappingTree tree = MappingIoConverter.toMappingIo(mappings, progressListener);
+                        progressListener.init(1, I18n.translate("progress.mappings.writing"));
+                        progressListener.step(1, null); // Reset message
+
+                        tree.accept(MappingWriter.create(path, mappingIoCounterpart), VisitOrder.createByName());
+                        progressListener.step(1, I18n.translate("progress.done"));
+                        lastUsedMappingIoWriter = true;
+                } catch (IOException e) {
+                        throw new UncheckedIOException(e);
+                }
         }
 
+        @Deprecated
         public EntryTree<EntryMapping> read(Path path, ProgressListener progressListener, MappingSaveParameters saveParameters) throws IOException, MappingParseException {
-                if (reader == null) {
-                        throw new IllegalStateException(name() + " does not support reading");
+                return read(path, progressListener, saveParameters, null);
+        }
+
+        public EntryTree<EntryMapping> read(Path path, ProgressListener progressListener, MappingSaveParameters saveParameters, JarIndex index) throws IOException, MappingParseException {
+                if (!useMappingIo()) {
+                        if (reader == null) {
+                                throw new IllegalStateException(name() + " does not support reading");
+                        }
+
+                        return reader.read(path, progressListener, saveParameters);
                 }
 
-                return reader.read(path, progressListener, saveParameters);
+                String loadingMessage;
+
+                if (mappingIoCounterpart.hasSingleFile()) {
+                        loadingMessage = I18n.translate("progress.mappings.loading_file");
+                } else {
+                        loadingMessage = I18n.translate("progress.mappings.loading_directory");
+                }
+
+                progressListener.init(1, loadingMessage);
+
+                VisitableMappingTree mappingTree = new MemoryMappingTree();
+                MappingReader.read(path, mappingIoCounterpart, mappingTree);
+                return MappingIoConverter.fromMappingIo(mappingTree, progressListener, index);
         }
 
         @Nullable
@@ -67,4 +125,43 @@ public enum MappingFormat {
         public MappingsReader getReader() {
                 return reader;
         }
+
+        @Nullable
+        @ApiStatus.Internal
+        public net.fabricmc.mappingio.format.MappingFormat getMappingIoCounterpart() {
+                return mappingIoCounterpart;
+        }
+
+        @ApiStatus.Internal
+        public boolean hasMappingIoWriter() {
+                return hasMappingIoWriter;
+        }
+
+        public boolean isReadable() {
+                return reader != null || mappingIoCounterpart != null;
+        }
+
+        public boolean isWritable() {
+                return writer != null || hasMappingIoWriter;
+        }
+
+        @ApiStatus.Internal
+        private boolean useMappingIo() {
+                if (mappingIoCounterpart == null) return false;
+                return System.getProperty("enigma.use_mappingio", "true").equals("true");
+        }
+
+        public static List<MappingFormat> getReadableFormats() {
+                return Arrays.asList(values())
+                                .stream()
+                                .filter(MappingFormat::isReadable)
+                                .toList();
+        }
+
+        public static List<MappingFormat> getWritableFormats() {
+                return Arrays.asList(values())
+                                .stream()
+                                .filter(MappingFormat::isWritable)
+                                .toList();
+        }
 }
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java
new file mode 100644
index 0000000..3843d8e
--- /dev/null
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingIoConverter.java
@@ -0,0 +1,279 @@
+package cuchaz.enigma.translation.mapping.serde;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.StreamSupport;
+
+import javax.annotation.Nullable;
+
+import org.jetbrains.annotations.ApiStatus;
+import net.fabricmc.mappingio.MappedElementKind;
+import net.fabricmc.mappingio.tree.MemoryMappingTree;
+import net.fabricmc.mappingio.tree.VisitableMappingTree;
+import net.fabricmc.mappingio.tree.MappingTree.ClassMapping;
+import net.fabricmc.mappingio.tree.MappingTree.FieldMapping;
+import net.fabricmc.mappingio.tree.MappingTree.MethodArgMapping;
+import net.fabricmc.mappingio.tree.MappingTree.MethodMapping;
+import net.fabricmc.mappingio.tree.MappingTree.MethodVarMapping;
+
+import cuchaz.enigma.ProgressListener;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.translation.mapping.EntryMap;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.tree.EntryTree;
+import cuchaz.enigma.translation.mapping.tree.EntryTreeNode;
+import cuchaz.enigma.translation.mapping.tree.HashEntryTree;
+import cuchaz.enigma.translation.representation.MethodDescriptor;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.Entry;
+import cuchaz.enigma.translation.representation.entry.FieldEntry;
+import cuchaz.enigma.translation.representation.entry.LocalVariableEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+import cuchaz.enigma.utils.I18n;
+
+@ApiStatus.Internal
+public class MappingIoConverter {
+        public static VisitableMappingTree toMappingIo(EntryTree<EntryMapping> mappings, ProgressListener progress) {
+                return toMappingIo(mappings, progress, "intermediary", "named");
+        }
+
+        public static VisitableMappingTree toMappingIo(EntryTree<EntryMapping> mappings, ProgressListener progress, String fromNs, String toNs) {
+                try {
+                        List<EntryTreeNode<EntryMapping>> classes = StreamSupport.stream(mappings.spliterator(), false)
+                                        .filter(node -> node.getEntry() instanceof ClassEntry)
+                                        .toList();
+
+                        progress.init(classes.size(), I18n.translate("progress.mappings.converting.to_mappingio"));
+                        int stepsDone = 0;
+
+                        MemoryMappingTree mappingTree = new MemoryMappingTree();
+                        mappingTree.visitNamespaces(fromNs, List.of(toNs));
+
+                        for (EntryTreeNode<EntryMapping> classNode : classes) {
+                                progress.step(++stepsDone, classNode.getEntry().getFullName());
+                                writeClass(classNode, mappings, mappingTree);
+                        }
+
+                        mappingTree.visitEnd();
+                        return mappingTree;
+                } catch (IOException e) {
+                        throw new UncheckedIOException(e);
+                }
+        }
+
+        private static void writeClass(EntryTreeNode<EntryMapping> classNode, EntryMap<EntryMapping> oldMappingTree, VisitableMappingTree newMappingTree) throws IOException {
+                ClassEntry classEntry = (ClassEntry) classNode.getEntry();
+                EntryMapping mapping = oldMappingTree.get(classEntry);
+                Deque<String> parts = new LinkedList<>();
+
+                newMappingTree.visitClass(classEntry.getFullName());
+                newMappingTree.visitComment(MappedElementKind.CLASS, mapping.javadoc());
+
+                do {
+                        mapping = oldMappingTree.get(classEntry);
+
+                        if (mapping != null && mapping.targetName() != null) {
+                                parts.addFirst(mapping.targetName());
+                        } else {
+                                parts.addFirst(classEntry.getName());
+                        }
+
+                        classEntry = classEntry.getOuterClass();
+                } while (classEntry != null);
+
+                String mappedName = String.join("$", parts);
+                newMappingTree.visitDstName(MappedElementKind.CLASS, 0, mappedName);
+
+                for (EntryTreeNode<EntryMapping> child : classNode.getChildNodes()) {
+                        Entry<?> entry = child.getEntry();
+
+                        if (entry instanceof FieldEntry) {
+                                writeField(child, newMappingTree);
+                        } else if (entry instanceof MethodEntry) {
+                                writeMethod(child, newMappingTree);
+                        }
+                }
+        }
+
+        private static void writeField(EntryTreeNode<EntryMapping> fieldNode, VisitableMappingTree mappingTree) throws IOException {
+                if (fieldNode.getValue() == null || fieldNode.getValue().equals(EntryMapping.DEFAULT)) {
+                        return; // Shortcut
+                }
+
+                FieldEntry fieldEntry = ((FieldEntry) fieldNode.getEntry());
+                mappingTree.visitField(fieldEntry.getName(), fieldEntry.getDesc().toString());
+
+                EntryMapping fieldMapping = fieldNode.getValue();
+
+                if (fieldMapping == null) {
+                        fieldMapping = EntryMapping.DEFAULT;
+                }
+
+                mappingTree.visitDstName(MappedElementKind.FIELD, 0, fieldMapping.targetName());
+                mappingTree.visitComment(MappedElementKind.FIELD, fieldMapping.javadoc());
+        }
+
+        private static void writeMethod(EntryTreeNode<EntryMapping> methodNode, VisitableMappingTree mappingTree) throws IOException {
+                MethodEntry methodEntry = ((MethodEntry) methodNode.getEntry());
+                mappingTree.visitMethod(methodEntry.getName(), methodEntry.getDesc().toString());
+
+                EntryMapping methodMapping = methodNode.getValue();
+
+                if (methodMapping == null) {
+                        methodMapping = EntryMapping.DEFAULT;
+                }
+
+                mappingTree.visitDstName(MappedElementKind.METHOD, 0, methodMapping.targetName());
+                mappingTree.visitComment(MappedElementKind.METHOD, methodMapping.javadoc());
+
+                for (EntryTreeNode<EntryMapping> child : methodNode.getChildNodes()) {
+                        Entry<?> entry = child.getEntry();
+
+                        if (entry instanceof LocalVariableEntry local) {
+                                if (local.isArgument()) {
+                                        writeMethodArg(child, mappingTree);
+                                } else {
+                                        writeMethodVar(child, mappingTree);
+                                }
+                        }
+                }
+        }
+
+        private static void writeMethodArg(EntryTreeNode<EntryMapping> argNode, VisitableMappingTree mappingTree) throws IOException {
+                if (argNode.getValue() == null || argNode.getValue().equals(EntryMapping.DEFAULT)) {
+                        return; // Shortcut
+                }
+
+                LocalVariableEntry argEntry = ((LocalVariableEntry) argNode.getEntry());
+                mappingTree.visitMethodArg(-1, argEntry.getIndex(), argEntry.getName());
+
+                EntryMapping argMapping = argNode.getValue();
+
+                if (argMapping == null) {
+                        argMapping = EntryMapping.DEFAULT;
+                }
+
+                mappingTree.visitDstName(MappedElementKind.METHOD_ARG, 0, argMapping.targetName());
+                mappingTree.visitComment(MappedElementKind.METHOD_ARG, argMapping.javadoc());
+        }
+
+        private static void writeMethodVar(EntryTreeNode<EntryMapping> varNode, VisitableMappingTree mappingTree) throws IOException {
+                if (varNode.getValue() == null || varNode.getValue().equals(EntryMapping.DEFAULT)) {
+                        return; // Shortcut
+                }
+
+                LocalVariableEntry varEntry = ((LocalVariableEntry) varNode.getEntry());
+                mappingTree.visitMethodVar(-1, varEntry.getIndex(), -1, -1, varEntry.getName());
+
+                EntryMapping varMapping = varNode.getValue();
+
+                if (varMapping == null) {
+                        varMapping = EntryMapping.DEFAULT;
+                }
+
+                mappingTree.visitDstName(MappedElementKind.METHOD_VAR, 0, varMapping.targetName());
+                mappingTree.visitComment(MappedElementKind.METHOD_VAR, varMapping.javadoc());
+        }
+
+        public static EntryTree<EntryMapping> fromMappingIo(VisitableMappingTree mappingTree, ProgressListener progress, @Nullable JarIndex index) {
+                EntryTree<EntryMapping> dstMappingTree = new HashEntryTree<>();
+                progress.init(mappingTree.getClasses().size(), I18n.translate("progress.mappings.converting.from_mappingio"));
+                int steps = 0;
+
+                for (ClassMapping classMapping : mappingTree.getClasses()) {
+                        progress.step(steps++, classMapping.getDstName(0) != null ? classMapping.getDstName(0) : classMapping.getSrcName());
+                        readClass(classMapping, dstMappingTree, index);
+                }
+
+                return dstMappingTree;
+        }
+
+        private static void readClass(ClassMapping classMapping, EntryTree<EntryMapping> mappingTree, JarIndex index) {
+                ClassEntry currentClass = new ClassEntry(classMapping.getSrcName());
+                String dstName = classMapping.getDstName(0);
+
+                if (dstName != null) {
+                        dstName = dstName.substring(dstName.lastIndexOf('$') + 1);
+                }
+
+                mappingTree.insert(currentClass, new EntryMapping(dstName, classMapping.getComment()));
+
+                for (FieldMapping fieldMapping : classMapping.getFields()) {
+                        readField(fieldMapping, currentClass, mappingTree, index);
+                }
+
+                for (MethodMapping methodMapping : classMapping.getMethods()) {
+                        readMethod(methodMapping, currentClass, mappingTree);
+                }
+        }
+
+        private static void readField(FieldMapping fieldMapping, ClassEntry parent, EntryTree<EntryMapping> mappingTree, JarIndex index) {
+                String srcDesc = fieldMapping.getSrcDesc();
+                FieldEntry[] fieldEntries;
+
+                if (srcDesc != null) {
+                        fieldEntries = new FieldEntry[] { new FieldEntry(parent, fieldMapping.getSrcName(), new TypeDescriptor(fieldMapping.getSrcDesc())) };
+                } else {
+                        if (index == null) return; // Enigma requires source descriptors, and without an index we can't look them up
+
+                        fieldEntries = index.getChildrenByClass().get(parent).stream()
+                                        .filter(entry -> entry instanceof FieldEntry)
+                                        .filter(entry -> entry.getName().equals(fieldMapping.getSrcName()))
+                                        .toArray(FieldEntry[]::new);
+
+                        if (fieldEntries.length == 0) { // slow path for synthetics
+                                fieldEntries = index.getEntryIndex().getFields().stream()
+                                                .filter(entry -> entry.getParent().getFullName().equals(parent.getFullName()))
+                                                .filter(entry -> {
+                                                        if (entry.getName().equals(fieldMapping.getSrcName())) {
+                                                                return true;
+                                                        } else {
+                                                                System.out.println("Entry name: " + entry.getName() + ", mapping name: " + fieldMapping.getSrcName());
+                                                                return false;
+                                                        }
+                                                })
+                                                .toArray(FieldEntry[]::new);
+                        }
+
+                        if (fieldEntries.length == 0) return; // No target found, invalid mapping
+                }
+
+                for (FieldEntry fieldEntry : fieldEntries) {
+                        mappingTree.insert(fieldEntry, new EntryMapping(fieldMapping.getDstName(0), fieldMapping.getComment()));
+                }
+        }
+
+        private static void readMethod(MethodMapping methodMapping, ClassEntry parent, EntryTree<EntryMapping> mappingTree) {
+                MethodEntry currentMethod;
+                mappingTree.insert(currentMethod = new MethodEntry(parent, methodMapping.getSrcName(), new MethodDescriptor(methodMapping.getSrcDesc())),
+                                new EntryMapping(methodMapping.getDstName(0), methodMapping.getComment()));
+
+                for (MethodArgMapping argMapping : methodMapping.getArgs()) {
+                        readMethodArg(argMapping, currentMethod, mappingTree);
+                }
+
+                for (MethodVarMapping varMapping : methodMapping.getVars()) {
+                        readMethodVar(varMapping, currentMethod, mappingTree);
+                }
+        }
+
+        private static void readMethodArg(MethodArgMapping argMapping, MethodEntry parent, EntryTree<EntryMapping> mappingTree) {
+                String srcName = argMapping.getSrcName() != null ? argMapping.getSrcName() : "";
+
+                mappingTree.insert(
+                                new LocalVariableEntry(parent, argMapping.getLvIndex(), srcName, true, null),
+                                new EntryMapping(argMapping.getDstName(0), argMapping.getComment()));
+        }
+
+        private static void readMethodVar(MethodVarMapping varMapping, MethodEntry parent, EntryTree<EntryMapping> mappingTree) {
+                String srcName = varMapping.getSrcName() != null ? varMapping.getSrcName() : "";
+
+                mappingTree.insert(
+                                new LocalVariableEntry(parent, varMapping.getLvIndex(), srcName, false, null),
+                                new EntryMapping(varMapping.getDstName(0), varMapping.getComment()));
+        }
+}
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsReader.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsReader.java
index 5461342..d5570e9 100644
--- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsReader.java
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsReader.java
@@ -40,12 +40,12 @@ public enum EnigmaMappingsReader implements MappingsReader {
         FILE {
                 @Override
                 public EntryTree<EntryMapping> read(Path path, ProgressListener progress, MappingSaveParameters saveParameters) throws IOException, MappingParseException {
-                        progress.init(1, I18n.translate("progress.mappings.enigma_file.loading"));
+                        progress.init(1, I18n.translate("progress.mappings.loading_file"));
 
                         EntryTree<EntryMapping> mappings = new HashEntryTree<>();
                         readFile(path, mappings);
 
-                        progress.step(1, I18n.translate("progress.mappings.enigma_file.done"));
+                        progress.step(1, I18n.translate("progress.done"));
 
                         return mappings;
                 }
@@ -60,7 +60,7 @@ public enum EnigmaMappingsReader implements MappingsReader {
                         EntryTree<EntryMapping> mappings = new HashEntryTree<>();
                         List<Path> files = Files.walk(root).filter(f -> !Files.isDirectory(f)).filter(f -> f.toString().endsWith(".mapping")).toList();
 
-                        progress.init(files.size(), I18n.translate("progress.mappings.enigma_directory.loading"));
+                        progress.init(files.size(), I18n.translate("progress.mappings.loading_directory"));
                         int step = 0;
 
                         for (Path file : files) {
@@ -102,7 +102,7 @@ public enum EnigmaMappingsReader implements MappingsReader {
                         throw new IllegalArgumentException("No paths to read mappings from");
                 }
 
-                progress.init(paths.length, I18n.translate("progress.mappings.enigma_directory.loading"));
+                progress.init(paths.length, I18n.translate("progress.mappings.loading_directory"));
                 int step = 0;
 
                 for (Path file : paths) {
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsWriter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsWriter.java
index df1af91..73f29a1 100644
--- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsWriter.java
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/enigma/EnigmaMappingsWriter.java
@@ -58,7 +58,7 @@ public enum EnigmaMappingsWriter implements MappingsWriter {
                 public void write(EntryTree<EntryMapping> mappings, MappingDelta<EntryMapping> delta, Path path, ProgressListener progress, MappingSaveParameters saveParameters) {
                         Collection<ClassEntry> classes = mappings.getRootNodes().filter(entry -> entry.getEntry() instanceof ClassEntry).map(entry -> (ClassEntry) entry.getEntry()).toList();
 
-                        progress.init(classes.size(), I18n.translate("progress.mappings.enigma_file.writing"));
+                        progress.init(classes.size(), I18n.translate("progress.mappings.writing"));
 
                         int steps = 0;
 
@@ -78,11 +78,9 @@ public enum EnigmaMappingsWriter implements MappingsWriter {
                         Collection<ClassEntry> changedClasses = delta.getChangedRoots().filter(entry -> entry instanceof ClassEntry).map(entry -> (ClassEntry) entry).toList();
 
                         applyDeletions(path, changedClasses, mappings, delta.getBaseMappings(), saveParameters.getFileNameFormat());
-
                         changedClasses = changedClasses.stream().filter(entry -> !isClassEmpty(mappings, entry)).collect(Collectors.toList());
 
-                        progress.init(changedClasses.size(), I18n.translate("progress.mappings.enigma_directory.writing"));
-
+                        progress.init(changedClasses.size(), I18n.translate("progress.mappings.writing"));
                         AtomicInteger steps = new AtomicInteger();
 
                         Translator translator = new MappingTranslator(mappings, VoidEntryResolver.INSTANCE);
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/srg/SrgMappingsWriter.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/srg/SrgMappingsWriter.java
index 4621efe..5addcad 100644
--- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/srg/SrgMappingsWriter.java
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/srg/SrgMappingsWriter.java
@@ -45,7 +45,7 @@ public enum SrgMappingsWriter implements MappingsWriter {
                 List<String> methodLines = new ArrayList<>();
 
                 List<? extends Entry<?>> rootEntries = Lists.newArrayList(mappings).stream().map(EntryTreeNode::getEntry).toList();
-                progress.init(rootEntries.size(), I18n.translate("progress.mappings.srg_file.generating"));
+                progress.init(rootEntries.size(), I18n.translate("progress.mappings.converting"));
 
                 int steps = 0;
 
@@ -54,7 +54,7 @@ public enum SrgMappingsWriter implements MappingsWriter {
                         writeEntry(classLines, fieldLines, methodLines, mappings, entry);
                 }
 
-                progress.init(3, I18n.translate("progress.mappings.srg_file.writing"));
+                progress.init(3, I18n.translate("progress.mappings.writing"));
 
                 try (PrintWriter writer = new LfPrintWriter(Files.newBufferedWriter(path))) {
                         progress.step(0, I18n.translate("type.classes"));
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsReader.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsReader.java
index 534a567..1575f46 100644
--- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsReader.java
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tiny/TinyMappingsReader.java
@@ -35,7 +35,7 @@ public enum TinyMappingsReader implements MappingsReader {
                 EntryTree<EntryMapping> mappings = new HashEntryTree<>();
                 lines.remove(0);
 
-                progress.init(lines.size(), I18n.translate("progress.mappings.tiny_file.loading"));
+                progress.init(lines.size(), I18n.translate("progress.mappings.loading_file"));
 
                 for (int lineNumber = 0; lineNumber < lines.size(); lineNumber++) {
                         progress.step(lineNumber, "");
diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Reader.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Reader.java
index eecbc35..28185f5 100644
--- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Reader.java
+++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/serde/tinyv2/TinyV2Reader.java
@@ -46,7 +46,7 @@ public final class TinyV2Reader implements MappingsReader {
         private EntryTree<EntryMapping> read(Path path, List<String> lines, ProgressListener progress) throws MappingParseException {
                 EntryTree<EntryMapping> mappings = new HashEntryTree<>();
 
-                progress.init(lines.size(), "progress.mappings.tiny_v2.loading");
+                progress.init(lines.size(), "progress.mappings.loading_file");
 
                 BitSet state = new BitSet(STATE_SIZE);
                 @SuppressWarnings({"unchecked", "rawtypes"}) MappingPair<? extends Entry<?>, RawEntryMapping>[] holds = new MappingPair[STATE_SIZE];
diff --git a/enigma/src/main/resources/lang/en_us.json b/enigma/src/main/resources/lang/en_us.json
index 421620e..2a3cfb2 100644
--- a/enigma/src/main/resources/lang/en_us.json
+++ b/enigma/src/main/resources/lang/en_us.json
@@ -137,6 +137,7 @@
         "log_panel.messages": "Messages",
         "log_panel.users": "Users",
 
+        "progress.done": "Done!",
         "progress.operation": "%s - Operation in progress",
         "progress.jar.indexing": "Indexing jar",
         "progress.jar.indexing.entries": "Entries...",
@@ -147,15 +148,12 @@
         "progress.sources.writing": "Writing sources...",
         "progress.classes.deobfuscating": "Deobfuscating classes...",
         "progress.classes.decompiling": "Decompiling classes...",
-        "progress.mappings.enigma_file.loading": "Loading mapping file",
-        "progress.mappings.enigma_file.done": "Done!",
-        "progress.mappings.enigma_file.writing": "Writing classes",
-        "progress.mappings.enigma_directory.loading": "Loading mapping files",
-        "progress.mappings.enigma_directory.writing": "Writing classes",
-        "progress.mappings.tiny_file.loading": "Loading mapping file",
-        "progress.mappings.tiny_v2.loading": "Loading mapping file",
-        "progress.mappings.srg_file.generating": "Generating mappings",
-        "progress.mappings.srg_file.writing": "Writing mappings",
+        "progress.mappings.loading_file": "Loading mapping file",
+        "progress.mappings.loading_directory": "Loading mapping files",
+        "progress.mappings.writing": "Writing classes",
+        "progress.mappings.converting": "Converting mappings",
+        "progress.mappings.converting.to_mappingio": "Converting to Mapping-IO",
+        "progress.mappings.converting.from_mappingio": "Converting from Mapping-IO",
         "progress.stats": "Generating stats",
         "progress.stats.data": "Generating data",
 
diff --git a/enigma/src/main/resources/lang/fr_fr.json b/enigma/src/main/resources/lang/fr_fr.json
index d3d0c29..520dd32 100644
--- a/enigma/src/main/resources/lang/fr_fr.json
+++ b/enigma/src/main/resources/lang/fr_fr.json
@@ -131,6 +131,7 @@
         "log_panel.messages": "Messages",
         "log_panel.users": "Utilisateurs",
 
+        "progress.done": "Terminé !",
         "progress.operation": "%s - Opération en cours",
         "progress.jar.indexing": "Indexation du jar",
         "progress.jar.indexing.entries": "Entrées...",
@@ -141,15 +142,10 @@
         "progress.sources.writing": "Écriture des sources...",
         "progress.classes.deobfuscating": "Déobfuscation des classes...",
         "progress.classes.decompiling": "Décompilation des classes...",
-        "progress.mappings.enigma_file.loading": "Chargement du fichier de mappings",
-        "progress.mappings.enigma_file.done": "Terminé !",
-        "progress.mappings.enigma_file.writing": "Écriture des classes",
-        "progress.mappings.enigma_directory.loading": "Chargement des fichiers de mappings",
-        "progress.mappings.enigma_directory.writing": "Écriture des classes",
-        "progress.mappings.tiny_file.loading": "Chargement du fichier de mappings",
-        "progress.mappings.tiny_v2.loading": "Chargement du fichier de mappings",
-        "progress.mappings.srg_file.generating": "Génération des mappings",
-        "progress.mappings.srg_file.writing": "Écriture des mappings",
+        "progress.mappings.loading_file": "Chargement du fichier de mappings",
+        "progress.mappings.loading_directory": "Chargement des fichiers de mappings",
+        "progress.mappings.writing": "Écriture des mappings",
+        "progress.mappings.converting": "Conversion des mappings",
         "progress.stats": "Génération des statistiques",
         "progress.stats.data": "Génération des données",
 
diff --git a/enigma/src/main/resources/lang/ja_jp.json b/enigma/src/main/resources/lang/ja_jp.json
index 09e7ee0..b4d5199 100644
--- a/enigma/src/main/resources/lang/ja_jp.json
+++ b/enigma/src/main/resources/lang/ja_jp.json
@@ -132,6 +132,7 @@
         "log_panel.messages": "メッセージ",
         "log_panel.users": "ユーザー",
 
+        "progress.done": "完了しました!",
         "progress.operation": "%s - 処理中",
         "progress.jar.indexing": "jarのインデックス中",
         "progress.jar.indexing.entries": "エントリー...",
@@ -142,15 +143,9 @@
         "progress.sources.writing": "ソースコードを書き出し中...",
         "progress.classes.deobfuscating": "クラスを難読化解除中...",
         "progress.classes.decompiling": "クラスのデコンパイル中...",
-        "progress.mappings.enigma_file.loading": "マッピングファイルをロード",
-        "progress.mappings.enigma_file.done": "完了しました!",
-        "progress.mappings.enigma_file.writing": "クラスの書き出し中",
-        "progress.mappings.enigma_directory.loading": "マッピングファイルの読込中",
-        "progress.mappings.enigma_directory.writing": "クラスの書き出し中",
-        "progress.mappings.tiny_file.loading": "マッピングファイルの読込中",
-        "progress.mappings.tiny_v2.loading": "マッピングファイルの読込中",
-        "progress.mappings.srg_file.generating": "マッピングの作成中",
-        "progress.mappings.srg_file.writing": "マッピングの書き出し中",
+        "progress.mappings.loading_file": "マッピングファイルをロード",
+        "progress.mappings.loading_directory": "マッピングファイルの読込中",
+        "progress.mappings.writing": "マッピングの書き出し中",
         "progress.stats": "統計情報を作成中",
         "progress.stats.data": "データの作成中",
 
diff --git a/enigma/src/main/resources/lang/zh_cn.json b/enigma/src/main/resources/lang/zh_cn.json
index fe806fb..dbc6dd3 100644
--- a/enigma/src/main/resources/lang/zh_cn.json
+++ b/enigma/src/main/resources/lang/zh_cn.json
@@ -75,6 +75,7 @@
         "info_panel.tree.implementations": "实现",
         "info_panel.tree.calls": "调用图",
 
+        "progress.done": "完成！",
         "progress.operation": "%s - 进行中",
         "progress.jar.indexing": "索引 Jar",
         "progress.jar.indexing.entries": "条目...",
@@ -85,15 +86,9 @@
         "progress.sources.writing": "写出源码中...",
         "progress.classes.deobfuscating": "反混淆类中...",
         "progress.classes.decompiling": "反编译类中...",
-        "progress.mappings.enigma_file.loading": "加载映射文件",
-        "progress.mappings.enigma_file.done": "完成！",
-        "progress.mappings.enigma_file.writing": "写入类",
-        "progress.mappings.enigma_directory.loading": "加载映射文件",
-        "progress.mappings.enigma_directory.writing": "写入类",
-        "progress.mappings.tiny_file.loading": "加载映射文件",
-        "progress.mappings.tiny_v2.loading": "加载映射文件",
-        "progress.mappings.srg_file.generating": "生成映射",
-        "progress.mappings.srg_file.writing": "写出映射",
+        "progress.mappings.loading_file": "加载映射文件",
+        "progress.mappings.loading_directory": "加载映射文件",
+        "progress.mappings.writing": "写出映射",
         "progress.stats": "生成统计范围",
         "progress.stats.data": "生成数据",
 
diff --git a/enigma/src/test/java/cuchaz/enigma/translation/mapping/TestReadWriteCycle.java b/enigma/src/test/java/cuchaz/enigma/translation/mapping/TestReadWriteCycle.java
index 681fd3f..25f11fb 100644
--- a/enigma/src/test/java/cuchaz/enigma/translation/mapping/TestReadWriteCycle.java
+++ b/enigma/src/test/java/cuchaz/enigma/translation/mapping/TestReadWriteCycle.java
@@ -4,6 +4,7 @@ import java.io.File;
 import java.io.IOException;
 
 import org.junit.Assert;
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import cuchaz.enigma.ProgressListener;
@@ -62,7 +63,7 @@ public class TestReadWriteCycle {
                 mappingFormat.write(testMappings, tempFile.toPath(), ProgressListener.none(), parameters);
                 Assert.assertTrue("Written file not created", tempFile.exists());
 
-                EntryTree<EntryMapping> loadedMappings = mappingFormat.read(tempFile.toPath(), ProgressListener.none(), parameters);
+                EntryTree<EntryMapping> loadedMappings = mappingFormat.read(tempFile.toPath(), ProgressListener.none(), parameters, null);
 
                 Assert.assertTrue("Loaded mappings don't contain testClazz", loadedMappings.contains(testClazz.a));
                 Assert.assertTrue("Loaded mappings don't contain testField1", loadedMappings.contains(testField1.a));
@@ -87,6 +88,11 @@ public class TestReadWriteCycle {
                 tempFile.delete();
         }
 
+        @BeforeClass
+        public static void setup() {
+                System.getProperties().setProperty("enigma.use_mappingio", "false");
+        }
+
         @Test
         public void testEnigmaFile() throws IOException, MappingParseException {
                 testReadWriteCycle(MappingFormat.ENIGMA_FILE, true, ".enigma");