Allow attaching class, method, field, and parameter javadocs (#185)

* bring liach pr to modern enigma

* bump version

* fuck off vscode

* switch to COMMENT and write comments before

* it was already after, what do you want

* oops

* put inner classes at the end

* remove indents and use all caps

* add refreshmappings command

* Update src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaMappingsWriter.java

* Delete RefreshEnigmaMappingsCommand.java

* Update CommandMain.java

* ok

11 files changed, 225 insertions, 66 deletions

diff --git a/src/main/java/cuchaz/enigma/translation/mapping/EntryMapping.java b/src/main/java/cuchaz/enigma/translation/mapping/EntryMapping.java
index b74cc0b..c607817 100644
--- a/src/main/java/cuchaz/enigma/translation/mapping/EntryMapping.java
+++ b/src/main/java/cuchaz/enigma/translation/mapping/EntryMapping.java
@@ -1,18 +1,29 @@
 package cuchaz.enigma.translation.mapping;
 
 import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 
 public class EntryMapping {
         private final String targetName;
         private final AccessModifier accessModifier;
+        private final @Nullable String javadoc;
 
         public EntryMapping(@Nonnull String targetName) {
                 this(targetName, AccessModifier.UNCHANGED);
         }
 
+        public EntryMapping(@Nonnull String targetName, @Nullable String javadoc) {
+                this(targetName, AccessModifier.UNCHANGED, javadoc);
+        }
+
         public EntryMapping(@Nonnull String targetName, AccessModifier accessModifier) {
+                this(targetName, accessModifier, null);
+        }
+
+        public EntryMapping(@Nonnull String targetName, AccessModifier accessModifier, @Nullable String javadoc) {
                 this.targetName = targetName;
                 this.accessModifier = accessModifier;
+                this.javadoc = javadoc;
         }
 
         @Nonnull
@@ -28,6 +39,23 @@ public class EntryMapping {
                 return accessModifier;
         }
 
+        @Nullable
+        public String getJavadoc() {
+                return javadoc;
+        }
+
+        public EntryMapping withName(String newName) {
+                return new EntryMapping(newName, accessModifier, javadoc);
+        }
+
+        public EntryMapping withModifier(AccessModifier newModifier) {
+                return new EntryMapping(targetName, newModifier, javadoc);
+        }
+
+        public EntryMapping withDocs(String newDocs) {
+                return new EntryMapping(targetName, accessModifier, newDocs);
+        }
+
         @Override
         public boolean equals(Object obj) {
                 if (obj == this) return true;
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/EntryRemapper.java b/src/main/java/cuchaz/enigma/translation/mapping/EntryRemapper.java
index c9808cc..ad36c97 100644
--- a/src/main/java/cuchaz/enigma/translation/mapping/EntryRemapper.java
+++ b/src/main/java/cuchaz/enigma/translation/mapping/EntryRemapper.java
@@ -11,6 +11,7 @@ import cuchaz.enigma.translation.representation.entry.Entry;
 
 import javax.annotation.Nullable;
 import java.util.Collection;
+import java.util.function.UnaryOperator;
 import java.util.stream.Stream;
 
 public class EntryRemapper {
@@ -40,9 +41,13 @@ public class EntryRemapper {
         }
 
         public <E extends Entry<?>> void mapFromObf(E obfuscatedEntry, @Nullable EntryMapping deobfMapping) {
-                Collection<E> resolvedEntries = obfResolver.resolveEntry(obfuscatedEntry, ResolutionStrategy.RESOLVE_ROOT);
+                mapFromObf(obfuscatedEntry, deobfMapping, true);
+        }
+
+        public <E extends Entry<?>> void mapFromObf(E obfuscatedEntry, @Nullable EntryMapping deobfMapping, boolean renaming) {
+                Collection<E> resolvedEntries = obfResolver.resolveEntry(obfuscatedEntry, renaming ? ResolutionStrategy.RESOLVE_ROOT : ResolutionStrategy.RESOLVE_CLOSEST);
 
-                if (deobfMapping != null) {
+                if (renaming && deobfMapping != null) {
                         for (E resolvedEntry : resolvedEntries) {
                                 validator.validateRename(resolvedEntry, deobfMapping.getTargetName());
                         }
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaFormat.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaFormat.java
new file mode 100644
index 0000000..af92ffb
--- /dev/null
+++ b/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaFormat.java
@@ -0,0 +1,9 @@
+package cuchaz.enigma.translation.mapping.serde;
+
+public class EnigmaFormat {
+        public static final String COMMENT = "COMMENT";
+        public static final String CLASS = "CLASS";
+        public static final String FIELD = "FIELD";
+        public static final String METHOD = "METHOD";
+        public static final String PARAMETER = "ARG";
+}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaMappingsReader.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaMappingsReader.java
index 1e4c442..2c993f4 100644
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaMappingsReader.java
+++ b/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaMappingsReader.java
@@ -64,7 +64,7 @@ public enum EnigmaMappingsReader implements MappingsReader {
 
         protected void readFile(Path path, EntryTree<EntryMapping> mappings) throws IOException, MappingParseException {
                 List<String> lines = Files.readAllLines(path, Charsets.UTF_8);
-                Deque<Entry<?>> mappingStack = new ArrayDeque<>();
+                Deque<MappingPair<?, RawEntryMapping>> mappingStack = new ArrayDeque<>();
 
                 for (int lineNumber = 0; lineNumber < lines.size(); lineNumber++) {
                         String line = lines.get(lineNumber);
@@ -75,21 +75,33 @@ public enum EnigmaMappingsReader implements MappingsReader {
                                 continue;
                         }
 
-                        while (indentation < mappingStack.size()) {
-                                mappingStack.pop();
-                        }
+                        cleanMappingStack(indentation, mappingStack, mappings);
 
                         try {
-                                MappingPair<?, EntryMapping> pair = parseLine(mappingStack.peek(), line);
-                                mappingStack.push(pair.getEntry());
-                                if (pair.getMapping() != null) {
-                                        mappings.insert(pair.getEntry(), pair.getMapping());
+                                MappingPair<?, RawEntryMapping> pair = parseLine(mappingStack.peek(), line);
+                                if (pair != null) {
+                                        mappingStack.push(pair);
+                                        if (pair.getMapping() != null) {
+
+                                        }
                                 }
                         } catch (Throwable t) {
                                 t.printStackTrace();
                                 throw new MappingParseException(path::toString, lineNumber, t.toString());
                         }
                 }
+
+                // Clean up rest
+                cleanMappingStack(0, mappingStack, mappings);
+        }
+
+        private void cleanMappingStack(int indentation, Deque<MappingPair<?, RawEntryMapping>> mappingStack, EntryTree<EntryMapping> mappings) {
+                while (indentation < mappingStack.size()) {
+                        MappingPair<?, RawEntryMapping> pair = mappingStack.pop();
+                        if (pair.getMapping() != null) {
+                                mappings.insert(pair.getEntry(), pair.getMapping().bake());
+                        }
+                }
         }
 
         @Nullable
@@ -123,25 +135,38 @@ public enum EnigmaMappingsReader implements MappingsReader {
                 return indent;
         }
 
-        private MappingPair<?, EntryMapping> parseLine(@Nullable Entry<?> parent, String line) {
+        private MappingPair<?, RawEntryMapping> parseLine(@Nullable MappingPair<?, RawEntryMapping> parent, String line) {
                 String[] tokens = line.trim().split("\\s");
-                String keyToken = tokens[0].toLowerCase(Locale.ROOT);
+                String keyToken = tokens[0].toUpperCase(Locale.ROOT);
+                Entry<?> parentEntry = parent == null ? null : parent.getEntry();
 
                 switch (keyToken) {
-                        case "class":
-                                return parseClass(parent, tokens);
-                        case "field":
-                                return parseField(parent, tokens);
-                        case "method":
-                                return parseMethod(parent, tokens);
-                        case "arg":
-                                return parseArgument(parent, tokens);
+                        case EnigmaFormat.CLASS:
+                                return parseClass(parentEntry, tokens);
+                        case EnigmaFormat.FIELD:
+                                return parseField(parentEntry, tokens);
+                        case EnigmaFormat.METHOD:
+                                return parseMethod(parentEntry, tokens);
+                        case EnigmaFormat.PARAMETER:
+                                return parseArgument(parentEntry, tokens);
+                        case EnigmaFormat.COMMENT:
+                                readJavadoc(parent, tokens);
+                                return null;
                         default:
                                 throw new RuntimeException("Unknown token '" + keyToken + "'");
                 }
         }
+        
+        private void readJavadoc(MappingPair<?, RawEntryMapping> parent, String[] tokens) {
+                if (parent == null)
+                        throw new IllegalStateException("Javadoc has no parent!");
+                String jdLine = tokens.length > 1 ? tokens[1] : ""; // Empty string to concat
+                if (parent.getMapping() == null)
+                        throw new IllegalStateException("Javadoc requires a mapping!");
+                parent.getMapping().addJavadocLine(MappingHelper.unescape(jdLine));
+        }
 
-        private MappingPair<ClassEntry, EntryMapping> parseClass(@Nullable Entry<?> parent, String[] tokens) {
+        private MappingPair<ClassEntry, RawEntryMapping> parseClass(@Nullable Entry<?> parent, String[] tokens) {
                 String obfuscatedName = ClassEntry.getInnerName(tokens[1]);
                 ClassEntry obfuscatedEntry;
                 if (parent instanceof ClassEntry) {
@@ -167,13 +192,13 @@ public enum EnigmaMappingsReader implements MappingsReader {
                 }
 
                 if (mapping != null) {
-                        return new MappingPair<>(obfuscatedEntry, new EntryMapping(mapping, modifier));
+                        return new MappingPair<>(obfuscatedEntry, new RawEntryMapping(mapping, modifier));
                 } else {
                         return new MappingPair<>(obfuscatedEntry);
                 }
         }
 
-        private MappingPair<FieldEntry, EntryMapping> parseField(@Nullable Entry<?> parent, String[] tokens) {
+        private MappingPair<FieldEntry, RawEntryMapping> parseField(@Nullable Entry<?> parent, String[] tokens) {
                 if (!(parent instanceof ClassEntry)) {
                         throw new RuntimeException("Field must be a child of a class!");
                 }
@@ -204,13 +229,13 @@ public enum EnigmaMappingsReader implements MappingsReader {
 
                 FieldEntry obfuscatedEntry = new FieldEntry(ownerEntry, obfuscatedName, descriptor);
                 if (mapping != null) {
-                        return new MappingPair<>(obfuscatedEntry, new EntryMapping(mapping, modifier));
+                        return new MappingPair<>(obfuscatedEntry, new RawEntryMapping(mapping, modifier));
                 } else {
                         return new MappingPair<>(obfuscatedEntry);
                 }
         }
 
-        private MappingPair<MethodEntry, EntryMapping> parseMethod(@Nullable Entry<?> parent, String[] tokens) {
+        private MappingPair<MethodEntry, RawEntryMapping> parseMethod(@Nullable Entry<?> parent, String[] tokens) {
                 if (!(parent instanceof ClassEntry)) {
                         throw new RuntimeException("Method must be a child of a class!");
                 }
@@ -244,22 +269,22 @@ public enum EnigmaMappingsReader implements MappingsReader {
 
                 MethodEntry obfuscatedEntry = new MethodEntry(ownerEntry, obfuscatedName, descriptor);
                 if (mapping != null) {
-                        return new MappingPair<>(obfuscatedEntry, new EntryMapping(mapping, modifier));
+                        return new MappingPair<>(obfuscatedEntry, new RawEntryMapping(mapping, modifier));
                 } else {
                         return new MappingPair<>(obfuscatedEntry);
                 }
         }
 
-        private MappingPair<LocalVariableEntry, EntryMapping> parseArgument(@Nullable Entry<?> parent, String[] tokens) {
+        private MappingPair<LocalVariableEntry, RawEntryMapping> parseArgument(@Nullable Entry<?> parent, String[] tokens) {
                 if (!(parent instanceof MethodEntry)) {
                         throw new RuntimeException("Method arg must be a child of a method!");
                 }
 
                 MethodEntry ownerEntry = (MethodEntry) parent;
-                LocalVariableEntry obfuscatedEntry = new LocalVariableEntry(ownerEntry, Integer.parseInt(tokens[1]), "", true);
+                LocalVariableEntry obfuscatedEntry = new LocalVariableEntry(ownerEntry, Integer.parseInt(tokens[1]), "", true, null);
                 String mapping = tokens[2];
 
-                return new MappingPair<>(obfuscatedEntry, new EntryMapping(mapping));
+                return new MappingPair<>(obfuscatedEntry, new RawEntryMapping(mapping));
         }
 
         @Nullable
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaMappingsWriter.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaMappingsWriter.java
index 7199be8..f490b1d 100644
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaMappingsWriter.java
+++ b/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaMappingsWriter.java
@@ -11,15 +11,6 @@
 
 package cuchaz.enigma.translation.mapping.serde;
 
-import cuchaz.enigma.ProgressListener;
-import cuchaz.enigma.translation.MappingTranslator;
-import cuchaz.enigma.translation.Translator;
-import cuchaz.enigma.translation.mapping.*;
-import cuchaz.enigma.translation.mapping.tree.EntryTree;
-import cuchaz.enigma.translation.mapping.tree.EntryTreeNode;
-import cuchaz.enigma.translation.representation.entry.*;
-import cuchaz.enigma.utils.LFPrintWriter;
-
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.nio.file.DirectoryStream;
@@ -33,6 +24,24 @@ import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import cuchaz.enigma.ProgressListener;
+import cuchaz.enigma.translation.MappingTranslator;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.mapping.AccessModifier;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.MappingDelta;
+import cuchaz.enigma.translation.mapping.MappingFileNameFormat;
+import cuchaz.enigma.translation.mapping.MappingSaveParameters;
+import cuchaz.enigma.translation.mapping.VoidEntryResolver;
+import cuchaz.enigma.translation.mapping.tree.EntryTree;
+import cuchaz.enigma.translation.mapping.tree.EntryTreeNode;
+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.LFPrintWriter;
+
 public enum EnigmaMappingsWriter implements MappingsWriter {
         FILE {
                 @Override
@@ -154,10 +163,26 @@ public enum EnigmaMappingsWriter implements MappingsWriter {
         protected void writeRoot(PrintWriter writer, EntryTree<EntryMapping> mappings, ClassEntry classEntry) {
                 Collection<Entry<?>> children = groupChildren(mappings.getChildren(classEntry));
 
-                writer.println(writeClass(classEntry, mappings.get(classEntry)).trim());
+                EntryMapping classEntryMapping = mappings.get(classEntry);
+
+                writer.println(writeClass(classEntry, classEntryMapping).trim());
+                if (classEntryMapping != null && classEntryMapping.getJavadoc() != null) {
+                        writeDocs(writer, classEntryMapping, 0);
+                }
+
                 for (Entry<?> child : children) {
                         writeEntry(writer, mappings, child, 1);
                 }
+
+        }
+
+        private void writeDocs(PrintWriter writer, EntryMapping mapping, int depth) {
+                String jd = mapping.getJavadoc();
+                if (jd != null) {
+                        for (String line : jd.split("\\R")) {
+                                writer.println(indent(EnigmaFormat.COMMENT + " " + MappingHelper.escape(line), depth + 1));
+                        }
+                }
         }
 
         protected void writeEntry(PrintWriter writer, EntryTree<EntryMapping> mappings, Entry<?> entry, int depth) {
@@ -167,6 +192,7 @@ public enum EnigmaMappingsWriter implements MappingsWriter {
                 }
 
                 EntryMapping mapping = node.getValue();
+
                 if (entry instanceof ClassEntry) {
                         String line = writeClass((ClassEntry) entry, mapping);
                         writer.println(indent(line, depth));
@@ -180,6 +206,9 @@ public enum EnigmaMappingsWriter implements MappingsWriter {
                         String line = writeArgument((LocalVariableEntry) entry, mapping);
                         writer.println(indent(line, depth));
                 }
+                if (mapping != null && mapping.getJavadoc() != null) {
+                        writeDocs(writer, mapping, depth);
+                }
 
                 Collection<Entry<?>> children = groupChildren(node.getChildren());
                 for (Entry<?> child : children) {
@@ -190,11 +219,6 @@ public enum EnigmaMappingsWriter implements MappingsWriter {
         private Collection<Entry<?>> groupChildren(Collection<Entry<?>> children) {
                 Collection<Entry<?>> result = new ArrayList<>(children.size());
 
-                children.stream().filter(e -> e instanceof ClassEntry)
-                                .map(e -> (ClassEntry) e)
-                                .sorted()
-                                .forEach(result::add);
-
                 children.stream().filter(e -> e instanceof FieldEntry)
                                 .map(e -> (FieldEntry) e)
                                 .sorted()
@@ -210,11 +234,16 @@ public enum EnigmaMappingsWriter implements MappingsWriter {
                                 .sorted()
                                 .forEach(result::add);
 
+                children.stream().filter(e -> e instanceof ClassEntry)
+                                                .map(e -> (ClassEntry) e)
+                                                .sorted()
+                                                .forEach(result::add);
+
                 return result;
         }
 
         protected String writeClass(ClassEntry entry, EntryMapping mapping) {
-                StringBuilder builder = new StringBuilder("CLASS ");
+                StringBuilder builder = new StringBuilder(EnigmaFormat.CLASS +" ");
                 builder.append(entry.getName()).append(' ');
                 writeMapping(builder, mapping);
 
@@ -222,7 +251,7 @@ public enum EnigmaMappingsWriter implements MappingsWriter {
         }
 
         protected String writeMethod(MethodEntry entry, EntryMapping mapping) {
-                StringBuilder builder = new StringBuilder("METHOD ");
+                StringBuilder builder = new StringBuilder(EnigmaFormat.METHOD + " ");
                 builder.append(entry.getName()).append(' ');
                 writeMapping(builder, mapping);
 
@@ -232,7 +261,7 @@ public enum EnigmaMappingsWriter implements MappingsWriter {
         }
 
         protected String writeField(FieldEntry entry, EntryMapping mapping) {
-                StringBuilder builder = new StringBuilder("FIELD ");
+                StringBuilder builder = new StringBuilder(EnigmaFormat.FIELD + " ");
                 builder.append(entry.getName()).append(' ');
                 writeMapping(builder, mapping);
 
@@ -242,7 +271,7 @@ public enum EnigmaMappingsWriter implements MappingsWriter {
         }
 
         protected String writeArgument(LocalVariableEntry entry, EntryMapping mapping) {
-                return "ARG " + entry.getIndex() + ' ' + mapping.getTargetName();
+                return EnigmaFormat.PARAMETER + " " + entry.getIndex() + ' ' + mapping.getTargetName();
         }
 
         private void writeMapping(StringBuilder builder, EntryMapping mapping) {
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java
index 7eae1c0..c04eec5 100644
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java
+++ b/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java
@@ -19,6 +19,7 @@ public enum MappingFormat {
         SRG_FILE(SrgMappingsWriter.INSTANCE, null),
         PROGUARD(null, ProguardMappingsReader.INSTANCE);
 
+
         private final MappingsWriter writer;
         private final MappingsReader reader;
 
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingHelper.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingHelper.java
new file mode 100644
index 0000000..7c8f6cc
--- /dev/null
+++ b/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingHelper.java
@@ -0,0 +1,51 @@
+package cuchaz.enigma.translation.mapping.serde;
+
+public final class MappingHelper {
+        private static final String TO_ESCAPE = "\\\n\r\0\t";
+        private static final String ESCAPED = "\\nr0t";
+
+        public static String escape(String raw) {
+                StringBuilder builder = new StringBuilder(raw.length() + 1);
+                for (int i = 0; i < raw.length(); i++) {
+                        final char c = raw.charAt(i);
+                        final int r = TO_ESCAPE.indexOf(c);
+                        if (r < 0) {
+                                builder.append(c);
+                        } else {
+                                builder.append('\\').append(ESCAPED.charAt(r));
+                        }
+                }
+                return builder.toString();
+        }
+
+        public static String unescape(String str) {
+                int pos = str.indexOf('\\');
+                if (pos < 0) return str;
+
+                StringBuilder ret = new StringBuilder(str.length() - 1);
+                int start = 0;
+
+                do {
+                        ret.append(str, start, pos);
+                        pos++;
+                        int type;
+
+                        if (pos >= str.length()) {
+                                throw new RuntimeException("incomplete escape sequence at the end");
+                        } else if ((type = ESCAPED.indexOf(str.charAt(pos))) < 0) {
+                                throw new RuntimeException("invalid escape character: \\" + str.charAt(pos));
+                        } else {
+                                ret.append(TO_ESCAPE.charAt(type));
+                        }
+
+                        start = pos + 1;
+                } while ((pos = str.indexOf('\\', start)) >= 0);
+
+                ret.append(str, start, str.length());
+
+                return ret.toString();
+        }
+
+        private MappingHelper() {
+        }
+}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/RawEntryMapping.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/RawEntryMapping.java
index 5d63f38..afb40e9 100644
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/RawEntryMapping.java
+++ b/src/main/java/cuchaz/enigma/translation/mapping/serde/RawEntryMapping.java
@@ -1,12 +1,15 @@
 package cuchaz.enigma.translation.mapping.serde;
 
-import com.google.common.base.Strings;
 import cuchaz.enigma.translation.mapping.AccessModifier;
 import cuchaz.enigma.translation.mapping.EntryMapping;
 
+import java.util.ArrayList;
+import java.util.List;
+
 final class RawEntryMapping {
         private final String targetName;
         private final AccessModifier access;
+        private List<String> javadocs = new ArrayList<>();
 
         RawEntryMapping(String targetName) {
                 this(targetName, null);
@@ -17,7 +20,11 @@ final class RawEntryMapping {
                 this.targetName = targetName;
         }
 
+        void addJavadocLine(String line) {
+                javadocs.add(line);
+        }
+
         EntryMapping bake() {
-                return Strings.isNullOrEmpty(targetName) ? null : new EntryMapping(targetName, access);
+                return new EntryMapping(targetName, access, javadocs.isEmpty() ? null : String.join("\n", javadocs));
         }
 }
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyMappingsReader.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyMappingsReader.java
index 81d181b..aceb02f 100644
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyMappingsReader.java
+++ b/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyMappingsReader.java
@@ -108,7 +108,7 @@ public enum TinyMappingsReader implements MappingsReader {
                 int variableIndex = Integer.parseInt(tokens[4]);
 
                 String mapping = tokens[5];
-                LocalVariableEntry obfuscatedEntry = new LocalVariableEntry(ownerMethod, variableIndex, "", true);
+                LocalVariableEntry obfuscatedEntry = new LocalVariableEntry(ownerMethod, variableIndex, "", true, null);
                 return new MappingPair<>(obfuscatedEntry, new EntryMapping(mapping));
         }
 }
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyV2Reader.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyV2Reader.java
index 2621f31..c0488e9 100644
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyV2Reader.java
+++ b/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyV2Reader.java
@@ -200,14 +200,6 @@ final class TinyV2Reader implements MappingsReader {
                 addJavadoc(pair, parts[1]);
         }
 
-        private void addJavadoc(MappingPair<? extends Entry, RawEntryMapping> pair, String javadoc) {
-                RawEntryMapping mapping = pair.getMapping();
-                if (mapping == null) {
-                        throw new IllegalArgumentException("Javadoc requires a mapping in enigma!");
-                }
-//              mapping.addJavadocLine(javadoc); todo javadocs
-        }
-
         private MappingPair<ClassEntry, RawEntryMapping> parseClass(String[] tokens, boolean escapeNames) {
                 ClassEntry obfuscatedEntry = new ClassEntry(unescapeOpt(tokens[1], escapeNames));
                 if (tokens.length <= 2)
@@ -239,13 +231,25 @@ final class TinyV2Reader implements MappingsReader {
                 return new MappingPair<>(obfuscatedEntry, new RawEntryMapping(mapping));
         }
 
+
+
+        private void addJavadoc(MappingPair<? extends Entry, RawEntryMapping> pair, String javadoc) {
+                RawEntryMapping mapping = pair.getMapping();
+                if (mapping == null) {
+                        throw new IllegalArgumentException("Javadoc requires a mapping in enigma!");
+                }
+                mapping.addJavadocLine(javadoc);
+        }
+
+
+
         private MappingPair<LocalVariableEntry, RawEntryMapping> parseArgument(MappingPair<? extends Entry, RawEntryMapping> parent, String[] tokens, boolean escapeNames) {
                 MethodEntry ownerMethod = (MethodEntry) parent.getEntry();
                 int variableIndex = Integer.parseInt(tokens[1]);
 
                 // tokens[2] is the useless obf name
 
-                LocalVariableEntry obfuscatedEntry = new LocalVariableEntry(ownerMethod, variableIndex, "", true);
+                LocalVariableEntry obfuscatedEntry = new LocalVariableEntry(ownerMethod, variableIndex, "", true, null);
                 if (tokens.length <= 3)
                         return new MappingPair<>(obfuscatedEntry);
                 String mapping = unescapeOpt(tokens[3], escapeNames);
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyV2Writer.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyV2Writer.java
index a734ca2..95e04c3 100644
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyV2Writer.java
+++ b/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyV2Writer.java
@@ -155,12 +155,12 @@ public final class TinyV2Writer implements MappingsWriter {
         }
 
         private void writeComment(PrintWriter writer, EntryMapping mapping, int indent) {
-//              if (mapping != null && mapping.getJavadoc() != null) { todo javadocs
-//                      writer.print(indent(indent));
-//                      writer.print("c\t");
-//                      writer.print(MappingHelper.escape(mapping.getJavadoc()));
-//                      writer.println();
-//              }
+                if (mapping != null && mapping.getJavadoc() != null) {
+                        writer.print(indent(indent));
+                        writer.print("c\t");
+                        writer.print(MappingHelper.escape(mapping.getJavadoc()));
+                        writer.println();
+                }
         }
 
         private String indent(int level) {