[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

1 files changed, 20 insertions, 19 deletions

diff --git a/src/main/java/cuchaz/enigma/analysis/FieldReferenceTreeNode.java b/src/main/java/cuchaz/enigma/analysis/FieldReferenceTreeNode.java
index 2318a2b..4beab7f 100644
--- a/src/main/java/cuchaz/enigma/analysis/FieldReferenceTreeNode.java
+++ b/src/main/java/cuchaz/enigma/analysis/FieldReferenceTreeNode.java
@@ -11,32 +11,31 @@
 
 package cuchaz.enigma.analysis;
 
-import cuchaz.enigma.bytecode.AccessFlags;
-import cuchaz.enigma.mapping.*;
-import cuchaz.enigma.mapping.entry.FieldEntry;
-import cuchaz.enigma.mapping.entry.MethodDefEntry;
-import cuchaz.enigma.mapping.entry.MethodEntry;
+import cuchaz.enigma.analysis.index.JarIndex;
+import cuchaz.enigma.analysis.index.ReferenceIndex;
+import cuchaz.enigma.translation.Translator;
+import cuchaz.enigma.translation.representation.entry.FieldEntry;
+import cuchaz.enigma.translation.representation.entry.MethodDefEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
 
 import javax.swing.tree.DefaultMutableTreeNode;
 
 public class FieldReferenceTreeNode extends DefaultMutableTreeNode implements ReferenceTreeNode<FieldEntry, MethodDefEntry> {
 
-        private Translator deobfuscatingTranslator;
+        private final Translator translator;
         private FieldEntry entry;
         private EntryReference<FieldEntry, MethodDefEntry> reference;
-        private AccessFlags access;
 
-        public FieldReferenceTreeNode(Translator deobfuscatingTranslator, FieldEntry entry) {
-                this.deobfuscatingTranslator = deobfuscatingTranslator;
+        public FieldReferenceTreeNode(Translator translator, FieldEntry entry) {
+                this.translator = translator;
                 this.entry = entry;
                 this.reference = null;
         }
 
-        private FieldReferenceTreeNode(Translator deobfuscatingTranslator, EntryReference<FieldEntry, MethodDefEntry> reference, AccessFlags access) {
-                this.deobfuscatingTranslator = deobfuscatingTranslator;
+        private FieldReferenceTreeNode(Translator translator, EntryReference<FieldEntry, MethodDefEntry> reference) {
+                this.translator = translator;
                 this.entry = reference.entry;
                 this.reference = reference;
-                this.access = access;
         }
 
         @Override
@@ -52,27 +51,29 @@ public class FieldReferenceTreeNode extends DefaultMutableTreeNode implements Re
         @Override
         public String toString() {
                 if (this.reference != null) {
-                        return String.format("%s (%s)", this.deobfuscatingTranslator.getTranslatedMethodDef(this.reference.context), this.access);
+                        return String.format("%s", translator.translate(this.reference.context));
                 }
-                return deobfuscatingTranslator.getTranslatedField(entry).getName();
+                return translator.translate(entry).toString();
         }
 
         public void load(JarIndex index, boolean recurse) {
+                ReferenceIndex referenceIndex = index.getReferenceIndex();
+
                 // get all the child nodes
                 if (this.reference == null) {
-                        for (EntryReference<FieldEntry, MethodDefEntry> reference : index.getFieldReferences(this.entry)) {
-                                add(new FieldReferenceTreeNode(this.deobfuscatingTranslator, reference, index.getAccessFlags(this.entry)));
+                        for (EntryReference<FieldEntry, MethodDefEntry> reference : referenceIndex.getReferencesToField(this.entry)) {
+                                add(new FieldReferenceTreeNode(translator, reference));
                         }
                 } else {
-                        for (EntryReference<MethodEntry, MethodDefEntry> reference : index.getMethodsReferencing(this.reference.context)) {
-                                add(new MethodReferenceTreeNode(this.deobfuscatingTranslator, reference, index.getAccessFlags(this.reference.context)));
+                        for (EntryReference<MethodEntry, MethodDefEntry> reference : referenceIndex.getReferencesToMethod(this.reference.context)) {
+                                add(new MethodReferenceTreeNode(translator, reference));
                         }
                 }
 
                 if (recurse && children != null) {
                         for (Object node : children) {
                                 if (node instanceof MethodReferenceTreeNode) {
-                                        ((MethodReferenceTreeNode) node).load(index, true);
+                                        ((MethodReferenceTreeNode) node).load(index, true, false);
                                 } else if (node instanceof FieldReferenceTreeNode) {
                                         ((FieldReferenceTreeNode) node).load(index, true);
                                 }