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

5 files changed, 160 insertions, 713 deletions

diff --git a/src/main/java/cuchaz/enigma/analysis/AddJavadocsAstTransform.java b/src/main/java/cuchaz/enigma/analysis/AddJavadocsAstTransform.java
new file mode 100644
index 0000000..17ae63d
--- /dev/null
+++ b/src/main/java/cuchaz/enigma/analysis/AddJavadocsAstTransform.java
@@ -0,0 +1,135 @@
+package cuchaz.enigma.analysis;
+
+import com.google.common.base.Function;
+import com.google.common.base.Strings;
+import com.strobel.assembler.metadata.ParameterDefinition;
+import com.strobel.decompiler.languages.java.ast.*;
+import com.strobel.decompiler.languages.java.ast.transforms.IAstTransform;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.EntryRemapper;
+import cuchaz.enigma.translation.mapping.EntryResolver;
+import cuchaz.enigma.translation.mapping.ResolutionStrategy;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+import cuchaz.enigma.translation.representation.entry.*;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+public final class AddJavadocsAstTransform implements IAstTransform {
+
+        private final EntryRemapper remapper;
+
+        public AddJavadocsAstTransform(EntryRemapper remapper) {
+                this.remapper = remapper;
+        }
+
+        @Override
+        public void run(AstNode compilationUnit) {
+                compilationUnit.acceptVisitor(new Visitor(remapper), null);
+        }
+
+        static class Visitor extends DepthFirstAstVisitor<Void, Void> {
+
+                private final EntryRemapper remapper;
+
+                Visitor(EntryRemapper remapper) {
+                        this.remapper = remapper;
+                }
+
+                private <T extends AstNode> void addDoc(T node, Function<T, Entry<?>> retriever) {
+                        final Comment[] comments = getComments(node, retriever);
+                        if (comments != null) {
+                                node.insertChildrenBefore(node.getFirstChild(), Roles.COMMENT, comments);
+                        }
+                }
+
+                private <T extends AstNode> Comment[] getComments(T node, Function<T, Entry<?>> retriever) {
+                        final EntryMapping mapping = remapper.getDeobfMapping(retriever.apply(node));
+                        final String docs = mapping == null ? null : Strings.emptyToNull(mapping.getJavadoc());
+                        return docs == null ? null : Stream.of(docs.split("\\R")).map(st -> new Comment(st,
+                                        CommentType.Documentation)).toArray(Comment[]::new);
+                }
+
+                private Comment[] getParameterComments(ParameterDeclaration node, Function<ParameterDeclaration, Entry<?>> retriever) {
+                        final EntryMapping mapping = remapper.getDeobfMapping(retriever.apply(node));
+                        final Comment[] ret = getComments(node, retriever);
+                        if (ret != null) {
+                                final String paramPrefix = "@param " + mapping.getTargetName() + " ";
+                                final String indent = Strings.repeat(" ", paramPrefix.length());
+                                ret[0].setContent(paramPrefix + ret[0].getContent());
+                                for (int i = 1; i < ret.length; i++) {
+                                        ret[i].setContent(indent + ret[i].getContent());
+                                }
+                        }
+                        return ret;
+                }
+
+                private void visitMethod(AstNode node) {
+                        final MethodDefEntry methodDefEntry = MethodDefEntry.parse(node.getUserData(Keys.METHOD_DEFINITION));
+                        final Comment[] baseComments = getComments(node, $ -> methodDefEntry);
+                        List<Comment> comments = new ArrayList<>();
+                        if (baseComments != null)
+                                Collections.addAll(comments, baseComments);
+
+                        for (ParameterDeclaration dec : node.getChildrenByRole(Roles.PARAMETER)) {
+                                ParameterDefinition def = dec.getUserData(Keys.PARAMETER_DEFINITION);
+                                final Comment[] paramComments = getParameterComments(dec, $ -> new LocalVariableDefEntry(methodDefEntry, def.getSlot(), def.getName(),
+                                                true,
+                                                TypeDescriptor.parse(def.getParameterType()), null));
+                                if (paramComments != null)
+                                        Collections.addAll(comments, paramComments);
+                        }
+
+                        if (!comments.isEmpty()) {
+                                if (remapper.getObfResolver().resolveEntry(methodDefEntry, ResolutionStrategy.RESOLVE_ROOT).stream().noneMatch(e -> Objects.equals(e, methodDefEntry))) {
+                                        comments.add(0, new Comment("{@inheritDoc}", CommentType.Documentation));
+                                }
+                                final AstNode oldFirst = node.getFirstChild();
+                                for (Comment comment : comments) {
+                                        node.insertChildBefore(oldFirst, comment, Roles.COMMENT);
+                                }
+                        }
+                }
+
+                @Override
+                protected Void visitChildren(AstNode node, Void data) {
+                        for (final AstNode child : node.getChildren()) {
+                                child.acceptVisitor(this, data);
+                        }
+                        return null;
+                }
+
+                @Override
+                public Void visitMethodDeclaration(MethodDeclaration node, Void data) {
+                        visitMethod(node);
+                        return super.visitMethodDeclaration(node, data);
+                }
+
+                @Override
+                public Void visitConstructorDeclaration(ConstructorDeclaration node, Void data) {
+                        visitMethod(node);
+                        return super.visitConstructorDeclaration(node, data);
+                }
+
+                @Override
+                public Void visitFieldDeclaration(FieldDeclaration node, Void data) {
+                        addDoc(node, dec -> FieldDefEntry.parse(dec.getUserData(Keys.FIELD_DEFINITION)));
+                        return super.visitFieldDeclaration(node, data);
+                }
+
+                @Override
+                public Void visitTypeDeclaration(TypeDeclaration node, Void data) {
+                        addDoc(node, dec -> ClassDefEntry.parse(dec.getUserData(Keys.TYPE_DEFINITION)));
+                        return super.visitTypeDeclaration(node, data);
+                }
+
+                @Override
+                public Void visitEnumValueDeclaration(EnumValueDeclaration node, Void data) {
+                        addDoc(node, dec -> FieldDefEntry.parse(dec.getUserData(Keys.FIELD_DEFINITION)));
+                        return super.visitEnumValueDeclaration(node, data);
+                }
+        }
+}
diff --git a/src/main/java/cuchaz/enigma/analysis/SourceIndexClassVisitor.java b/src/main/java/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
index c977703..2a72cb1 100644
--- a/src/main/java/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
+++ b/src/main/java/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
@@ -40,7 +40,7 @@ public class SourceIndexClassVisitor extends SourceIndexVisitor {
                         return node.acceptVisitor(new SourceIndexClassVisitor(classEntry), index);
                 }
 
-                return recurse(node, index);
+                return visitChildren(node, index);
         }
 
         @Override
@@ -51,7 +51,7 @@ public class SourceIndexClassVisitor extends SourceIndexVisitor {
                         index.addReference(node.getIdentifierToken(), classEntry, this.classEntry);
                 }
 
-                return recurse(node, index);
+                return visitChildren(node, index);
         }
 
         @Override
@@ -82,7 +82,7 @@ public class SourceIndexClassVisitor extends SourceIndexVisitor {
                 assert (node.getVariables().size() == 1);
                 VariableInitializer variable = node.getVariables().firstOrNullObject();
                 index.addDeclaration(variable.getNameToken(), fieldEntry);
-                return recurse(node, index);
+                return visitChildren(node, index);
         }
 
         @Override
@@ -91,6 +91,6 @@ public class SourceIndexClassVisitor extends SourceIndexVisitor {
                 FieldDefinition def = node.getUserData(Keys.FIELD_DEFINITION);
                 FieldDefEntry fieldEntry = FieldDefEntry.parse(def);
                 index.addDeclaration(node.getNameToken(), fieldEntry);
-                return recurse(node, index);
+                return visitChildren(node, index);
         }
 }
diff --git a/src/main/java/cuchaz/enigma/analysis/SourceIndexMethodVisitor.java b/src/main/java/cuchaz/enigma/analysis/SourceIndexMethodVisitor.java
index fde6edf..dfe58ba 100644
--- a/src/main/java/cuchaz/enigma/analysis/SourceIndexMethodVisitor.java
+++ b/src/main/java/cuchaz/enigma/analysis/SourceIndexMethodVisitor.java
@@ -63,7 +63,7 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
                 // Check for identifier
                 node.getArguments().stream().filter(expression -> expression instanceof IdentifierExpression)
                                 .forEach(expression -> this.checkIdentifier((IdentifierExpression) expression, index));
-                return recurse(node, index);
+                return visitChildren(node, index);
         }
 
         @Override
@@ -81,7 +81,7 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
                         index.addReference(node.getMemberNameToken(), fieldEntry, this.methodEntry);
                 }
 
-                return recurse(node, index);
+                return visitChildren(node, index);
         }
 
         @Override
@@ -92,7 +92,7 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
                         index.addReference(node.getIdentifierToken(), classEntry, this.methodEntry);
                 }
 
-                return recurse(node, index);
+                return visitChildren(node, index);
         }
 
         @Override
@@ -107,14 +107,14 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
                         }
 
                         TypeDescriptor parameterType = TypeDescriptor.parse(def.getParameterType());
-                        LocalVariableDefEntry localVariableEntry = new LocalVariableDefEntry(ownerMethod, parameterIndex, node.getName(), true, parameterType);
+                        LocalVariableDefEntry localVariableEntry = new LocalVariableDefEntry(ownerMethod, parameterIndex, node.getName(), true, parameterType, null);
                         Identifier identifier = node.getNameToken();
                         // cache the argument entry and the identifier
                         identifierEntryCache.put(identifier.getName(), localVariableEntry);
                         index.addDeclaration(identifier, localVariableEntry);
                 }
 
-                return recurse(node, index);
+                return visitChildren(node, index);
         }
 
         @Override
@@ -126,7 +126,7 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
                         index.addReference(node.getIdentifierToken(), fieldEntry, this.methodEntry);
                 } else
                         this.checkIdentifier(node, index);
-                return recurse(node, index);
+                return visitChildren(node, index);
         }
 
         private void checkIdentifier(IdentifierExpression node, SourceIndex index) {
@@ -157,7 +157,7 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
                         index.addReference(simpleTypeNode.getIdentifierToken(), constructorEntry, this.methodEntry);
                 }
 
-                return recurse(node, index);
+                return visitChildren(node, index);
         }
 
         @Override
@@ -177,7 +177,7 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
                                                 if (variableIndex >= 0) {
                                                         MethodDefEntry ownerMethod = MethodDefEntry.parse(originalVariable.getDeclaringMethod());
                                                         TypeDescriptor variableType = TypeDescriptor.parse(originalVariable.getVariableType());
-                                                        LocalVariableDefEntry localVariableEntry = new LocalVariableDefEntry(ownerMethod, variableIndex, initializer.getName(), false, variableType);
+                                                        LocalVariableDefEntry localVariableEntry = new LocalVariableDefEntry(ownerMethod, variableIndex, initializer.getName(), false, variableType, null);
                                                         identifierEntryCache.put(identifier.getName(), localVariableEntry);
                                                         addDeclarationToUnmatched(identifier.getName(), index);
                                                         index.addDeclaration(identifier, localVariableEntry);
@@ -186,7 +186,7 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
                                 }
                         }
                 }
-                return recurse(node, index);
+                return visitChildren(node, index);
         }
 
         @Override
@@ -211,6 +211,6 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
                         }
                 }
 
-                return recurse(node, index);
+                return visitChildren(node, index);
         }
 }
diff --git a/src/main/java/cuchaz/enigma/analysis/SourceIndexVisitor.java b/src/main/java/cuchaz/enigma/analysis/SourceIndexVisitor.java
index 75a66a2..8bd00a8 100644
--- a/src/main/java/cuchaz/enigma/analysis/SourceIndexVisitor.java
+++ b/src/main/java/cuchaz/enigma/analysis/SourceIndexVisitor.java
@@ -12,11 +12,13 @@
 package cuchaz.enigma.analysis;
 
 import com.strobel.assembler.metadata.TypeDefinition;
-import com.strobel.decompiler.languages.java.ast.*;
-import com.strobel.decompiler.patterns.Pattern;
+import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.DepthFirstAstVisitor;
+import com.strobel.decompiler.languages.java.ast.Keys;
+import com.strobel.decompiler.languages.java.ast.TypeDeclaration;
 import cuchaz.enigma.translation.representation.entry.ClassDefEntry;
 
-public class SourceIndexVisitor implements IAstVisitor<SourceIndex, Void> {
+public class SourceIndexVisitor extends DepthFirstAstVisitor<SourceIndex, Void> {
         @Override
         public Void visitTypeDeclaration(TypeDeclaration node, SourceIndex index) {
                 TypeDefinition def = node.getUserData(Keys.TYPE_DEFINITION);
@@ -26,355 +28,11 @@ public class SourceIndexVisitor implements IAstVisitor<SourceIndex, Void> {
                 return node.acceptVisitor(new SourceIndexClassVisitor(classEntry), index);
         }
 
-        protected Void recurse(AstNode node, SourceIndex index) {
+        @Override
+        protected Void visitChildren(AstNode node, SourceIndex index) {
                 for (final AstNode child : node.getChildren()) {
                         child.acceptVisitor(this, index);
                 }
                 return null;
         }
-
-        @Override
-        public Void visitMethodDeclaration(MethodDeclaration node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitConstructorDeclaration(ConstructorDeclaration node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitFieldDeclaration(FieldDeclaration node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitEnumValueDeclaration(EnumValueDeclaration node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitParameterDeclaration(ParameterDeclaration node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitInvocationExpression(InvocationExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitMemberReferenceExpression(MemberReferenceExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitSimpleType(SimpleType node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitIdentifierExpression(IdentifierExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitComment(Comment node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitPatternPlaceholder(AstNode node, Pattern pattern, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitTypeReference(TypeReferenceExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitJavaTokenNode(JavaTokenNode node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitIdentifier(Identifier node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitNullReferenceExpression(NullReferenceExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitThisReferenceExpression(ThisReferenceExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitSuperReferenceExpression(SuperReferenceExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitClassOfExpression(ClassOfExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitBlockStatement(BlockStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitExpressionStatement(ExpressionStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitBreakStatement(BreakStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitContinueStatement(ContinueStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitDoWhileStatement(DoWhileStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitEmptyStatement(EmptyStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitIfElseStatement(IfElseStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitLabelStatement(LabelStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitLabeledStatement(LabeledStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitReturnStatement(ReturnStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitSwitchStatement(SwitchStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitSwitchSection(SwitchSection node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitCaseLabel(CaseLabel node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitThrowStatement(ThrowStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitCatchClause(CatchClause node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitAnnotation(Annotation node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitNewLine(NewLineNode node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitVariableDeclaration(VariableDeclarationStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitVariableInitializer(VariableInitializer node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitText(TextNode node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitImportDeclaration(ImportDeclaration node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitInitializerBlock(InstanceInitializer node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitTypeParameterDeclaration(TypeParameterDeclaration node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitCompilationUnit(CompilationUnit node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitPackageDeclaration(PackageDeclaration node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitArraySpecifier(ArraySpecifier node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitComposedType(ComposedType node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitWhileStatement(WhileStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitPrimitiveExpression(PrimitiveExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitCastExpression(CastExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitBinaryOperatorExpression(BinaryOperatorExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitInstanceOfExpression(InstanceOfExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitIndexerExpression(IndexerExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitUnaryOperatorExpression(UnaryOperatorExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitConditionalExpression(ConditionalExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitArrayInitializerExpression(ArrayInitializerExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitObjectCreationExpression(ObjectCreationExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitArrayCreationExpression(ArrayCreationExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitAssignmentExpression(AssignmentExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitForStatement(ForStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitForEachStatement(ForEachStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitTryCatchStatement(TryCatchStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitGotoStatement(GotoStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitParenthesizedExpression(ParenthesizedExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitSynchronizedStatement(SynchronizedStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitAnonymousObjectCreationExpression(AnonymousObjectCreationExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitWildcardType(WildcardType node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitMethodGroupExpression(MethodGroupExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitAssertStatement(AssertStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitLambdaExpression(LambdaExpression node, SourceIndex index) {
-                return recurse(node, index);
-        }
-
-        @Override
-        public Void visitLocalTypeDeclarationStatement(LocalTypeDeclarationStatement node, SourceIndex index) {
-                return recurse(node, index);
-        }
 }
diff --git a/src/main/java/cuchaz/enigma/analysis/TreeDumpVisitor.java b/src/main/java/cuchaz/enigma/analysis/TreeDumpVisitor.java
index c98fb9e..c85d97a 100644
--- a/src/main/java/cuchaz/enigma/analysis/TreeDumpVisitor.java
+++ b/src/main/java/cuchaz/enigma/analysis/TreeDumpVisitor.java
@@ -18,7 +18,7 @@ import com.strobel.decompiler.patterns.Pattern;
 import java.io.*;
 import java.nio.charset.Charset;
 
-public class TreeDumpVisitor implements IAstVisitor<Void, Void> {
+public class TreeDumpVisitor extends DepthFirstAstVisitor<Void, Void> {
 
         private File file;
         private Writer out;
@@ -31,7 +31,7 @@ public class TreeDumpVisitor implements IAstVisitor<Void, Void> {
         public Void visitCompilationUnit(CompilationUnit node, Void ignored) {
                 try {
                         out = new OutputStreamWriter(new FileOutputStream(file), Charset.forName("UTF-8"));
-                        recurse(node, ignored);
+                        visitChildren(node, ignored);
                         out.close();
                         return null;
                 } catch (IOException ex) {
@@ -39,7 +39,8 @@ public class TreeDumpVisitor implements IAstVisitor<Void, Void> {
                 }
         }
 
-        private Void recurse(AstNode node, Void ignored) {
+        @Override
+        protected Void visitChildren(AstNode node, Void ignored) {
                 // show the tree
                 try {
                         out.write(getIndent(node) + node.getClass().getSimpleName() + " " + getText(node) + " " + dumpUserData(node) + " " + node.getRegion() + "\n");
@@ -89,351 +90,4 @@ public class TreeDumpVisitor implements IAstVisitor<Void, Void> {
                 }
                 return depth;
         }
-
-        // OVERRIDES WE DON'T CARE ABOUT
-
-        @Override
-        public Void visitInvocationExpression(InvocationExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitMemberReferenceExpression(MemberReferenceExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitSimpleType(SimpleType node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitMethodDeclaration(MethodDeclaration node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitConstructorDeclaration(ConstructorDeclaration node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitParameterDeclaration(ParameterDeclaration node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitFieldDeclaration(FieldDeclaration node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitTypeDeclaration(TypeDeclaration node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitComment(Comment node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitPatternPlaceholder(AstNode node, Pattern pattern, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitTypeReference(TypeReferenceExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitJavaTokenNode(JavaTokenNode node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitIdentifier(Identifier node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitNullReferenceExpression(NullReferenceExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitThisReferenceExpression(ThisReferenceExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitSuperReferenceExpression(SuperReferenceExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitClassOfExpression(ClassOfExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitBlockStatement(BlockStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitExpressionStatement(ExpressionStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitBreakStatement(BreakStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitContinueStatement(ContinueStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitDoWhileStatement(DoWhileStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitEmptyStatement(EmptyStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitIfElseStatement(IfElseStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitLabelStatement(LabelStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitLabeledStatement(LabeledStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitReturnStatement(ReturnStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitSwitchStatement(SwitchStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitSwitchSection(SwitchSection node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitCaseLabel(CaseLabel node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitThrowStatement(ThrowStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitCatchClause(CatchClause node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitAnnotation(Annotation node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitNewLine(NewLineNode node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitVariableDeclaration(VariableDeclarationStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitVariableInitializer(VariableInitializer node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitText(TextNode node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitImportDeclaration(ImportDeclaration node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitInitializerBlock(InstanceInitializer node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitTypeParameterDeclaration(TypeParameterDeclaration node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitPackageDeclaration(PackageDeclaration node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitArraySpecifier(ArraySpecifier node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitComposedType(ComposedType node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitWhileStatement(WhileStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitPrimitiveExpression(PrimitiveExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitCastExpression(CastExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitBinaryOperatorExpression(BinaryOperatorExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitInstanceOfExpression(InstanceOfExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitIndexerExpression(IndexerExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitIdentifierExpression(IdentifierExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitUnaryOperatorExpression(UnaryOperatorExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitConditionalExpression(ConditionalExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitArrayInitializerExpression(ArrayInitializerExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitObjectCreationExpression(ObjectCreationExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitArrayCreationExpression(ArrayCreationExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitAssignmentExpression(AssignmentExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitForStatement(ForStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitForEachStatement(ForEachStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitTryCatchStatement(TryCatchStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitGotoStatement(GotoStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitParenthesizedExpression(ParenthesizedExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitSynchronizedStatement(SynchronizedStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitAnonymousObjectCreationExpression(AnonymousObjectCreationExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitWildcardType(WildcardType node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitMethodGroupExpression(MethodGroupExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitEnumValueDeclaration(EnumValueDeclaration node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitAssertStatement(AssertStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitLambdaExpression(LambdaExpression node, Void ignored) {
-                return recurse(node, ignored);
-        }
-
-        @Override
-        public Void visitLocalTypeDeclarationStatement(LocalTypeDeclarationStatement node, Void ignored) {
-                return recurse(node, ignored);
-        }
 }