Revert "Removed unused methods"

This reverts commit 1742190f784d0d62e7cc869eebafdfe1927e448f.

8 files changed, 546 insertions, 2 deletions

diff --git a/src/main/java/cuchaz/enigma/analysis/Access.java b/src/main/java/cuchaz/enigma/analysis/Access.java
index ec5ac1e..877327f 100644
--- a/src/main/java/cuchaz/enigma/analysis/Access.java
+++ b/src/main/java/cuchaz/enigma/analysis/Access.java
@@ -30,7 +30,9 @@ public enum Access {
     }
 
     public static Access get(int modifiers) {
-        if (Modifier.isProtected(modifiers)) {
+        if (Modifier.isPublic(modifiers)) {
+            return Public;
+        } else if (Modifier.isProtected(modifiers)) {
             return Protected;
         } else if (Modifier.isPrivate(modifiers)) {
             return Private;
diff --git a/src/main/java/cuchaz/enigma/analysis/BridgeMarker.java b/src/main/java/cuchaz/enigma/analysis/BridgeMarker.java
index d6db11c..cd18584 100644
--- a/src/main/java/cuchaz/enigma/analysis/BridgeMarker.java
+++ b/src/main/java/cuchaz/enigma/analysis/BridgeMarker.java
@@ -18,7 +18,7 @@ import javassist.bytecode.AccessFlag;
 
 public class BridgeMarker {
 
-    private final JarIndex m_jarIndex;
+    private JarIndex m_jarIndex;
 
     public BridgeMarker(JarIndex jarIndex) {
         this.m_jarIndex = jarIndex;
diff --git a/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java b/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java
index f5227bb..2a231cb 100644
--- a/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java
+++ b/src/main/java/cuchaz/enigma/analysis/ClassImplementationsTreeNode.java
@@ -17,6 +17,7 @@ import java.util.List;
 import javax.swing.tree.DefaultMutableTreeNode;
 
 import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.MethodEntry;
 import cuchaz.enigma.mapping.Translator;
 
 public class ClassImplementationsTreeNode extends DefaultMutableTreeNode {
@@ -56,4 +57,20 @@ public class ClassImplementationsTreeNode extends DefaultMutableTreeNode {
         // add them to this node
         nodes.forEach(this::add);
     }
+
+    public static ClassImplementationsTreeNode findNode(ClassImplementationsTreeNode node, MethodEntry entry) {
+        // is this the node?
+        if (node.entry.equals(entry)) {
+            return node;
+        }
+
+        // recurse
+        for (int i = 0; i < node.getChildCount(); i++) {
+            ClassImplementationsTreeNode foundNode = findNode((ClassImplementationsTreeNode) node.getChildAt(i), entry);
+            if (foundNode != null) {
+                return foundNode;
+            }
+        }
+        return null;
+    }
 }
diff --git a/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java b/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java
index f0e7306..7233fcf 100644
--- a/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java
+++ b/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java
@@ -56,6 +56,59 @@ public class EntryRenamer {
         }
     }
 
+    public static <Key, Val> void renameMethodsInMultimap(Map<MethodEntry, MethodEntry> renames, Multimap<Key, Val> map) {
+        // for each key/value pair...
+        Set<Map.Entry<Key, Val>> entriesToAdd = Sets.newHashSet();
+        for (Map.Entry<Key, Val> entry : map.entries()) {
+            entriesToAdd.add(new AbstractMap.SimpleEntry<>(renameMethodsInThing(renames, entry.getKey()), renameMethodsInThing(renames, entry.getValue())));
+        }
+        map.clear();
+        for (Map.Entry<Key, Val> entry : entriesToAdd) {
+            map.put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    public static <Key, Val> void renameMethodsInMap(Map<MethodEntry, MethodEntry> renames, Map<Key, Val> map) {
+        // for each key/value pair...
+        Set<Map.Entry<Key, Val>> entriesToAdd = Sets.newHashSet();
+        for (Map.Entry<Key, Val> entry : map.entrySet()) {
+            entriesToAdd.add(new AbstractMap.SimpleEntry<>(renameMethodsInThing(renames, entry.getKey()), renameMethodsInThing(renames, entry.getValue())));
+        }
+        map.clear();
+        for (Map.Entry<Key, Val> entry : entriesToAdd) {
+            map.put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> T renameMethodsInThing(Map<MethodEntry,MethodEntry> renames, T thing) {
+        if (thing instanceof MethodEntry) {
+            MethodEntry methodEntry = (MethodEntry)thing;
+            MethodEntry newMethodEntry = renames.get(methodEntry);
+            if (newMethodEntry != null) {
+                return (T)new MethodEntry(
+                        methodEntry.getClassEntry(),
+                        newMethodEntry.getName(),
+                        methodEntry.getSignature()
+                );
+            }
+            return thing;
+        } else if (thing instanceof ArgumentEntry) {
+            ArgumentEntry argumentEntry = (ArgumentEntry)thing;
+            return (T)new ArgumentEntry(
+                    renameMethodsInThing(renames, argumentEntry.getBehaviorEntry()),
+                    argumentEntry.getIndex(),
+                    argumentEntry.getName()
+            );
+        } else if (thing instanceof EntryReference) {
+            EntryReference<Entry,Entry> reference = (EntryReference<Entry,Entry>)thing;
+            reference.entry = renameMethodsInThing(renames, reference.entry);
+            reference.context = renameMethodsInThing(renames, reference.context);
+            return thing;
+        }
+        return thing;
+    }
+
     @SuppressWarnings("unchecked")
     public static <T> T renameClassesInThing(final Map<String, String> renames, T thing) {
         if (thing instanceof String) {
diff --git a/src/main/java/cuchaz/enigma/analysis/JarIndex.java b/src/main/java/cuchaz/enigma/analysis/JarIndex.java
index 51a2543..bb36c9e 100644
--- a/src/main/java/cuchaz/enigma/analysis/JarIndex.java
+++ b/src/main/java/cuchaz/enigma/analysis/JarIndex.java
@@ -503,6 +503,22 @@ public class JarIndex {
         return this.obfClassEntries;
     }
 
+    public Collection<FieldEntry> getObfFieldEntries() {
+        return this.fields.values();
+    }
+
+    public Collection<FieldEntry> getObfFieldEntries(ClassEntry classEntry) {
+        return this.fields.get(classEntry);
+    }
+
+    public Collection<BehaviorEntry> getObfBehaviorEntries() {
+        return this.behaviors.values();
+    }
+
+    public Collection<BehaviorEntry> getObfBehaviorEntries(ClassEntry classEntry) {
+        return this.behaviors.get(classEntry);
+    }
+
     public TranslationIndex getTranslationIndex() {
         return this.translationIndex;
     }
diff --git a/src/main/java/cuchaz/enigma/analysis/SourceIndex.java b/src/main/java/cuchaz/enigma/analysis/SourceIndex.java
index 73e0431..719930e 100644
--- a/src/main/java/cuchaz/enigma/analysis/SourceIndex.java
+++ b/src/main/java/cuchaz/enigma/analysis/SourceIndex.java
@@ -145,6 +145,14 @@ public class SourceIndex {
         return this.tokenToReference.keySet();
     }
 
+    public Iterable<Token> declarationTokens() {
+        return this.declarationToToken.values();
+    }
+
+    public Iterable<Entry> declarations() {
+        return this.declarationToToken.keySet();
+    }
+
     public Token getDeclarationToken(Entry deobfEntry) {
         return this.declarationToToken.get(deobfEntry);
     }
diff --git a/src/main/java/cuchaz/enigma/analysis/TranslationIndex.java b/src/main/java/cuchaz/enigma/analysis/TranslationIndex.java
index 921fff4..17bf51b 100644
--- a/src/main/java/cuchaz/enigma/analysis/TranslationIndex.java
+++ b/src/main/java/cuchaz/enigma/analysis/TranslationIndex.java
@@ -148,6 +148,13 @@ public class TranslationIndex {
         return subclasses;
     }
 
+    public void getSubclassesRecursively(Set<ClassEntry> out, ClassEntry classEntry) {
+        for (ClassEntry subclassEntry : getSubclass(classEntry)) {
+            out.add(subclassEntry);
+            getSubclassesRecursively(out, subclassEntry);
+        }
+    }
+
     public void getSubclassNamesRecursively(Set<String> out, ClassEntry classEntry) {
         for (ClassEntry subclassEntry : getSubclass(classEntry)) {
             out.add(subclassEntry.getName());
diff --git a/src/main/java/cuchaz/enigma/analysis/TreeDumpVisitor.java b/src/main/java/cuchaz/enigma/analysis/TreeDumpVisitor.java
new file mode 100644
index 0000000..ef8a190
--- /dev/null
+++ b/src/main/java/cuchaz/enigma/analysis/TreeDumpVisitor.java
@@ -0,0 +1,441 @@
+/*******************************************************************************
+ * Copyright (c) 2015 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser General Public
+ * License v3.0 which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/lgpl.html
+ * <p>
+ * Contributors:
+ * Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import com.strobel.componentmodel.Key;
+import com.strobel.decompiler.languages.java.ast.*;
+import com.strobel.decompiler.patterns.Pattern;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Writer;
+
+public class TreeDumpVisitor implements IAstVisitor<Void, Void> {
+
+    private File m_file;
+    private Writer m_out;
+
+    public TreeDumpVisitor(File file) {
+        m_file = file;
+        m_out = null;
+    }
+
+    @Override
+    public Void visitCompilationUnit(CompilationUnit node, Void ignored) {
+        try {
+            m_out = new FileWriter(m_file);
+            recurse(node, ignored);
+            m_out.close();
+            return null;
+        } catch (IOException ex) {
+            throw new Error(ex);
+        }
+    }
+
+    private Void recurse(AstNode node, Void ignored) {
+        // show the tree
+        try {
+            m_out.write(getIndent(node) + node.getClass().getSimpleName() + " " + getText(node) + " " + dumpUserData(node) + " " + node.getRegion() + "\n");
+        } catch (IOException ex) {
+            throw new Error(ex);
+        }
+
+        // recurse
+        for (final AstNode child : node.getChildren()) {
+            child.acceptVisitor(this, ignored);
+        }
+        return null;
+    }
+
+    private String getText(AstNode node) {
+        if (node instanceof Identifier) {
+            return "\"" + ((Identifier) node).getName() + "\"";
+        }
+        return "";
+    }
+
+    private String dumpUserData(AstNode node) {
+        StringBuilder buf = new StringBuilder();
+        for (Key<?> key : Keys.ALL_KEYS) {
+            Object val = node.getUserData(key);
+            if (val != null) {
+                buf.append(String.format(" [%s=%s]", key, val));
+            }
+        }
+        return buf.toString();
+    }
+
+    private String getIndent(AstNode node) {
+        StringBuilder buf = new StringBuilder();
+        int depth = getDepth(node);
+        for (int i = 0; i < depth; i++) {
+            buf.append("\t");
+        }
+        return buf.toString();
+    }
+
+    private int getDepth(AstNode node) {
+        int depth = -1;
+        while (node != null) {
+            depth++;
+            node = node.getParent();
+        }
+        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);
+    }
+}