Merge pull request #62 from OpenModLoader/asm

ASM based class translator

1 files changed, 159 insertions, 476 deletions

diff --git a/src/main/java/cuchaz/enigma/analysis/JarIndex.java b/src/main/java/cuchaz/enigma/analysis/JarIndex.java
index d0d0f2c..5917a32 100644
--- a/src/main/java/cuchaz/enigma/analysis/JarIndex.java
+++ b/src/main/java/cuchaz/enigma/analysis/JarIndex.java
@@ -12,113 +12,73 @@
 package cuchaz.enigma.analysis;
 
 import com.google.common.collect.*;
+import cuchaz.enigma.bytecode.AccessFlags;
 import cuchaz.enigma.mapping.*;
-import cuchaz.enigma.mapping.Translator;
-import javassist.*;
-import javassist.bytecode.*;
-import javassist.expr.*;
+import cuchaz.enigma.mapping.entry.*;
+import org.objectweb.asm.Opcodes;
 
-import java.lang.reflect.Modifier;
 import java.util.*;
-import java.util.jar.JarFile;
 
 public class JarIndex {
 
+        private final ReferencedEntryPool entryPool;
+
         private Set<ClassEntry> obfClassEntries;
         private TranslationIndex translationIndex;
         private Map<Entry, Access> access;
-        private Multimap<ClassEntry, FieldEntry> fields;
-        private Multimap<ClassEntry, BehaviorEntry> behaviors;
-        private Multimap<String, MethodEntry> methodImplementations;
-        private Multimap<BehaviorEntry, EntryReference<BehaviorEntry, BehaviorEntry>> behaviorReferences;
-        private Multimap<FieldEntry, EntryReference<FieldEntry, BehaviorEntry>> fieldReferences;
+        private Multimap<ClassEntry, FieldDefEntry> fields;
+        private Multimap<ClassEntry, MethodDefEntry> methods;
+        private Multimap<String, MethodDefEntry> methodImplementations;
+        private Multimap<MethodEntry, EntryReference<MethodEntry, MethodDefEntry>> methodsReferencing;
+        private Multimap<MethodEntry, MethodEntry> methodReferences;
+        private Multimap<FieldEntry, EntryReference<FieldEntry, MethodDefEntry>> fieldReferences;
         private Multimap<ClassEntry, ClassEntry> innerClassesByOuter;
         private Map<ClassEntry, ClassEntry> outerClassesByInner;
-        private Map<ClassEntry, BehaviorEntry> anonymousClasses;
         private Map<MethodEntry, MethodEntry> bridgedMethods;
         private Set<MethodEntry> syntheticMethods;
 
-        public JarIndex() {
+        public JarIndex(ReferencedEntryPool entryPool) {
+                this.entryPool = entryPool;
                 this.obfClassEntries = Sets.newHashSet();
-                this.translationIndex = new TranslationIndex();
+                this.translationIndex = new TranslationIndex(entryPool);
                 this.access = Maps.newHashMap();
                 this.fields = HashMultimap.create();
-                this.behaviors = HashMultimap.create();
+                this.methods = HashMultimap.create();
                 this.methodImplementations = HashMultimap.create();
-                this.behaviorReferences = HashMultimap.create();
+                this.methodsReferencing = HashMultimap.create();
+                this.methodReferences = HashMultimap.create();
                 this.fieldReferences = HashMultimap.create();
                 this.innerClassesByOuter = HashMultimap.create();
                 this.outerClassesByInner = Maps.newHashMap();
-                this.anonymousClasses = Maps.newHashMap();
                 this.bridgedMethods = Maps.newHashMap();
                 this.syntheticMethods = Sets.newHashSet();
         }
 
-        public void indexJar(JarFile jar, boolean buildInnerClasses) {
+        public void indexJar(ParsedJar jar, boolean buildInnerClasses) {
 
                 // step 1: read the class names
-                this.obfClassEntries.addAll(JarClassIterator.getClassEntries(jar));
-
-                // step 2: index field/method/constructor access
-                for (CtClass c : JarClassIterator.classes(jar)) {
-                        for (CtField field : c.getDeclaredFields()) {
-                                FieldEntry fieldEntry = EntryFactory.getFieldEntry(field);
-                                this.access.put(fieldEntry, Access.get(field));
-                                this.fields.put(fieldEntry.getClassEntry(), fieldEntry);
-                        }
-                        for (CtBehavior behavior : c.getDeclaredBehaviors()) {
-                                BehaviorEntry behaviorEntry = EntryFactory.getBehaviorEntry(behavior);
-                                this.access.put(behaviorEntry, Access.get(behavior));
-                                this.behaviors.put(behaviorEntry.getClassEntry(), behaviorEntry);
-                        }
-                }
+                obfClassEntries.addAll(jar.getClassEntries());
 
-                // step 3: index extends, implements, fields, and methods
-                for (CtClass c : JarClassIterator.classes(jar)) {
-                        this.translationIndex.indexClass(c);
-                        String className = Descriptor.toJvmName(c.getName());
-                        for (String interfaceName : c.getClassFile().getInterfaces()) {
-                                className = Descriptor.toJvmName(className);
-                                interfaceName = Descriptor.toJvmName(interfaceName);
-                                if (className.equals(interfaceName)) {
-                                        throw new IllegalArgumentException("Class cannot be its own interface! " + className);
-                                }
-                        }
-                        for (CtBehavior behavior : c.getDeclaredBehaviors()) {
-                                indexBehavior(behavior);
-                        }
-                }
+                // step 2: index classes, fields, methods, interfaces
+                jar.visit(node -> node.accept(new IndexClassVisitor(this, Opcodes.ASM5)));
 
-                // step 4: index field, method, constructor references
-                for (CtClass c : JarClassIterator.classes(jar)) {
-                        for (CtBehavior behavior : c.getDeclaredBehaviors()) {
-                                indexBehaviorReferences(behavior);
+                // step 3: index field, method, constructor references
+                jar.visit(node -> node.accept(new IndexReferenceVisitor(this, Opcodes.ASM5)));
+
+                // step 4: index access and bridged methods
+                for (MethodDefEntry methodEntry : methods.values()) {
+                        // look for access and bridged methods
+                        MethodEntry accessedMethod = findAccessMethod(methodEntry);
+                        if (accessedMethod != null) {
+                                if (isBridgedMethod(accessedMethod, methodEntry)) {
+                                        this.bridgedMethods.put(methodEntry, accessedMethod);
+                                }
                         }
                 }
 
                 if (buildInnerClasses) {
-
                         // step 5: index inner classes and anonymous classes
-                        for (CtClass c : JarClassIterator.classes(jar)) {
-                                ClassEntry innerClassEntry = EntryFactory.getClassEntry(c);
-                                ClassEntry outerClassEntry = findOuterClass(c);
-                                if (outerClassEntry != null) {
-                                        this.innerClassesByOuter.put(outerClassEntry, innerClassEntry);
-                                        boolean innerWasAdded = this.outerClassesByInner.put(innerClassEntry, outerClassEntry) == null;
-                                        assert (innerWasAdded);
-
-                                        BehaviorEntry enclosingBehavior = isAnonymousClass(c, outerClassEntry);
-                                        if (enclosingBehavior != null) {
-                                                this.anonymousClasses.put(innerClassEntry, enclosingBehavior);
-
-                                                // DEBUG
-                                                //System.out.println("ANONYMOUS: " + outerClassEntry.getName() + "$" + innerClassEntry.getSimpleName());
-                                        }/* else {
-                                // DEBUG
-                        //System.out.println("INNER: " + outerClassEntry.getName() + "$" + innerClassEntry.getSimpleName());
-                    }*/
-                                }
-                        }
+                        jar.visit(node -> node.accept(new IndexInnerClassVisitor(this, Opcodes.ASM5)));
 
                         // step 6: update other indices with inner class info
                         Map<String, String> renames = Maps.newHashMap();
@@ -133,385 +93,138 @@ public class JarIndex {
                         EntryRenamer.renameClassesInSet(renames, this.obfClassEntries);
                         this.translationIndex.renameClasses(renames);
                         EntryRenamer.renameClassesInMultimap(renames, this.methodImplementations);
-                        EntryRenamer.renameClassesInMultimap(renames, this.behaviorReferences);
+                        EntryRenamer.renameClassesInMultimap(renames, this.methodsReferencing);
+                        EntryRenamer.renameClassesInMultimap(renames, this.methodReferences);
                         EntryRenamer.renameClassesInMultimap(renames, this.fieldReferences);
                         EntryRenamer.renameClassesInMap(renames, this.access);
                 }
         }
 
-        private void indexBehavior(CtBehavior behavior) {
-                // get the behavior entry
-                final BehaviorEntry behaviorEntry = EntryFactory.getBehaviorEntry(behavior);
-                if (behaviorEntry instanceof MethodEntry) {
-                        MethodEntry methodEntry = (MethodEntry) behaviorEntry;
-
-                        // is synthetic
-                        if ((behavior.getModifiers() & AccessFlag.SYNTHETIC) != 0) {
-                                syntheticMethods.add(methodEntry);
+        protected ClassDefEntry indexClass(int access, String name, String signature, String superName, String[] interfaces) {
+                for (String interfaceName : interfaces) {
+                        if (name.equals(interfaceName)) {
+                                throw new IllegalArgumentException("Class cannot be its own interface! " + name);
                         }
-
-                        // index implementation
-                        this.methodImplementations.put(behaviorEntry.getClassName(), methodEntry);
-
-                        // look for bridge and bridged methods
-                        CtMethod bridgedMethod = getBridgedMethod((CtMethod) behavior);
-                        if (bridgedMethod != null) {
-                                this.bridgedMethods.put(methodEntry, EntryFactory.getMethodEntry(bridgedMethod));
-                        }
-                }
-                // looks like we don't care about constructors here
-        }
-
-        private void indexBehaviorReferences(CtBehavior behavior) {
-                // index method calls
-                final BehaviorEntry behaviorEntry = EntryFactory.getBehaviorEntry(behavior);
-                try {
-                        behavior.instrument(new ExprEditor() {
-                                @Override
-                                public void edit(MethodCall call) {
-                                        MethodEntry calledMethodEntry = EntryFactory.getMethodEntry(call);
-                                        ClassEntry resolvedClassEntry = translationIndex.resolveEntryClass(calledMethodEntry);
-                                        if (resolvedClassEntry != null && !resolvedClassEntry.equals(calledMethodEntry.getClassEntry())) {
-                                                calledMethodEntry = new MethodEntry(
-                                                        resolvedClassEntry,
-                                                        calledMethodEntry.getName(),
-                                                        calledMethodEntry.getSignature()
-                                                );
-                                        }
-                                        EntryReference<BehaviorEntry, BehaviorEntry> reference = new EntryReference<>(
-                                                calledMethodEntry,
-                                                call.getMethodName(),
-                                                behaviorEntry
-                                        );
-                                        behaviorReferences.put(calledMethodEntry, reference);
-                                }
-
-                                @Override
-                                public void edit(FieldAccess call) {
-                                        FieldEntry calledFieldEntry = EntryFactory.getFieldEntry(call);
-                                        ClassEntry resolvedClassEntry = translationIndex.resolveEntryClass(calledFieldEntry);
-                                        if (resolvedClassEntry != null && !resolvedClassEntry.equals(calledFieldEntry.getClassEntry())) {
-                                                calledFieldEntry = new FieldEntry(calledFieldEntry, resolvedClassEntry);
-                                        }
-                                        EntryReference<FieldEntry, BehaviorEntry> reference = new EntryReference<>(
-                                                calledFieldEntry,
-                                                call.getFieldName(),
-                                                behaviorEntry
-                                        );
-                                        fieldReferences.put(calledFieldEntry, reference);
-                                }
-
-                                @Override
-                                public void edit(ConstructorCall call) {
-                                        ConstructorEntry calledConstructorEntry = EntryFactory.getConstructorEntry(call);
-                                        EntryReference<BehaviorEntry, BehaviorEntry> reference = new EntryReference<>(
-                                                calledConstructorEntry,
-                                                call.getMethodName(),
-                                                behaviorEntry
-                                        );
-                                        behaviorReferences.put(calledConstructorEntry, reference);
-                                }
-
-                                @Override
-                                public void edit(NewExpr call) {
-                                        ConstructorEntry calledConstructorEntry = EntryFactory.getConstructorEntry(call);
-                                        EntryReference<BehaviorEntry, BehaviorEntry> reference = new EntryReference<>(
-                                                calledConstructorEntry,
-                                                call.getClassName(),
-                                                behaviorEntry
-                                        );
-                                        behaviorReferences.put(calledConstructorEntry, reference);
-                                }
-                        });
-                } catch (CannotCompileException ex) {
-                        throw new Error(ex);
                 }
+                return this.translationIndex.indexClass(access, name, signature, superName, interfaces);
         }
 
-        private CtMethod getBridgedMethod(CtMethod method) {
-
-                // bridge methods just call another method, cast it to the return type, and return the result
-                // let's see if we can detect this scenario
-
-                // skip non-synthetic methods
-                if ((method.getModifiers() & AccessFlag.SYNTHETIC) == 0) {
-                        return null;
-                }
+        protected void indexField(ClassDefEntry owner, int access, String name, String desc, String signature) {
+                FieldDefEntry fieldEntry = new FieldDefEntry(owner, name, new TypeDescriptor(desc), Signature.createTypedSignature(signature), new AccessFlags(access));
+                this.translationIndex.indexField(fieldEntry);
+                this.access.put(fieldEntry, Access.get(access));
+                this.fields.put(fieldEntry.getOwnerClassEntry(), fieldEntry);
+        }
 
-                // get all the called methods
-                final List<MethodCall> methodCalls = Lists.newArrayList();
-                try {
-                        method.instrument(new ExprEditor() {
-                                @Override
-                                public void edit(MethodCall call) {
-                                        methodCalls.add(call);
-                                }
-                        });
-                } catch (CannotCompileException ex) {
-                        // this is stupid... we're not even compiling anything
-                        throw new Error(ex);
-                }
+        protected void indexMethod(ClassDefEntry owner, int access, String name, String desc, String signature) {
+                MethodDefEntry methodEntry = new MethodDefEntry(owner, name, new MethodDescriptor(desc), Signature.createSignature(signature), new AccessFlags(access));
+                this.translationIndex.indexMethod(methodEntry);
+                this.access.put(methodEntry, Access.get(access));
+                this.methods.put(methodEntry.getOwnerClassEntry(), methodEntry);
 
-                // is there just one?
-                if (methodCalls.size() != 1) {
-                        return null;
+                if (new AccessFlags(access).isSynthetic()) {
+                        syntheticMethods.add(methodEntry);
                 }
-                MethodCall call = methodCalls.get(0);
 
-                try {
-                        // we have a bridge method!
-                        return call.getMethod();
-                } catch (NotFoundException ex) {
-                        // can't find the type? not a bridge method
-                        return null;
+                // we don't care about constructors here
+                if (!methodEntry.isConstructor()) {
+                        // index implementation
+                        this.methodImplementations.put(methodEntry.getClassName(), methodEntry);
                 }
         }
 
-        private ClassEntry findOuterClass(CtClass c) {
-
-                ClassEntry classEntry = EntryFactory.getClassEntry(c);
-
-                // does this class already have an outer class?
-                if (classEntry.isInnerClass()) {
-                        return classEntry.getOuterClassEntry();
+        protected void indexMethodCall(MethodDefEntry callerEntry, String owner, String name, String desc) {
+                MethodEntry referencedMethod = new MethodEntry(entryPool.getClass(owner), name, new MethodDescriptor(desc));
+                ClassEntry resolvedClassEntry = translationIndex.resolveEntryOwner(referencedMethod);
+                if (resolvedClassEntry != null && !resolvedClassEntry.equals(referencedMethod.getOwnerClassEntry())) {
+                        referencedMethod = referencedMethod.updateOwnership(resolvedClassEntry);
                 }
-
-                // inner classes:
-                // have constructors that can (illegally) set synthetic fields
-                // the outer class is the only class that calls constructors
-
-                // use the synthetic fields to find the synthetic constructors
-                for (CtConstructor constructor : c.getDeclaredConstructors()) {
-                        Set<String> syntheticFieldTypes = Sets.newHashSet();
-                        if (!isIllegalConstructor(syntheticFieldTypes, constructor)) {
-                                continue;
-                        }
-
-                        ConstructorEntry constructorEntry = EntryFactory.getConstructorEntry(constructor);
-
-                        // gather the classes from the illegally-set synthetic fields
-                        Set<ClassEntry> illegallySetClasses = Sets.newHashSet();
-                        for (String type : syntheticFieldTypes) {
-                                if (type.startsWith("L")) {
-                                        ClassEntry outerClassEntry = new ClassEntry(type.substring(1, type.length() - 1));
-                                        if (isSaneOuterClass(outerClassEntry, classEntry)) {
-                                                illegallySetClasses.add(outerClassEntry);
-                                        }
-                                }
-                        }
-
-                        // who calls this constructor?
-                        Set<ClassEntry> callerClasses = Sets.newHashSet();
-                        for (EntryReference<BehaviorEntry, BehaviorEntry> reference : getBehaviorReferences(constructorEntry)) {
-
-                                // make sure it's not a call to super
-                                if (reference.entry instanceof ConstructorEntry && reference.context instanceof ConstructorEntry) {
-
-                                        // is the entry a superclass of the context?
-                                        ClassEntry calledClassEntry = reference.entry.getClassEntry();
-                                        ClassEntry superclassEntry = this.translationIndex.getSuperclass(reference.context.getClassEntry());
-                                        if (superclassEntry != null && superclassEntry.equals(calledClassEntry)) {
-                                                // it's a super call, skip
-                                                continue;
-                                        }
-                                }
-
-                                if (isSaneOuterClass(reference.context.getClassEntry(), classEntry)) {
-                                        callerClasses.add(reference.context.getClassEntry());
-                                }
-                        }
-
-                        // do we have an answer yet?
-                        if (callerClasses.isEmpty()) {
-                                if (illegallySetClasses.size() == 1) {
-                                        return illegallySetClasses.iterator().next();
-                                } else {
-                                        System.out.println(String.format("WARNING: Unable to find outer class for %s. No caller and no illegally set field classes.", classEntry));
-                                }
-                        } else {
-                                if (callerClasses.size() == 1) {
-                                        return callerClasses.iterator().next();
-                                } else {
-                                        // multiple callers, do the illegally set classes narrow it down?
-                                        Set<ClassEntry> intersection = Sets.newHashSet(callerClasses);
-                                        intersection.retainAll(illegallySetClasses);
-                                        if (intersection.size() == 1) {
-                                                return intersection.iterator().next();
-                                        } else {
-                                                System.out.println(String.format("WARNING: Unable to choose outer class for %s among options: %s", classEntry, callerClasses));
-                                        }
-                                }
-                        }
-                }
-
-                return null;
+                methodsReferencing.put(referencedMethod, new EntryReference<>(referencedMethod, referencedMethod.getName(), callerEntry));
+                methodReferences.put(callerEntry, referencedMethod);
         }
 
-        private boolean isSaneOuterClass(ClassEntry outerClassEntry, ClassEntry innerClassEntry) {
-
-                // clearly this would be silly
-                if (outerClassEntry.equals(innerClassEntry)) {
-                        return false;
+        protected void indexFieldAccess(MethodDefEntry callerEntry, String owner, String name, String desc) {
+                FieldEntry referencedField = new FieldEntry(entryPool.getClass(owner), name, new TypeDescriptor(desc));
+                ClassEntry resolvedClassEntry = translationIndex.resolveEntryOwner(referencedField);
+                if (resolvedClassEntry != null && !resolvedClassEntry.equals(referencedField.getOwnerClassEntry())) {
+                        referencedField = referencedField.updateOwnership(resolvedClassEntry);
                 }
-
-                // is the outer class in the jar?
-                return this.obfClassEntries.contains(outerClassEntry);
-
+                fieldReferences.put(referencedField, new EntryReference<>(referencedField, referencedField.getName(), callerEntry));
         }
 
-        @SuppressWarnings("unchecked")
-        private boolean isIllegalConstructor(Set<String> syntheticFieldTypes, CtConstructor constructor) {
+        public void indexInnerClass(ClassEntry innerEntry, ClassEntry outerEntry) {
+                this.innerClassesByOuter.put(outerEntry, innerEntry);
+                this.outerClassesByInner.putIfAbsent(innerEntry, outerEntry);
+        }
 
-                // illegal constructors only set synthetic member fields, then call super()
-                String className = constructor.getDeclaringClass().getName();
+        private MethodEntry findAccessMethod(MethodDefEntry method) {
 
-                // collect all the field accesses, constructor calls, and method calls
-                final List<FieldAccess> illegalFieldWrites = Lists.newArrayList();
-                final List<ConstructorCall> constructorCalls = Lists.newArrayList();
-                try {
-                        constructor.instrument(new ExprEditor() {
-                                @Override
-                                public void edit(FieldAccess fieldAccess) {
-                                        if (fieldAccess.isWriter() && constructorCalls.isEmpty()) {
-                                                illegalFieldWrites.add(fieldAccess);
-                                        }
-                                }
+                // we want to find all compiler-added methods that directly call another with no processing
 
-                                @Override
-                                public void edit(ConstructorCall constructorCall) {
-                                        constructorCalls.add(constructorCall);
-                                }
-                        });
-                } catch (CannotCompileException ex) {
-                        // we're not compiling anything... this is stupid
-                        throw new Error(ex);
-                }
-
-                // are there any illegal field writes?
-                if (illegalFieldWrites.isEmpty()) {
-                        return false;
+                // skip non-synthetic methods
+                if (!method.getAccess().isSynthetic()) {
+                        return null;
                 }
 
-                // are all the writes to synthetic fields?
-                for (FieldAccess fieldWrite : illegalFieldWrites) {
-
-                        // all illegal writes have to be to the local class
-                        if (!fieldWrite.getClassName().equals(className)) {
-                                System.err.println(String.format("WARNING: illegal write to non-member field %s.%s", fieldWrite.getClassName(), fieldWrite.getFieldName()));
-                                return false;
-                        }
-
-                        // find the field
-                        FieldInfo fieldInfo = null;
-                        for (FieldInfo info : (List<FieldInfo>) constructor.getDeclaringClass().getClassFile().getFields()) {
-                                if (info.getName().equals(fieldWrite.getFieldName()) && info.getDescriptor().equals(fieldWrite.getSignature())) {
-                                        fieldInfo = info;
-                                        break;
-                                }
-                        }
-                        if (fieldInfo == null) {
-                                // field is in a superclass or something, can't be a local synthetic member
-                                return false;
-                        }
+                // get all the methods that we call
+                final Collection<MethodEntry> referencedMethods = methodReferences.get(method);
 
-                        // is this field synthetic?
-                        boolean isSynthetic = (fieldInfo.getAccessFlags() & AccessFlag.SYNTHETIC) != 0;
-                        if (isSynthetic) {
-                                syntheticFieldTypes.add(fieldInfo.getDescriptor());
-                        } else {
-                                System.err.println(String.format("WARNING: illegal write to non synthetic field %s %s.%s", fieldInfo.getDescriptor(), className, fieldInfo.getName()));
-                                return false;
-                        }
+                // is there just one?
+                if (referencedMethods.size() != 1) {
+                        return null;
                 }
 
-                // we passed all the tests!
-                return true;
+                return referencedMethods.stream().findFirst().orElse(null);
         }
 
-        private BehaviorEntry isAnonymousClass(CtClass c, ClassEntry outerClassEntry) {
-
-                // is this class already marked anonymous?
-                EnclosingMethodAttribute enclosingMethodAttribute = (EnclosingMethodAttribute) c.getClassFile().getAttribute(EnclosingMethodAttribute.tag);
-                if (enclosingMethodAttribute != null) {
-                        if (enclosingMethodAttribute.methodIndex() > 0) {
-                                return EntryFactory.getBehaviorEntry(
-                                        Descriptor.toJvmName(enclosingMethodAttribute.className()),
-                                        enclosingMethodAttribute.methodName(),
-                                        enclosingMethodAttribute.methodDescriptor()
-                                );
-                        } else {
-                                // an attribute but no method? assume not anonymous
-                                return null;
-                        }
-                }
-
-                // if there's an inner class attribute, but not an enclosing method attribute, then it's not anonymous
-                InnerClassesAttribute innerClassesAttribute = (InnerClassesAttribute) c.getClassFile().getAttribute(InnerClassesAttribute.tag);
-                if (innerClassesAttribute != null) {
-                        return null;
+        private boolean isBridgedMethod(MethodEntry called, MethodEntry access) {
+                // Bridged methods will always have the same name as the method they are calling
+                // They will also have the same amount of parameters (though equal descriptors cannot be guaranteed)
+                if (!called.getName().equals(access.getName()) || called.getDesc().getArgumentDescs().size() != access.getDesc().getArgumentDescs().size()) {
+                        return false;
                 }
 
-                ClassEntry innerClassEntry = new ClassEntry(Descriptor.toJvmName(c.getName()));
-
-                // anonymous classes:
-                // can't be abstract
-                // have only one constructor
-                // it's called exactly once by the outer class
-                // the type the instance is assigned to can't be this type
-
-                // is abstract?
-                if (Modifier.isAbstract(c.getModifiers())) {
-                        return null;
+                TypeDescriptor accessReturn = access.getDesc().getReturnDesc();
+                TypeDescriptor calledReturn = called.getDesc().getReturnDesc();
+                if (calledReturn.isVoid() || calledReturn.isPrimitive() || accessReturn.isVoid() || accessReturn.isPrimitive()) {
+                        return false;
                 }
 
-                // is there exactly one constructor?
-                if (c.getDeclaredConstructors().length != 1) {
-                        return null;
+                // Bridged methods will never have the same type as what they are calling
+                if (accessReturn.equals(calledReturn)) {
+                        return false;
                 }
-                CtConstructor constructor = c.getDeclaredConstructors()[0];
 
-                // is this constructor called exactly once?
-                ConstructorEntry constructorEntry = EntryFactory.getConstructorEntry(constructor);
-                Collection<EntryReference<BehaviorEntry, BehaviorEntry>> references = getBehaviorReferences(constructorEntry);
-                if (references.size() != 1) {
-                        return null;
-                }
+                String accessType = accessReturn.toString();
 
-                // does the caller use this type?
-                BehaviorEntry caller = references.iterator().next().context;
-                for (FieldEntry fieldEntry : getReferencedFields(caller)) {
-                        if (fieldEntry.getType().hasClass() && fieldEntry.getType().getClassEntry().equals(innerClassEntry)) {
-                                // caller references this type, so it can't be anonymous
-                                return null;
-                        }
-                }
-                for (BehaviorEntry behaviorEntry : getReferencedBehaviors(caller)) {
-                        if (behaviorEntry.getSignature().hasClass(innerClassEntry)) {
-                                return null;
-                        }
+                // If we're casting down from generic type to type-erased Object we're a bridge method
+                if (accessType.equals("Ljava/lang/Object;")) {
+                        return true;
                 }
 
-                return caller;
+                // Now we need to detect cases where we are being casted down to a higher type bound
+                List<ClassEntry> calledAncestry = translationIndex.getAncestry(calledReturn.getTypeEntry());
+                return calledAncestry.contains(accessReturn.getTypeEntry());
         }
 
         public Set<ClassEntry> getObfClassEntries() {
                 return this.obfClassEntries;
         }
 
-        public Collection<FieldEntry> getObfFieldEntries() {
+        public Collection<FieldDefEntry> getObfFieldEntries() {
                 return this.fields.values();
         }
 
-        public Collection<FieldEntry> getObfFieldEntries(ClassEntry classEntry) {
+        public Collection<FieldDefEntry> getObfFieldEntries(ClassEntry classEntry) {
                 return this.fields.get(classEntry);
         }
 
-        public Collection<BehaviorEntry> getObfBehaviorEntries() {
-                return this.behaviors.values();
+        public Collection<MethodDefEntry> getObfBehaviorEntries() {
+                return this.methods.values();
         }
 
-        public Collection<BehaviorEntry> getObfBehaviorEntries(ClassEntry classEntry) {
-                return this.behaviors.get(classEntry);
+        public Collection<MethodDefEntry> getObfBehaviorEntries(ClassEntry classEntry) {
+                return this.methods.get(classEntry);
         }
 
         public TranslationIndex getTranslationIndex() {
@@ -533,8 +246,8 @@ public class JarIndex {
                         }
                 }
                 ClassInheritanceTreeNode rootNode = new ClassInheritanceTreeNode(
-                        deobfuscatingTranslator,
-                        ancestry.get(ancestry.size() - 1)
+                                deobfuscatingTranslator,
+                                ancestry.get(ancestry.size() - 1)
                 );
 
                 // expand all children recursively
@@ -557,28 +270,20 @@ public class JarIndex {
         public MethodInheritanceTreeNode getMethodInheritance(Translator deobfuscatingTranslator, MethodEntry obfMethodEntry) {
 
                 // travel to the ancestor implementation
-                ClassEntry baseImplementationClassEntry = obfMethodEntry.getClassEntry();
-                for (ClassEntry ancestorClassEntry : this.translationIndex.getAncestry(obfMethodEntry.getClassEntry())) {
-                        MethodEntry ancestorMethodEntry = new MethodEntry(
-                                new ClassEntry(ancestorClassEntry),
-                                obfMethodEntry.getName(),
-                                obfMethodEntry.getSignature()
-                        );
-                        if (containsObfBehavior(ancestorMethodEntry)) {
+                ClassEntry baseImplementationClassEntry = obfMethodEntry.getOwnerClassEntry();
+                for (ClassEntry ancestorClassEntry : this.translationIndex.getAncestry(obfMethodEntry.getOwnerClassEntry())) {
+                        MethodEntry ancestorMethodEntry = entryPool.getMethod(ancestorClassEntry, obfMethodEntry.getName(), obfMethodEntry.getDesc().toString());
+                        if (ancestorMethodEntry != null && containsObfMethod(ancestorMethodEntry)) {
                                 baseImplementationClassEntry = ancestorClassEntry;
                         }
                 }
 
                 // make a root node at the base
-                MethodEntry methodEntry = new MethodEntry(
-                        baseImplementationClassEntry,
-                        obfMethodEntry.getName(),
-                        obfMethodEntry.getSignature()
-                );
+                MethodEntry methodEntry = entryPool.getMethod(baseImplementationClassEntry, obfMethodEntry.getName(), obfMethodEntry.getDesc().toString());
                 MethodInheritanceTreeNode rootNode = new MethodInheritanceTreeNode(
-                        deobfuscatingTranslator,
-                        methodEntry,
-                        containsObfBehavior(methodEntry)
+                                deobfuscatingTranslator,
+                                methodEntry,
+                                containsObfMethod(methodEntry)
                 );
 
                 // expand the full tree
@@ -599,12 +304,8 @@ public class JarIndex {
                         for (ClassEntry interfaceEntry : getInterfaces(obfMethodEntry.getClassName())) {
 
                                 // is this method defined in this interface?
-                                MethodEntry methodInterface = new MethodEntry(
-                                        interfaceEntry,
-                                        obfMethodEntry.getName(),
-                                        obfMethodEntry.getSignature()
-                                );
-                                if (containsObfBehavior(methodInterface)) {
+                                MethodEntry methodInterface = entryPool.getMethod(interfaceEntry, obfMethodEntry.getName(), obfMethodEntry.getDesc().toString());
+                                if (methodInterface != null && containsObfMethod(methodInterface)) {
                                         interfaceMethodEntries.add(methodInterface);
                                 }
                         }
@@ -623,27 +324,30 @@ public class JarIndex {
 
         public Set<MethodEntry> getRelatedMethodImplementations(MethodEntry obfMethodEntry) {
                 Set<MethodEntry> methodEntries = Sets.newHashSet();
-                getRelatedMethodImplementations(methodEntries, getMethodInheritance(new Translator(), obfMethodEntry));
+                getRelatedMethodImplementations(methodEntries, getMethodInheritance(new DirectionalTranslator(entryPool), obfMethodEntry));
                 return methodEntries;
         }
 
         private void getRelatedMethodImplementations(Set<MethodEntry> methodEntries, MethodInheritanceTreeNode node) {
                 MethodEntry methodEntry = node.getMethodEntry();
+                if (methodEntries.contains(methodEntry)) {
+                        return;
+                }
 
-                if (containsObfBehavior(methodEntry)) {
+                if (containsObfMethod(methodEntry)) {
                         // collect the entry
                         methodEntries.add(methodEntry);
                 }
 
-                // look at bridged methods!
-                MethodEntry bridgedEntry = getBridgedMethod(methodEntry);
-                while (bridgedEntry != null) {
-                        methodEntries.addAll(getRelatedMethodImplementations(bridgedEntry));
-                        bridgedEntry = getBridgedMethod(bridgedEntry);
+                // look at bridge methods!
+                MethodEntry bridgedMethod = getBridgedMethod(methodEntry);
+                while (bridgedMethod != null) {
+                        methodEntries.addAll(getRelatedMethodImplementations(bridgedMethod));
+                        bridgedMethod = getBridgedMethod(bridgedMethod);
                 }
 
                 // look at interface methods too
-                for (MethodImplementationsTreeNode implementationsNode : getMethodImplementations(new Translator(), methodEntry)) {
+                for (MethodImplementationsTreeNode implementationsNode : getMethodImplementations(new DirectionalTranslator(entryPool), methodEntry)) {
                         getRelatedMethodImplementations(methodEntries, implementationsNode);
                 }
 
@@ -655,16 +359,16 @@ public class JarIndex {
 
         private void getRelatedMethodImplementations(Set<MethodEntry> methodEntries, MethodImplementationsTreeNode node) {
                 MethodEntry methodEntry = node.getMethodEntry();
-                if (containsObfBehavior(methodEntry)) {
+                if (containsObfMethod(methodEntry)) {
                         // collect the entry
                         methodEntries.add(methodEntry);
                 }
 
-                // look at bridged methods!
-                MethodEntry bridgedEntry = getBridgedMethod(methodEntry);
-                while (bridgedEntry != null) {
-                        methodEntries.addAll(getRelatedMethodImplementations(bridgedEntry));
-                        bridgedEntry = getBridgedMethod(bridgedEntry);
+                // look at bridge methods!
+                MethodEntry bridgedMethod = getBridgedMethod(methodEntry);
+                while (bridgedMethod != null) {
+                        methodEntries.addAll(getRelatedMethodImplementations(bridgedMethod));
+                        bridgedMethod = getBridgedMethod(bridgedMethod);
                 }
 
                 // recurse
@@ -673,34 +377,27 @@ public class JarIndex {
                 }
         }
 
-        public Collection<EntryReference<FieldEntry, BehaviorEntry>> getFieldReferences(FieldEntry fieldEntry) {
+        public Collection<EntryReference<FieldEntry, MethodDefEntry>> getFieldReferences(FieldEntry fieldEntry) {
                 return this.fieldReferences.get(fieldEntry);
         }
 
-        public Collection<FieldEntry> getReferencedFields(BehaviorEntry behaviorEntry) {
+        public Collection<FieldEntry> getReferencedFields(MethodDefEntry methodEntry) {
                 // linear search is fast enough for now
                 Set<FieldEntry> fieldEntries = Sets.newHashSet();
-                for (EntryReference<FieldEntry, BehaviorEntry> reference : this.fieldReferences.values()) {
-                        if (reference.context == behaviorEntry) {
+                for (EntryReference<FieldEntry, MethodDefEntry> reference : this.fieldReferences.values()) {
+                        if (reference.context == methodEntry) {
                                 fieldEntries.add(reference.entry);
                         }
                 }
                 return fieldEntries;
         }
 
-        public Collection<EntryReference<BehaviorEntry, BehaviorEntry>> getBehaviorReferences(BehaviorEntry behaviorEntry) {
-                return this.behaviorReferences.get(behaviorEntry);
+        public Collection<EntryReference<MethodEntry, MethodDefEntry>> getMethodsReferencing(MethodEntry methodEntry) {
+                return this.methodsReferencing.get(methodEntry);
         }
 
-        public Collection<BehaviorEntry> getReferencedBehaviors(BehaviorEntry behaviorEntry) {
-                // linear search is fast enough for now
-                Set<BehaviorEntry> behaviorEntries = Sets.newHashSet();
-                for (EntryReference<BehaviorEntry, BehaviorEntry> reference : this.behaviorReferences.values()) {
-                        if (reference.context == behaviorEntry) {
-                                behaviorEntries.add(reference.entry);
-                        }
-                }
-                return behaviorEntries;
+        public Collection<MethodEntry> getReferencedMethods(MethodDefEntry methodEntry) {
+                return this.methodReferences.get(methodEntry);
         }
 
         public Collection<ClassEntry> getInnerClasses(ClassEntry obfOuterClassEntry) {
@@ -711,22 +408,13 @@ public class JarIndex {
                 return this.outerClassesByInner.get(obfInnerClassEntry);
         }
 
-        public boolean isAnonymousClass(ClassEntry obfInnerClassEntry) {
-                return this.anonymousClasses.containsKey(obfInnerClassEntry);
-        }
-
         public boolean isSyntheticMethod(MethodEntry methodEntry) {
                 return this.syntheticMethods.contains(methodEntry);
         }
 
-        public BehaviorEntry getAnonymousClassCaller(ClassEntry obfInnerClassName) {
-                return this.anonymousClasses.get(obfInnerClassName);
-        }
-
         public Set<ClassEntry> getInterfaces(String className) {
-                ClassEntry classEntry = new ClassEntry(className);
-                Set<ClassEntry> interfaces = new HashSet<>();
-                interfaces.addAll(this.translationIndex.getInterfaces(classEntry));
+                ClassEntry classEntry = entryPool.getClass(className);
+                Set<ClassEntry> interfaces = new HashSet<>(this.translationIndex.getInterfaces(classEntry));
                 for (ClassEntry ancestor : this.translationIndex.getAncestry(classEntry)) {
                         interfaces.addAll(this.translationIndex.getInterfaces(ancestor));
                 }
@@ -754,7 +442,7 @@ public class JarIndex {
         }
 
         public boolean isInterface(String className) {
-                return this.translationIndex.isInterface(new ClassEntry(className));
+                return this.translationIndex.isInterface(entryPool.getClass(className));
         }
 
         public boolean containsObfClass(ClassEntry obfClassEntry) {
@@ -765,8 +453,8 @@ public class JarIndex {
                 return this.access.containsKey(obfFieldEntry);
         }
 
-        public boolean containsObfBehavior(BehaviorEntry obfBehaviorEntry) {
-                return this.access.containsKey(obfBehaviorEntry);
+        public boolean containsObfMethod(MethodEntry obfMethodEntry) {
+                return this.access.containsKey(obfMethodEntry);
         }
 
         public boolean containsEntryWithSameName(Entry entry) {
@@ -776,15 +464,13 @@ public class JarIndex {
                 return false;
         }
 
-        public boolean containsObfArgument(ArgumentEntry obfArgumentEntry) {
+        public boolean containsObfVariable(LocalVariableEntry obfVariableEntry) {
                 // check the behavior
-                if (!containsObfBehavior(obfArgumentEntry.getBehaviorEntry())) {
+                if (!containsObfMethod(obfVariableEntry.getOwnerEntry())) {
                         return false;
                 }
 
-                // check the argument
-                return obfArgumentEntry.getIndex() < obfArgumentEntry.getBehaviorEntry().getSignature().getArgumentTypes().size();
-
+                return true;
         }
 
         public boolean containsObfEntry(Entry obfEntry) {
@@ -792,15 +478,12 @@ public class JarIndex {
                         return containsObfClass((ClassEntry) obfEntry);
                 } else if (obfEntry instanceof FieldEntry) {
                         return containsObfField((FieldEntry) obfEntry);
-                } else if (obfEntry instanceof BehaviorEntry) {
-                        return containsObfBehavior((BehaviorEntry) obfEntry);
-                } else if (obfEntry instanceof ArgumentEntry) {
-                        return containsObfArgument((ArgumentEntry) obfEntry);
+                } else if (obfEntry instanceof MethodEntry) {
+                        return containsObfMethod((MethodEntry) obfEntry);
                 } else if (obfEntry instanceof LocalVariableEntry) {
-                        // TODO: Implement it
-                        return false;
+                        return containsObfVariable((LocalVariableEntry) obfEntry);
                 } else {
-                        throw new Error("Entry type not supported: " + obfEntry.getClass().getName());
+                        throw new Error("Entry desc not supported: " + obfEntry.getClass().getName());
                 }
         }