ASM Based Class Translator (#1)

* Initial port to ASM

* Package updates

* Annotation + inner class translation

* Fix inner class mapping

* More bytecode translation

* Signature refactoring

* Fix highlighting of mapped names

* Fix parameter name offset

* Fix anonymous class generation

* Fix issues with inner class signature transformation

* Fix bridged method detection

* Fix compile issues

* Resolve all failed tests

* Apply deobfuscated name to transformed classes

* Fix class signatures not being translated

* Fix frame array type translation

* Fix frame array type translation

* Fix array translation in method calls

* Fix method reference and bridge detection

* Fix handling of null deobf mappings

* Parameter translation in interfaces

* Fix enum parameter index offset

* Fix parsed local variable indexing

* Fix stackoverflow on rebuilding method names

* Ignore invalid decompiled variable indices

* basic source jar

* Output directly to file on source export

* Make decompile parallel

* fix incorrect super calls

* Use previous save state to delete old mapping files

* Fix old mappings not properly being removed

* Fix old mappings not properly being removed

* make isMethodProvider public

(cherry picked from commit ebad6a9)

* speed up Deobfuscator's getSources by using a single TranslatingTypeloader and caching the ClassLoaderTypeloader

* ignore .idea project folders

* move SynchronizedTypeLoader to a non-inner

* fix signature remap of inners for now

* index & resolve method/field references for usages view

* Allow reader/writer subclasses to provide the underlying file operations

* fix giving obf classes a name not removing them from the panel

* buffer the ParsedJar class entry inputstream, allow use with a jarinputstream

* make CachingClasspathTypeLoader public

* make CachingClasspathTypeLoader public

* support enum switches with obfuscated SwitchMaps

1 files changed, 94 insertions, 0 deletions

diff --git a/src/main/java/cuchaz/enigma/analysis/MethodReferenceTreeNode.java b/src/main/java/cuchaz/enigma/analysis/MethodReferenceTreeNode.java
new file mode 100644
index 0000000..76c73c1
--- /dev/null
+++ b/src/main/java/cuchaz/enigma/analysis/MethodReferenceTreeNode.java
@@ -0,0 +1,94 @@
+/*******************************************************************************
+ * 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.google.common.collect.Sets;
+import cuchaz.enigma.mapping.*;
+import cuchaz.enigma.mapping.entry.Entry;
+import cuchaz.enigma.mapping.entry.MethodDefEntry;
+import cuchaz.enigma.mapping.entry.MethodEntry;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.TreeNode;
+import java.util.Set;
+
+public class MethodReferenceTreeNode extends DefaultMutableTreeNode
+        implements ReferenceTreeNode<MethodEntry, MethodDefEntry> {
+
+        private Translator deobfuscatingTranslator;
+        private MethodEntry entry;
+        private EntryReference<MethodEntry, MethodDefEntry> reference;
+        private Access access;
+
+        public MethodReferenceTreeNode(Translator deobfuscatingTranslator, MethodEntry entry) {
+                this.deobfuscatingTranslator = deobfuscatingTranslator;
+                this.entry = entry;
+                this.reference = null;
+        }
+
+        public MethodReferenceTreeNode(Translator deobfuscatingTranslator,
+                                                                   EntryReference<MethodEntry, MethodDefEntry> reference, Access access) {
+                this.deobfuscatingTranslator = deobfuscatingTranslator;
+                this.entry = reference.entry;
+                this.reference = reference;
+                this.access = access;
+        }
+
+        @Override
+        public MethodEntry getEntry() {
+                return this.entry;
+        }
+
+        @Override
+        public EntryReference<MethodEntry, MethodDefEntry> getReference() {
+                return this.reference;
+        }
+
+        @Override
+        public String toString() {
+                if (this.reference != null) {
+                        return String.format("%s (%s)", this.deobfuscatingTranslator.getTranslatedMethodDef(this.reference.context),
+                                this.access);
+                }
+                return this.deobfuscatingTranslator.getTranslatedMethod(this.entry).getName();
+        }
+
+        public void load(JarIndex index, boolean recurse) {
+                // get all the child nodes
+                for (EntryReference<MethodEntry, MethodDefEntry> reference : index.getMethodsReferencing(this.entry)) {
+                        add(new MethodReferenceTreeNode(this.deobfuscatingTranslator, reference, index.getAccess(this.entry)));
+                }
+
+                if (recurse && this.children != null) {
+                        for (Object child : this.children) {
+                                if (child instanceof MethodReferenceTreeNode) {
+                                        MethodReferenceTreeNode node = (MethodReferenceTreeNode) child;
+
+                                        // don't recurse into ancestor
+                                        Set<Entry> ancestors = Sets.newHashSet();
+                                        TreeNode n = node;
+                                        while (n.getParent() != null) {
+                                                n = n.getParent();
+                                                if (n instanceof MethodReferenceTreeNode) {
+                                                        ancestors.add(((MethodReferenceTreeNode) n).getEntry());
+                                                }
+                                        }
+                                        if (ancestors.contains(node.getEntry())) {
+                                                continue;
+                                        }
+
+                                        node.load(index, true);
+                                }
+                        }
+                }
+        }
+}