[WIP] Mapping rework (#91)

* Move packages

* Mapping & entry refactor: first pass

* Fix deobf -> obf tree remapping

* Resolve various issues

* Give all entries the potential for parents and treat inner classes as children

* Deobf UI tree elements

* Tests pass

* Sort mapping output

* Fix delta tracking

* Index separation and first pass for #97

* Keep track of remapped jar index

* Fix child entries not being remapped

* Drop non-root entries

* Track dropped mappings

* Fix enigma mapping ordering

* EntryTreeNode interface

* Small tweaks

* Naive full index remap on rename

* Entries can resolve to more than one root entry

* Support alternative resolution strategies

* Bridge method resolution

* Tests pass

* Fix mappings being used where there are none

* Fix methods with different descriptors being considered unique. closes #89

13 files changed, 167 insertions, 177 deletions

diff --git a/src/test/java/cuchaz/enigma/TestDeobfed.java b/src/test/java/cuchaz/enigma/TestDeobfed.java
index 9babf1e3..25cb60c5 100644
--- a/src/test/java/cuchaz/enigma/TestDeobfed.java
+++ b/src/test/java/cuchaz/enigma/TestDeobfed.java
@@ -11,9 +11,8 @@
 
 package cuchaz.enigma;
 
-import cuchaz.enigma.analysis.JarIndex;
 import cuchaz.enigma.analysis.ParsedJar;
-import cuchaz.enigma.mapping.entry.ReferencedEntryPool;
+import cuchaz.enigma.analysis.index.JarIndex;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
@@ -32,13 +31,13 @@ public class TestDeobfed {
         public static void beforeClass()
                 throws Exception {
                 jar = new ParsedJar(new JarFile("build/test-deobf/translation.jar"));
-                index = new JarIndex(new ReferencedEntryPool());
-                index.indexJar(jar, true);
+                index = JarIndex.empty();
+                index.indexJar(jar, s -> {});
         }
 
         @Test
         public void obfEntries() {
-                assertThat(index.getObfClassEntries(), containsInAnyOrder(
+                assertThat(index.getEntryIndex().getClasses(), containsInAnyOrder(
                         newClass("cuchaz/enigma/inputs/Keep"),
                         newClass("a"),
                         newClass("b"),
diff --git a/src/test/java/cuchaz/enigma/TestDeobfuscator.java b/src/test/java/cuchaz/enigma/TestDeobfuscator.java
index 63a6f552..5f117213 100644
--- a/src/test/java/cuchaz/enigma/TestDeobfuscator.java
+++ b/src/test/java/cuchaz/enigma/TestDeobfuscator.java
@@ -12,7 +12,7 @@
 package cuchaz.enigma;
 
 import com.google.common.collect.Lists;
-import cuchaz.enigma.mapping.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
 import org.junit.Test;
 
 import java.io.IOException;
diff --git a/src/test/java/cuchaz/enigma/TestEntryFactory.java b/src/test/java/cuchaz/enigma/TestEntryFactory.java
index 4f52609e..9e1425a2 100644
--- a/src/test/java/cuchaz/enigma/TestEntryFactory.java
+++ b/src/test/java/cuchaz/enigma/TestEntryFactory.java
@@ -12,10 +12,10 @@
 package cuchaz.enigma;
 
 import cuchaz.enigma.analysis.EntryReference;
-import cuchaz.enigma.mapping.*;
-import cuchaz.enigma.mapping.entry.ClassEntry;
-import cuchaz.enigma.mapping.entry.FieldEntry;
-import cuchaz.enigma.mapping.entry.MethodEntry;
+import cuchaz.enigma.translation.representation.*;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.FieldEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
 
 public class TestEntryFactory {
 
diff --git a/src/test/java/cuchaz/enigma/TestInnerClasses.java b/src/test/java/cuchaz/enigma/TestInnerClasses.java
index 843a63c7..0319cf61 100644
--- a/src/test/java/cuchaz/enigma/TestInnerClasses.java
+++ b/src/test/java/cuchaz/enigma/TestInnerClasses.java
@@ -11,20 +11,16 @@
 
 package cuchaz.enigma;
 
-import cuchaz.enigma.analysis.JarIndex;
 import cuchaz.enigma.analysis.ParsedJar;
-import cuchaz.enigma.mapping.entry.ClassEntry;
-import cuchaz.enigma.mapping.entry.ReferencedEntryPool;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
 import org.junit.Test;
 
 import java.util.jar.JarFile;
 
 import static cuchaz.enigma.TestEntryFactory.newClass;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.empty;
 import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.nullValue;
 
 public class TestInnerClasses {
 
@@ -41,23 +37,19 @@ public class TestInnerClasses {
 
         public TestInnerClasses()
                 throws Exception {
-                index = new JarIndex(new ReferencedEntryPool());
+                index = JarIndex.empty();
                 ParsedJar jar = new ParsedJar(new JarFile("build/test-obf/innerClasses.jar"));
-                index.indexJar(jar, true);
+                index.indexJar(jar, s -> {});
                 deobfuscator = new Deobfuscator(jar);
         }
 
         @Test
         public void simple() {
-                assertThat(index.getOuterClass(SimpleInner), is(SimpleOuter));
-                assertThat(index.getInnerClasses(SimpleOuter), containsInAnyOrder(SimpleInner));
                 decompile(SimpleOuter);
         }
 
         @Test
         public void constructorArgs() {
-                assertThat(index.getOuterClass(ConstructorArgsInner), is(ConstructorArgsOuter));
-                assertThat(index.getInnerClasses(ConstructorArgsOuter), containsInAnyOrder(ConstructorArgsInner));
                 decompile(ConstructorArgsOuter);
         }
 
@@ -65,33 +57,25 @@ public class TestInnerClasses {
         public void classTree() {
 
                 // root level
-                assertThat(index.containsObfClass(ClassTreeRoot), is(true));
-                assertThat(index.getOuterClass(ClassTreeRoot), is(nullValue()));
-                assertThat(index.getInnerClasses(ClassTreeRoot), containsInAnyOrder(ClassTreeLevel1));
+                assertThat(index.getEntryIndex().hasClass(ClassTreeRoot), is(true));
 
                 // level 1
                 ClassEntry fullClassEntry = new ClassEntry(ClassTreeRoot.getName()
-                        + "$" + ClassTreeLevel1.getInnermostClassName());
-                assertThat(index.containsObfClass(fullClassEntry), is(true));
-                assertThat(index.getOuterClass(ClassTreeLevel1), is(ClassTreeRoot));
-                assertThat(index.getInnerClasses(ClassTreeLevel1), containsInAnyOrder(ClassTreeLevel2));
+                        + "$" + ClassTreeLevel1.getSimpleName());
+                assertThat(index.getEntryIndex().hasClass(fullClassEntry), is(true));
 
                 // level 2
                 fullClassEntry = new ClassEntry(ClassTreeRoot.getName()
-                        + "$" + ClassTreeLevel1.getInnermostClassName()
-                        + "$" + ClassTreeLevel2.getInnermostClassName());
-                assertThat(index.containsObfClass(fullClassEntry), is(true));
-                assertThat(index.getOuterClass(ClassTreeLevel2), is(ClassTreeLevel1));
-                assertThat(index.getInnerClasses(ClassTreeLevel2), containsInAnyOrder(ClassTreeLevel3));
+                        + "$" + ClassTreeLevel1.getSimpleName()
+                        + "$" + ClassTreeLevel2.getSimpleName());
+                assertThat(index.getEntryIndex().hasClass(fullClassEntry), is(true));
 
                 // level 3
                 fullClassEntry = new ClassEntry(ClassTreeRoot.getName()
-                        + "$" + ClassTreeLevel1.getInnermostClassName()
-                        + "$" + ClassTreeLevel2.getInnermostClassName()
-                        + "$" + ClassTreeLevel3.getInnermostClassName());
-                assertThat(index.containsObfClass(fullClassEntry), is(true));
-                assertThat(index.getOuterClass(ClassTreeLevel3), is(ClassTreeLevel2));
-                assertThat(index.getInnerClasses(ClassTreeLevel3), is(empty()));
+                        + "$" + ClassTreeLevel1.getSimpleName()
+                        + "$" + ClassTreeLevel2.getSimpleName()
+                        + "$" + ClassTreeLevel3.getSimpleName());
+                assertThat(index.getEntryIndex().hasClass(fullClassEntry), is(true));
         }
 
         private void decompile(ClassEntry classEntry) {
diff --git a/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java b/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java
index 763639a4..c3f3b669 100644
--- a/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java
+++ b/src/test/java/cuchaz/enigma/TestJarIndexConstructorReferences.java
@@ -12,12 +12,11 @@
 package cuchaz.enigma;
 
 import cuchaz.enigma.analysis.EntryReference;
-import cuchaz.enigma.analysis.JarIndex;
 import cuchaz.enigma.analysis.ParsedJar;
-import cuchaz.enigma.mapping.entry.ClassEntry;
-import cuchaz.enigma.mapping.entry.MethodDefEntry;
-import cuchaz.enigma.mapping.entry.MethodEntry;
-import cuchaz.enigma.mapping.entry.ReferencedEntryPool;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.MethodDefEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
 import org.junit.Test;
 
 import java.io.File;
@@ -41,13 +40,13 @@ public class TestJarIndexConstructorReferences {
         public TestJarIndexConstructorReferences()
                         throws Exception {
                 File jarFile = new File("build/test-obf/constructors.jar");
-                index = new JarIndex(new ReferencedEntryPool());
-                index.indexJar(new ParsedJar(new JarFile(jarFile)), false);
+                index = JarIndex.empty();
+                index.indexJar(new ParsedJar(new JarFile(jarFile)), s -> {});
         }
 
         @Test
         public void obfEntries() {
-                assertThat(index.getObfClassEntries(), containsInAnyOrder(newClass("cuchaz/enigma/inputs/Keep"), baseClass,
+                assertThat(index.getEntryIndex().getClasses(), containsInAnyOrder(newClass("cuchaz/enigma/inputs/Keep"), baseClass,
                                 subClass, subsubClass, defaultClass, callerClass));
         }
 
@@ -55,7 +54,7 @@ public class TestJarIndexConstructorReferences {
         @SuppressWarnings("unchecked")
         public void baseDefault() {
                 MethodEntry source = newMethod(baseClass, "<init>", "()V");
-                Collection<EntryReference<MethodEntry, MethodDefEntry>> references = index.getMethodsReferencing(source);
+                Collection<EntryReference<MethodEntry, MethodDefEntry>> references = index.getReferenceIndex().getReferencesToMethod(source);
                 assertThat(references, containsInAnyOrder(
                                 newBehaviorReferenceByMethod(source, callerClass.getName(), "a", "()V"),
                                 newBehaviorReferenceByMethod(source, subClass.getName(), "<init>", "()V"),
@@ -67,7 +66,7 @@ public class TestJarIndexConstructorReferences {
         @SuppressWarnings("unchecked")
         public void baseInt() {
                 MethodEntry source = newMethod(baseClass, "<init>", "(I)V");
-                assertThat(index.getMethodsReferencing(source), containsInAnyOrder(
+                assertThat(index.getReferenceIndex().getReferencesToMethod(source), containsInAnyOrder(
                                 newBehaviorReferenceByMethod(source, callerClass.getName(), "b", "()V")
                 ));
         }
@@ -76,7 +75,7 @@ public class TestJarIndexConstructorReferences {
         @SuppressWarnings("unchecked")
         public void subDefault() {
                 MethodEntry source = newMethod(subClass, "<init>", "()V");
-                assertThat(index.getMethodsReferencing(source), containsInAnyOrder(
+                assertThat(index.getReferenceIndex().getReferencesToMethod(source), containsInAnyOrder(
                                 newBehaviorReferenceByMethod(source, callerClass.getName(), "c", "()V"),
                                 newBehaviorReferenceByMethod(source, subClass.getName(), "<init>", "(I)V")
                 ));
@@ -86,7 +85,7 @@ public class TestJarIndexConstructorReferences {
         @SuppressWarnings("unchecked")
         public void subInt() {
                 MethodEntry source = newMethod(subClass, "<init>", "(I)V");
-                assertThat(index.getMethodsReferencing(source), containsInAnyOrder(
+                assertThat(index.getReferenceIndex().getReferencesToMethod(source), containsInAnyOrder(
                                 newBehaviorReferenceByMethod(source, callerClass.getName(), "d", "()V"),
                                 newBehaviorReferenceByMethod(source, subClass.getName(), "<init>", "(II)V"),
                                 newBehaviorReferenceByMethod(source, subsubClass.getName(), "<init>", "(I)V")
@@ -97,7 +96,7 @@ public class TestJarIndexConstructorReferences {
         @SuppressWarnings("unchecked")
         public void subIntInt() {
                 MethodEntry source = newMethod(subClass, "<init>", "(II)V");
-                assertThat(index.getMethodsReferencing(source), containsInAnyOrder(
+                assertThat(index.getReferenceIndex().getReferencesToMethod(source), containsInAnyOrder(
                                 newBehaviorReferenceByMethod(source, callerClass.getName(), "e", "()V")
                 ));
         }
@@ -105,14 +104,14 @@ public class TestJarIndexConstructorReferences {
         @Test
         public void subIntIntInt() {
                 MethodEntry source = newMethod(subClass, "<init>", "(III)V");
-                assertThat(index.getMethodsReferencing(source), is(empty()));
+                assertThat(index.getReferenceIndex().getReferencesToMethod(source), is(empty()));
         }
 
         @Test
         @SuppressWarnings("unchecked")
         public void subsubInt() {
                 MethodEntry source = newMethod(subsubClass, "<init>", "(I)V");
-                assertThat(index.getMethodsReferencing(source), containsInAnyOrder(
+                assertThat(index.getReferenceIndex().getReferencesToMethod(source), containsInAnyOrder(
                                 newBehaviorReferenceByMethod(source, callerClass.getName(), "f", "()V")
                 ));
         }
@@ -121,7 +120,7 @@ public class TestJarIndexConstructorReferences {
         @SuppressWarnings("unchecked")
         public void defaultConstructable() {
                 MethodEntry source = newMethod(defaultClass, "<init>", "()V");
-                assertThat(index.getMethodsReferencing(source), containsInAnyOrder(
+                assertThat(index.getReferenceIndex().getReferencesToMethod(source), containsInAnyOrder(
                                 newBehaviorReferenceByMethod(source, callerClass.getName(), "g", "()V")
                 ));
         }
diff --git a/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java b/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java
index 23df1a99..36595a3b 100644
--- a/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java
+++ b/src/test/java/cuchaz/enigma/TestJarIndexInheritanceTree.java
@@ -11,12 +11,22 @@
 
 package cuchaz.enigma;
 
-import cuchaz.enigma.analysis.*;
-import cuchaz.enigma.mapping.entry.*;
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.analysis.ParsedJar;
+import cuchaz.enigma.analysis.index.EntryIndex;
+import cuchaz.enigma.analysis.index.InheritanceIndex;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.translation.mapping.EntryResolver;
+import cuchaz.enigma.translation.mapping.IndexEntryResolver;
+import cuchaz.enigma.translation.representation.AccessFlags;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.FieldEntry;
+import cuchaz.enigma.translation.representation.entry.MethodDefEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
 import org.junit.Test;
+import org.objectweb.asm.Opcodes;
 
 import java.util.Collection;
-import java.util.Set;
 import java.util.jar.JarFile;
 
 import static cuchaz.enigma.TestEntryFactory.*;
@@ -27,7 +37,6 @@ public class TestJarIndexInheritanceTree {
 
         private JarIndex index;
 
-        private ClassEntry objectClass = newClass("java/lang/Object");
         private ClassEntry baseClass = newClass("a");
         private ClassEntry subClassA = newClass("b");
         private ClassEntry subClassAA = newClass("d");
@@ -37,13 +46,13 @@ public class TestJarIndexInheritanceTree {
 
         public TestJarIndexInheritanceTree()
                         throws Exception {
-                index = new JarIndex(new ReferencedEntryPool());
-                index.indexJar(new ParsedJar(new JarFile("build/test-obf/inheritanceTree.jar")), false);
+                index = JarIndex.empty();
+                index.indexJar(new ParsedJar(new JarFile("build/test-obf/inheritanceTree.jar")), s -> {});
         }
 
         @Test
         public void obfEntries() {
-                assertThat(index.getObfClassEntries(), containsInAnyOrder(
+                assertThat(index.getEntryIndex().getClasses(), containsInAnyOrder(
                                 newClass("cuchaz/enigma/inputs/Keep"), baseClass, subClassA, subClassAA, subClassB
                 ));
         }
@@ -51,67 +60,68 @@ public class TestJarIndexInheritanceTree {
         @Test
         public void translationIndex() {
 
-                TranslationIndex index = this.index.getTranslationIndex();
+                InheritanceIndex index = this.index.getInheritanceIndex();
 
                 // base class
-                assertThat(index.getSuperclass(baseClass), is(objectClass));
-                assertThat(index.getAncestry(baseClass), contains(objectClass));
-                assertThat(index.getSubclass(baseClass), containsInAnyOrder(subClassA, subClassB
+                assertThat(index.getParents(baseClass), is(empty()));
+                assertThat(index.getAncestors(baseClass), is(empty()));
+                assertThat(index.getChildren(baseClass), containsInAnyOrder(subClassA, subClassB
                 ));
 
                 // subclass a
-                assertThat(index.getSuperclass(subClassA), is(baseClass));
-                assertThat(index.getAncestry(subClassA), contains(baseClass, objectClass));
-                assertThat(index.getSubclass(subClassA), contains(subClassAA));
+                assertThat(index.getParents(subClassA), contains(baseClass));
+                assertThat(index.getAncestors(subClassA), containsInAnyOrder(baseClass));
+                assertThat(index.getChildren(subClassA), contains(subClassAA));
 
                 // subclass aa
-                assertThat(index.getSuperclass(subClassAA), is(subClassA));
-                assertThat(index.getAncestry(subClassAA), contains(subClassA, baseClass, objectClass));
-                assertThat(index.getSubclass(subClassAA), is(empty()));
+                assertThat(index.getParents(subClassAA), contains(subClassA));
+                assertThat(index.getAncestors(subClassAA), containsInAnyOrder(subClassA, baseClass));
+                assertThat(index.getChildren(subClassAA), is(empty()));
 
                 // subclass b
-                assertThat(index.getSuperclass(subClassB), is(baseClass));
-                assertThat(index.getAncestry(subClassB), contains(baseClass, objectClass));
-                assertThat(index.getSubclass(subClassB), is(empty()));
+                assertThat(index.getParents(subClassB), contains(baseClass));
+                assertThat(index.getAncestors(subClassB), containsInAnyOrder(baseClass));
+                assertThat(index.getChildren(subClassB), is(empty()));
         }
 
         @Test
         public void access() {
-                assertThat(index.getAccess(nameField), is(Access.PRIVATE));
-                assertThat(index.getAccess(numThingsField), is(Access.PRIVATE));
+                assertThat(index.getEntryIndex().getFieldAccess(nameField), is(new AccessFlags(Opcodes.ACC_PRIVATE)));
+                assertThat(index.getEntryIndex().getFieldAccess(numThingsField), is(new AccessFlags(Opcodes.ACC_PRIVATE)));
         }
 
         @Test
         public void relatedMethodImplementations() {
 
-                Set<MethodEntry> entries;
+                Collection<MethodEntry> entries;
 
+                EntryResolver resolver = new IndexEntryResolver(index);
                 // getName()
-                entries = index.getRelatedMethodImplementations(newMethod(baseClass, "a", "()Ljava/lang/String;"));
+                entries = resolver.resolveEquivalentMethods(newMethod(baseClass, "a", "()Ljava/lang/String;"));
                 assertThat(entries, containsInAnyOrder(
                                 newMethod(baseClass, "a", "()Ljava/lang/String;"),
                                 newMethod(subClassAA, "a", "()Ljava/lang/String;")
                 ));
-                entries = index.getRelatedMethodImplementations(newMethod(subClassAA, "a", "()Ljava/lang/String;"));
+                entries = resolver.resolveEquivalentMethods(newMethod(subClassAA, "a", "()Ljava/lang/String;"));
                 assertThat(entries, containsInAnyOrder(
                                 newMethod(baseClass, "a", "()Ljava/lang/String;"),
                                 newMethod(subClassAA, "a", "()Ljava/lang/String;")
                 ));
 
                 // doBaseThings()
-                entries = index.getRelatedMethodImplementations(newMethod(baseClass, "a", "()V"));
+                entries = resolver.resolveEquivalentMethods(newMethod(baseClass, "a", "()V"));
                 assertThat(entries, containsInAnyOrder(
                                 newMethod(baseClass, "a", "()V"),
                                 newMethod(subClassAA, "a", "()V"),
                                 newMethod(subClassB, "a", "()V")
                 ));
-                entries = index.getRelatedMethodImplementations(newMethod(subClassAA, "a", "()V"));
+                entries = resolver.resolveEquivalentMethods(newMethod(subClassAA, "a", "()V"));
                 assertThat(entries, containsInAnyOrder(
                                 newMethod(baseClass, "a", "()V"),
                                 newMethod(subClassAA, "a", "()V"),
                                 newMethod(subClassB, "a", "()V")
                 ));
-                entries = index.getRelatedMethodImplementations(newMethod(subClassB, "a", "()V"));
+                entries = resolver.resolveEquivalentMethods(newMethod(subClassB, "a", "()V"));
                 assertThat(entries, containsInAnyOrder(
                                 newMethod(baseClass, "a", "()V"),
                                 newMethod(subClassAA, "a", "()V"),
@@ -119,7 +129,7 @@ public class TestJarIndexInheritanceTree {
                 ));
 
                 // doBThings
-                entries = index.getRelatedMethodImplementations(newMethod(subClassB, "b", "()V"));
+                entries = resolver.resolveEquivalentMethods(newMethod(subClassB, "b", "()V"));
                 assertThat(entries, containsInAnyOrder(newMethod(subClassB, "b", "()V")));
         }
 
@@ -129,14 +139,14 @@ public class TestJarIndexInheritanceTree {
                 Collection<EntryReference<FieldEntry, MethodDefEntry>> references;
 
                 // name
-                references = index.getFieldReferences(nameField);
+                references = index.getReferenceIndex().getReferencesToField(nameField);
                 assertThat(references, containsInAnyOrder(
                                 newFieldReferenceByMethod(nameField, baseClass.getName(), "<init>", "(Ljava/lang/String;)V"),
                                 newFieldReferenceByMethod(nameField, baseClass.getName(), "a", "()Ljava/lang/String;")
                 ));
 
                 // numThings
-                references = index.getFieldReferences(numThingsField);
+                references = index.getReferenceIndex().getReferencesToField(numThingsField);
                 assertThat(references, containsInAnyOrder(
                                 newFieldReferenceByMethod(numThingsField, subClassB.getName(), "<init>", "()V"),
                                 newFieldReferenceByMethod(numThingsField, subClassB.getName(), "b", "()V")
@@ -152,7 +162,7 @@ public class TestJarIndexInheritanceTree {
 
                 // baseClass constructor
                 source = newMethod(baseClass, "<init>", "(Ljava/lang/String;)V");
-                references = index.getMethodsReferencing(source);
+                references = index.getReferenceIndex().getReferencesToMethod(source);
                 assertThat(references, containsInAnyOrder(
                                 newBehaviorReferenceByMethod(source, subClassA.getName(), "<init>", "(Ljava/lang/String;)V"),
                                 newBehaviorReferenceByMethod(source, subClassB.getName(), "<init>", "()V")
@@ -160,14 +170,14 @@ public class TestJarIndexInheritanceTree {
 
                 // subClassA constructor
                 source = newMethod(subClassA, "<init>", "(Ljava/lang/String;)V");
-                references = index.getMethodsReferencing(source);
+                references = index.getReferenceIndex().getReferencesToMethod(source);
                 assertThat(references, containsInAnyOrder(
                                 newBehaviorReferenceByMethod(source, subClassAA.getName(), "<init>", "()V")
                 ));
 
                 // baseClass.getName()
                 source = newMethod(baseClass, "a", "()Ljava/lang/String;");
-                references = index.getMethodsReferencing(source);
+                references = index.getReferenceIndex().getReferencesToMethod(source);
                 assertThat(references, containsInAnyOrder(
                                 newBehaviorReferenceByMethod(source, subClassAA.getName(), "a", "()Ljava/lang/String;"),
                                 newBehaviorReferenceByMethod(source, subClassB.getName(), "a", "()V")
@@ -175,7 +185,7 @@ public class TestJarIndexInheritanceTree {
 
                 // subclassAA.getName()
                 source = newMethod(subClassAA, "a", "()Ljava/lang/String;");
-                references = index.getMethodsReferencing(source);
+                references = index.getReferenceIndex().getReferencesToMethod(source);
                 assertThat(references, containsInAnyOrder(
                                 newBehaviorReferenceByMethod(source, subClassAA.getName(), "a", "()V")
                 ));
@@ -183,35 +193,35 @@ public class TestJarIndexInheritanceTree {
 
         @Test
         public void containsEntries() {
-
+                EntryIndex entryIndex = index.getEntryIndex();
                 // classes
-                assertThat(index.containsObfClass(baseClass), is(true));
-                assertThat(index.containsObfClass(subClassA), is(true));
-                assertThat(index.containsObfClass(subClassAA), is(true));
-                assertThat(index.containsObfClass(subClassB), is(true));
+                assertThat(entryIndex.hasClass(baseClass), is(true));
+                assertThat(entryIndex.hasClass(subClassA), is(true));
+                assertThat(entryIndex.hasClass(subClassAA), is(true));
+                assertThat(entryIndex.hasClass(subClassB), is(true));
 
                 // fields
-                assertThat(index.containsObfField(nameField), is(true));
-                assertThat(index.containsObfField(numThingsField), is(true));
+                assertThat(entryIndex.hasField(nameField), is(true));
+                assertThat(entryIndex.hasField(numThingsField), is(true));
 
                 // methods
                 // getName()
-                assertThat(index.containsObfMethod(newMethod(baseClass, "a", "()Ljava/lang/String;")), is(true));
-                assertThat(index.containsObfMethod(newMethod(subClassA, "a", "()Ljava/lang/String;")), is(false));
-                assertThat(index.containsObfMethod(newMethod(subClassAA, "a", "()Ljava/lang/String;")), is(true));
-                assertThat(index.containsObfMethod(newMethod(subClassB, "a", "()Ljava/lang/String;")), is(false));
+                assertThat(entryIndex.hasMethod(newMethod(baseClass, "a", "()Ljava/lang/String;")), is(true));
+                assertThat(entryIndex.hasMethod(newMethod(subClassA, "a", "()Ljava/lang/String;")), is(false));
+                assertThat(entryIndex.hasMethod(newMethod(subClassAA, "a", "()Ljava/lang/String;")), is(true));
+                assertThat(entryIndex.hasMethod(newMethod(subClassB, "a", "()Ljava/lang/String;")), is(false));
 
                 // doBaseThings()
-                assertThat(index.containsObfMethod(newMethod(baseClass, "a", "()V")), is(true));
-                assertThat(index.containsObfMethod(newMethod(subClassA, "a", "()V")), is(false));
-                assertThat(index.containsObfMethod(newMethod(subClassAA, "a", "()V")), is(true));
-                assertThat(index.containsObfMethod(newMethod(subClassB, "a", "()V")), is(true));
+                assertThat(entryIndex.hasMethod(newMethod(baseClass, "a", "()V")), is(true));
+                assertThat(entryIndex.hasMethod(newMethod(subClassA, "a", "()V")), is(false));
+                assertThat(entryIndex.hasMethod(newMethod(subClassAA, "a", "()V")), is(true));
+                assertThat(entryIndex.hasMethod(newMethod(subClassB, "a", "()V")), is(true));
 
                 // doBThings()
-                assertThat(index.containsObfMethod(newMethod(baseClass, "b", "()V")), is(false));
-                assertThat(index.containsObfMethod(newMethod(subClassA, "b", "()V")), is(false));
-                assertThat(index.containsObfMethod(newMethod(subClassAA, "b", "()V")), is(false));
-                assertThat(index.containsObfMethod(newMethod(subClassB, "b", "()V")), is(true));
+                assertThat(entryIndex.hasMethod(newMethod(baseClass, "b", "()V")), is(false));
+                assertThat(entryIndex.hasMethod(newMethod(subClassA, "b", "()V")), is(false));
+                assertThat(entryIndex.hasMethod(newMethod(subClassAA, "b", "()V")), is(false));
+                assertThat(entryIndex.hasMethod(newMethod(subClassB, "b", "()V")), is(true));
 
         }
 }
diff --git a/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java b/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java
index b4529ddc..1299bccc 100644
--- a/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java
+++ b/src/test/java/cuchaz/enigma/TestJarIndexLoneClass.java
@@ -12,12 +12,19 @@
 package cuchaz.enigma;
 
 import cuchaz.enigma.analysis.*;
-import cuchaz.enigma.mapping.*;
-import cuchaz.enigma.mapping.entry.*;
+import cuchaz.enigma.analysis.index.EntryIndex;
+import cuchaz.enigma.analysis.index.InheritanceIndex;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.translation.VoidTranslator;
+import cuchaz.enigma.translation.representation.AccessFlags;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.FieldEntry;
+import cuchaz.enigma.translation.representation.entry.MethodDefEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
 import org.junit.Test;
 
 import java.util.Collection;
-import java.util.Set;
+import java.util.List;
 import java.util.jar.JarFile;
 
 import static cuchaz.enigma.TestEntryFactory.*;
@@ -30,13 +37,13 @@ public class TestJarIndexLoneClass {
 
         public TestJarIndexLoneClass()
                         throws Exception {
-                index = new JarIndex(new ReferencedEntryPool());
-                index.indexJar(new ParsedJar(new JarFile("build/test-obf/loneClass.jar")), false);
+                index = JarIndex.empty();
+                index.indexJar(new ParsedJar(new JarFile("build/test-obf/loneClass.jar")), s -> {});
         }
 
         @Test
         public void obfEntries() {
-                assertThat(index.getObfClassEntries(), containsInAnyOrder(
+                assertThat(index.getEntryIndex().getClasses(), containsInAnyOrder(
                                 newClass("cuchaz/enigma/inputs/Keep"),
                                 newClass("a")
                 ));
@@ -44,25 +51,28 @@ public class TestJarIndexLoneClass {
 
         @Test
         public void translationIndex() {
-                assertThat(index.getTranslationIndex().getSuperclass(new ClassEntry("a")), is(new ClassEntry("java/lang/Object")));
-                assertThat(index.getTranslationIndex().getSuperclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(new ClassEntry("java/lang/Object")));
-                assertThat(index.getTranslationIndex().getAncestry(new ClassEntry("a")), contains(new ClassEntry("java/lang/Object")));
-                assertThat(index.getTranslationIndex().getAncestry(new ClassEntry("cuchaz/enigma/inputs/Keep")), contains(new ClassEntry("java/lang/Object")));
-                assertThat(index.getTranslationIndex().getSubclass(new ClassEntry("a")), is(empty()));
-                assertThat(index.getTranslationIndex().getSubclass(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty()));
+                InheritanceIndex inheritanceIndex = index.getInheritanceIndex();
+                assertThat(inheritanceIndex.getParents(new ClassEntry("a")), is(empty()));
+                assertThat(inheritanceIndex.getParents(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty()));
+                assertThat(inheritanceIndex.getAncestors(new ClassEntry("a")), is(empty()));
+                assertThat(inheritanceIndex.getAncestors(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty()));
+                assertThat(inheritanceIndex.getChildren(new ClassEntry("a")), is(empty()));
+                assertThat(inheritanceIndex.getChildren(new ClassEntry("cuchaz/enigma/inputs/Keep")), is(empty()));
         }
 
         @Test
         public void access() {
-                assertThat(index.getAccess(newField("a", "a", "Ljava/lang/String;")), is(Access.PRIVATE));
-                assertThat(index.getAccess(newMethod("a", "a", "()Ljava/lang/String;")), is(Access.PUBLIC));
-                assertThat(index.getAccess(newField("a", "b", "Ljava/lang/String;")), is(nullValue()));
-                assertThat(index.getAccess(newField("a", "a", "LFoo;")), is(nullValue()));
+                EntryIndex entryIndex = index.getEntryIndex();
+                assertThat(entryIndex.getFieldAccess(newField("a", "a", "Ljava/lang/String;")), is(AccessFlags.PRIVATE));
+                assertThat(entryIndex.getMethodAccess(newMethod("a", "a", "()Ljava/lang/String;")), is(AccessFlags.PUBLIC));
+                assertThat(entryIndex.getFieldAccess(newField("a", "b", "Ljava/lang/String;")), is(nullValue()));
+                assertThat(entryIndex.getFieldAccess(newField("a", "a", "LFoo;")), is(nullValue()));
         }
 
         @Test
         public void classInheritance() {
-                ClassInheritanceTreeNode node = index.getClassInheritance(new DirectionalTranslator(new ReferencedEntryPool()), newClass("a"));
+                IndexTreeBuilder treeBuilder = new IndexTreeBuilder(index);
+                ClassInheritanceTreeNode node = treeBuilder.buildClassInheritance(VoidTranslator.INSTANCE, newClass("a"));
                 assertThat(node, is(not(nullValue())));
                 assertThat(node.getObfClassName(), is("a"));
                 assertThat(node.getChildCount(), is(0));
@@ -70,8 +80,9 @@ public class TestJarIndexLoneClass {
 
         @Test
         public void methodInheritance() {
+                IndexTreeBuilder treeBuilder = new IndexTreeBuilder(index);
                 MethodEntry source = newMethod("a", "a", "()Ljava/lang/String;");
-                MethodInheritanceTreeNode node = index.getMethodInheritance(new DirectionalTranslator(new ReferencedEntryPool()), source);
+                MethodInheritanceTreeNode node = treeBuilder.buildMethodInheritance(VoidTranslator.INSTANCE, source);
                 assertThat(node, is(not(nullValue())));
                 assertThat(node.getMethodEntry(), is(source));
                 assertThat(node.getChildCount(), is(0));
@@ -79,19 +90,24 @@ public class TestJarIndexLoneClass {
 
         @Test
         public void classImplementations() {
-                ClassImplementationsTreeNode node = index.getClassImplementations(new DirectionalTranslator(new ReferencedEntryPool()), newClass("a"));
+                IndexTreeBuilder treeBuilder = new IndexTreeBuilder(index);
+                ClassImplementationsTreeNode node = treeBuilder.buildClassImplementations(VoidTranslator.INSTANCE, newClass("a"));
                 assertThat(node, is(nullValue()));
         }
 
         @Test
         public void methodImplementations() {
+                IndexTreeBuilder treeBuilder = new IndexTreeBuilder(index);
                 MethodEntry source = newMethod("a", "a", "()Ljava/lang/String;");
-                assertThat(index.getMethodImplementations(new DirectionalTranslator(new ReferencedEntryPool()), source), is(empty()));
+
+                List<MethodImplementationsTreeNode> nodes = treeBuilder.buildMethodImplementations(VoidTranslator.INSTANCE, source);
+                assertThat(nodes, hasSize(1));
+                assertThat(nodes.get(0).getMethodEntry(), is(source));
         }
 
         @Test
         public void relatedMethodImplementations() {
-                Set<MethodEntry> entries = index.getRelatedMethodImplementations(newMethod("a", "a", "()Ljava/lang/String;"));
+                Collection<MethodEntry> entries = index.getEntryResolver().resolveEquivalentMethods(newMethod("a", "a", "()Ljava/lang/String;"));
                 assertThat(entries, containsInAnyOrder(
                                 newMethod("a", "a", "()Ljava/lang/String;")
                 ));
@@ -101,7 +117,7 @@ public class TestJarIndexLoneClass {
         @SuppressWarnings("unchecked")
         public void fieldReferences() {
                 FieldEntry source = newField("a", "a", "Ljava/lang/String;");
-                Collection<EntryReference<FieldEntry, MethodDefEntry>> references = index.getFieldReferences(source);
+                Collection<EntryReference<FieldEntry, MethodDefEntry>> references = index.getReferenceIndex().getReferencesToField(source);
                 assertThat(references, containsInAnyOrder(
                                 newFieldReferenceByMethod(source, "a", "<init>", "(Ljava/lang/String;)V"),
                                 newFieldReferenceByMethod(source, "a", "a", "()Ljava/lang/String;")
@@ -110,42 +126,33 @@ public class TestJarIndexLoneClass {
 
         @Test
         public void behaviorReferences() {
-                assertThat(index.getMethodsReferencing(newMethod("a", "a", "()Ljava/lang/String;")), is(empty()));
-        }
-
-        @Test
-        public void innerClasses() {
-                assertThat(index.getInnerClasses(newClass("a")), is(empty()));
-        }
-
-        @Test
-        public void outerClass() {
-                assertThat(index.getOuterClass(newClass("a")), is(nullValue()));
+                assertThat(index.getReferenceIndex().getReferencesToMethod(newMethod("a", "a", "()Ljava/lang/String;")), is(empty()));
         }
 
         @Test
         public void interfaces() {
-                assertThat(index.getInterfaces("a"), is(empty()));
+                assertThat(index.getInheritanceIndex().getParents(new ClassEntry("a")), is(empty()));
         }
 
         @Test
         public void implementingClasses() {
-                assertThat(index.getImplementingClasses("a"), is(empty()));
+                assertThat(index.getInheritanceIndex().getChildren(new ClassEntry("a")), is(empty()));
         }
 
         @Test
         public void isInterface() {
-                assertThat(index.isInterface("a"), is(false));
+                assertThat(index.getInheritanceIndex().isParent(new ClassEntry("a")), is(false));
         }
 
         @Test
         public void testContains() {
-                assertThat(index.containsObfClass(newClass("a")), is(true));
-                assertThat(index.containsObfClass(newClass("b")), is(false));
-                assertThat(index.containsObfField(newField("a", "a", "Ljava/lang/String;")), is(true));
-                assertThat(index.containsObfField(newField("a", "b", "Ljava/lang/String;")), is(false));
-                assertThat(index.containsObfField(newField("a", "a", "LFoo;")), is(false));
-                assertThat(index.containsObfMethod(newMethod("a", "a", "()Ljava/lang/String;")), is(true));
-                assertThat(index.containsObfMethod(newMethod("a", "b", "()Ljava/lang/String;")), is(false));
+                EntryIndex entryIndex = index.getEntryIndex();
+                assertThat(entryIndex.hasClass(newClass("a")), is(true));
+                assertThat(entryIndex.hasClass(newClass("b")), is(false));
+                assertThat(entryIndex.hasField(newField("a", "a", "Ljava/lang/String;")), is(true));
+                assertThat(entryIndex.hasField(newField("a", "b", "Ljava/lang/String;")), is(false));
+                assertThat(entryIndex.hasField(newField("a", "a", "LFoo;")), is(false));
+                assertThat(entryIndex.hasMethod(newMethod("a", "a", "()Ljava/lang/String;")), is(true));
+                assertThat(entryIndex.hasMethod(newMethod("a", "b", "()Ljava/lang/String;")), is(false));
         }
 }
diff --git a/src/test/java/cuchaz/enigma/TestMethodDescriptor.java b/src/test/java/cuchaz/enigma/TestMethodDescriptor.java
index 48c46e52..a73880dd 100644
--- a/src/test/java/cuchaz/enigma/TestMethodDescriptor.java
+++ b/src/test/java/cuchaz/enigma/TestMethodDescriptor.java
@@ -11,8 +11,8 @@
 
 package cuchaz.enigma;
 
-import cuchaz.enigma.mapping.MethodDescriptor;
-import cuchaz.enigma.mapping.TypeDescriptor;
+import cuchaz.enigma.translation.representation.MethodDescriptor;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
 import org.junit.Test;
 
 import static org.hamcrest.MatcherAssert.assertThat;
diff --git a/src/test/java/cuchaz/enigma/TestSourceIndex.java b/src/test/java/cuchaz/enigma/TestSourceIndex.java
index 07542753..a5f5f712 100644
--- a/src/test/java/cuchaz/enigma/TestSourceIndex.java
+++ b/src/test/java/cuchaz/enigma/TestSourceIndex.java
@@ -13,7 +13,7 @@ package cuchaz.enigma;
 
 import com.google.common.collect.Sets;
 import com.strobel.decompiler.languages.java.ast.CompilationUnit;
-import cuchaz.enigma.mapping.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
 import org.junit.Test;
 
 import java.io.File;
@@ -44,7 +44,7 @@ public class TestSourceIndex {
 
                 // get all classes that aren't inner classes
                 Set<ClassEntry> classEntries = Sets.newHashSet();
-                for (ClassEntry obfClassEntry : deobfuscator.getJarIndex().getObfClassEntries()) {
+                for (ClassEntry obfClassEntry : deobfuscator.getJarIndex().getEntryIndex().getClasses()) {
                         if (!obfClassEntry.isInnerClass()) {
                                 classEntries.add(obfClassEntry);
                         }
diff --git a/src/test/java/cuchaz/enigma/TestTokensConstructors.java b/src/test/java/cuchaz/enigma/TestTokensConstructors.java
index 0e98da7f..1ee0bde1 100644
--- a/src/test/java/cuchaz/enigma/TestTokensConstructors.java
+++ b/src/test/java/cuchaz/enigma/TestTokensConstructors.java
@@ -11,7 +11,7 @@
 
 package cuchaz.enigma;
 
-import cuchaz.enigma.mapping.entry.MethodEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
 import org.junit.Test;
 
 import java.util.jar.JarFile;
diff --git a/src/test/java/cuchaz/enigma/TestTranslator.java b/src/test/java/cuchaz/enigma/TestTranslator.java
index 9b6eb916..b9781297 100644
--- a/src/test/java/cuchaz/enigma/TestTranslator.java
+++ b/src/test/java/cuchaz/enigma/TestTranslator.java
@@ -11,23 +11,14 @@
 
 package cuchaz.enigma;
 
-import cuchaz.enigma.mapping.entry.Entry;
-import cuchaz.enigma.mapping.Mappings;
-import cuchaz.enigma.mapping.Translator;
+import cuchaz.enigma.translation.representation.entry.Entry;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
-import static cuchaz.enigma.TestEntryFactory.newClass;
-import static cuchaz.enigma.TestEntryFactory.newField;
-import static cuchaz.enigma.TestEntryFactory.newMethod;
+import static cuchaz.enigma.TestEntryFactory.*;
 
 public class TestTranslator {
 
-        private static Deobfuscator deobfuscator;
-        private static Mappings mappings;
-        private static Translator deobfTranslator;
-        private static Translator obfTranslator;
-
         @BeforeClass
         public static void beforeClass()
                 throws Exception {
@@ -147,7 +138,7 @@ public class TestTranslator {
                 assertMapping(newMethod("i$b", "a", "()Ljava/lang/Object;"), newMethod("deobf/I_Generics$B_Generic", "m1", "()Ljava/lang/Object;"));
         }
 
-        private void assertMapping(Entry obf, Entry deobf) {
+        private void assertMapping(Entry<?> obf, Entry<?> deobf) {
                 //assertThat(deobfTranslator.translateEntry(obf), is(deobf));
                 //assertThat(obfTranslator.translateEntry(deobf), is(obf));
 
diff --git a/src/test/java/cuchaz/enigma/TestTypeDescriptor.java b/src/test/java/cuchaz/enigma/TestTypeDescriptor.java
index 8172848c..b9ebe559 100644
--- a/src/test/java/cuchaz/enigma/TestTypeDescriptor.java
+++ b/src/test/java/cuchaz/enigma/TestTypeDescriptor.java
@@ -11,7 +11,7 @@
 
 package cuchaz.enigma;
 
-import cuchaz.enigma.mapping.TypeDescriptor;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
 import org.junit.Test;
 
 import static cuchaz.enigma.TestEntryFactory.newClass;
diff --git a/src/test/java/cuchaz/enigma/TokenChecker.java b/src/test/java/cuchaz/enigma/TokenChecker.java
index d863a5ae..aac28662 100644
--- a/src/test/java/cuchaz/enigma/TokenChecker.java
+++ b/src/test/java/cuchaz/enigma/TokenChecker.java
@@ -16,7 +16,7 @@ import com.strobel.decompiler.languages.java.ast.CompilationUnit;
 import cuchaz.enigma.analysis.EntryReference;
 import cuchaz.enigma.analysis.SourceIndex;
 import cuchaz.enigma.analysis.Token;
-import cuchaz.enigma.mapping.entry.Entry;
+import cuchaz.enigma.translation.representation.entry.Entry;
 
 import java.io.IOException;
 import java.util.Collection;
@@ -32,9 +32,9 @@ public class TokenChecker {
                 deobfuscator = new Deobfuscator(jarFile);
         }
 
-        protected String getDeclarationToken(Entry entry) {
+        protected String getDeclarationToken(Entry<?> entry) {
                 // decompile the class
-                CompilationUnit tree = deobfuscator.getSourceTree(entry.getClassName());
+                CompilationUnit tree = deobfuscator.getSourceTree(entry.getContainingClass().getFullName());
                 // DEBUG
                 // tree.acceptVisitor( new TreeDumpVisitor( new File( "tree." + entry.getClassName().replace( '/', '.' ) + ".txt" ) ), null );
                 String source = deobfuscator.getSource(tree);
@@ -49,15 +49,15 @@ public class TokenChecker {
         }
 
         @SuppressWarnings("unchecked")
-        protected Collection<String> getReferenceTokens(EntryReference<? extends Entry, ? extends Entry> reference) {
+        protected Collection<String> getReferenceTokens(EntryReference<? extends Entry<?>, ? extends Entry<?>> reference) {
                 // decompile the class
-                CompilationUnit tree = deobfuscator.getSourceTree(reference.context.getClassName());
+                CompilationUnit tree = deobfuscator.getSourceTree(reference.context.getContainingClass().getFullName());
                 String source = deobfuscator.getSource(tree);
                 SourceIndex index = deobfuscator.getSourceIndex(tree, source);
 
                 // get the token values
                 List<String> values = Lists.newArrayList();
-                for (Token token : index.getReferenceTokens((EntryReference<Entry, Entry>) reference)) {
+                for (Token token : index.getReferenceTokens((EntryReference<Entry<?>, Entry<?>>) reference)) {
                         values.add(source.substring(token.start, token.end));
                 }
                 return values;