added types to fields

22 files changed, 156 insertions, 157 deletions

diff --git a/src/cuchaz/enigma/Deobfuscator.java b/src/cuchaz/enigma/Deobfuscator.java
index 5f61686..818bfd4 100644
--- a/src/cuchaz/enigma/Deobfuscator.java
+++ b/src/cuchaz/enigma/Deobfuscator.java
@@ -141,7 +141,7 @@ public class Deobfuscator {
                         
                         // fields
                         for (FieldMapping fieldMapping : Lists.newArrayList(classMapping.fields())) {
-                                FieldEntry fieldEntry = new FieldEntry(obfClassEntry, fieldMapping.getObfName());
+                                FieldEntry fieldEntry = new FieldEntry(obfClassEntry, fieldMapping.getObfName(), fieldMapping.getObfType());
                                 ClassEntry resolvedObfClassEntry = m_jarIndex.getTranslationIndex().resolveEntryClass(fieldEntry);
                                 if (resolvedObfClassEntry != null && !resolvedObfClassEntry.equals(fieldEntry.getClassEntry())) {
                                         boolean wasMoved = renamer.moveFieldToObfClass(classMapping, fieldMapping, resolvedObfClassEntry);
@@ -206,7 +206,7 @@ public class Deobfuscator {
                 
                 // check the fields
                 for (FieldMapping fieldMapping : Lists.newArrayList(classMapping.fields())) {
-                        FieldEntry fieldEntry = new FieldEntry(classEntry, fieldMapping.getObfName());
+                        FieldEntry fieldEntry = new FieldEntry(classEntry, fieldMapping.getObfName(), fieldMapping.getObfType());
                         if (!m_jarIndex.containsObfField(fieldEntry)) {
                                 System.err.println("WARNING: unable to find field " + fieldEntry + ". dropping mapping.");
                                 classMapping.removeFieldMapping(fieldMapping);
diff --git a/src/cuchaz/enigma/analysis/EntryRenamer.java b/src/cuchaz/enigma/analysis/EntryRenamer.java
index b54489c..2f27049 100644
--- a/src/cuchaz/enigma/analysis/EntryRenamer.java
+++ b/src/cuchaz/enigma/analysis/EntryRenamer.java
@@ -21,10 +21,13 @@ import com.google.common.collect.Sets;
 
 import cuchaz.enigma.mapping.ArgumentEntry;
 import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ClassNameReplacer;
 import cuchaz.enigma.mapping.ConstructorEntry;
 import cuchaz.enigma.mapping.Entry;
 import cuchaz.enigma.mapping.FieldEntry;
 import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.Signature;
+import cuchaz.enigma.mapping.Type;
 
 public class EntryRenamer {
         
@@ -127,7 +130,7 @@ public class EntryRenamer {
         }
         
         @SuppressWarnings("unchecked")
-        public static <T> T renameClassesInThing(Map<String,String> renames, T thing) {
+        public static <T> T renameClassesInThing(final Map<String,String> renames, T thing) {
                 if (thing instanceof String) {
                         String stringEntry = (String)thing;
                         if (renames.containsKey(stringEntry)) {
@@ -138,19 +141,23 @@ public class EntryRenamer {
                         return (T)new ClassEntry(renameClassesInThing(renames, classEntry.getClassName()));
                 } else if (thing instanceof FieldEntry) {
                         FieldEntry fieldEntry = (FieldEntry)thing;
-                        return (T)new FieldEntry(renameClassesInThing(renames, fieldEntry.getClassEntry()), fieldEntry.getName());
+                        return (T)new FieldEntry(
+                                renameClassesInThing(renames, fieldEntry.getClassEntry()),
+                                fieldEntry.getName(),
+                                renameClassesInThing(renames, fieldEntry.getType())
+                        );
                 } else if (thing instanceof ConstructorEntry) {
                         ConstructorEntry constructorEntry = (ConstructorEntry)thing;
                         return (T)new ConstructorEntry(
                                 renameClassesInThing(renames, constructorEntry.getClassEntry()),
-                                constructorEntry.getSignature()
+                                renameClassesInThing(renames, constructorEntry.getSignature())
                         );
                 } else if (thing instanceof MethodEntry) {
                         MethodEntry methodEntry = (MethodEntry)thing;
                         return (T)new MethodEntry(
                                 renameClassesInThing(renames, methodEntry.getClassEntry()),
                                 methodEntry.getName(),
-                                methodEntry.getSignature()
+                                renameClassesInThing(renames, methodEntry.getSignature())
                         );
                 } else if (thing instanceof ArgumentEntry) {
                         ArgumentEntry argumentEntry = (ArgumentEntry)thing;
@@ -164,6 +171,20 @@ public class EntryRenamer {
                         reference.entry = renameClassesInThing(renames, reference.entry);
                         reference.context = renameClassesInThing(renames, reference.context);
                         return thing;
+                } else if (thing instanceof Signature) {
+                        return (T)new Signature((Signature)thing, new ClassNameReplacer() {
+                                @Override
+                                public String replace(String className) {
+                                        return renameClassesInThing(renames, className);
+                                }
+                        });
+                } else if (thing instanceof Type) {
+                        return (T)new Type((Type)thing, new ClassNameReplacer() {
+                                @Override
+                                public String replace(String className) {
+                                        return renameClassesInThing(renames, className);
+                                }
+                        });
                 }
                 
                 return thing;
diff --git a/src/cuchaz/enigma/analysis/JarIndex.java b/src/cuchaz/enigma/analysis/JarIndex.java
index 3aac8bd..f54beda 100644
--- a/src/cuchaz/enigma/analysis/JarIndex.java
+++ b/src/cuchaz/enigma/analysis/JarIndex.java
@@ -57,7 +57,6 @@ public class JarIndex {
         private TranslationIndex m_translationIndex;
         private Multimap<String,String> m_interfaces;
         private Map<Entry,Access> m_access;
-        private Map<FieldEntry,ClassEntry> m_fieldClasses; // TODO: this will become obsolete!
         private Multimap<String,MethodEntry> m_methodImplementations;
         private Multimap<BehaviorEntry,EntryReference<BehaviorEntry,BehaviorEntry>> m_behaviorReferences;
         private Multimap<FieldEntry,EntryReference<FieldEntry,BehaviorEntry>> m_fieldReferences;
@@ -70,7 +69,6 @@ public class JarIndex {
                 m_translationIndex = new TranslationIndex();
                 m_interfaces = HashMultimap.create();
                 m_access = Maps.newHashMap();
-                m_fieldClasses = Maps.newHashMap();
                 m_methodImplementations = HashMultimap.create();
                 m_behaviorReferences = HashMultimap.create();
                 m_fieldReferences = HashMultimap.create();
@@ -114,9 +112,6 @@ public class JarIndex {
                                 }
                                 m_interfaces.put(className, interfaceName);
                         }
-                        for (CtField field : c.getDeclaredFields()) {
-                                indexField(field);
-                        }
                         for (CtBehavior behavior : c.getDeclaredBehaviors()) {
                                 indexBehavior(behavior);
                         }
@@ -169,18 +164,6 @@ public class JarIndex {
                 }
         }
         
-        private void indexField(CtField field) {
-                // get the field entry
-                String className = Descriptor.toJvmName(field.getDeclaringClass().getName());
-                FieldEntry fieldEntry = new FieldEntry(new ClassEntry(className), field.getName());
-                
-                // is the field a class type?
-                if (field.getSignature().startsWith("L")) {
-                        ClassEntry fieldTypeEntry = new ClassEntry(field.getSignature().substring(1, field.getSignature().length() - 1));
-                        m_fieldClasses.put(fieldEntry, fieldTypeEntry);
-                }
-        }
-        
         private void indexBehavior(CtBehavior behavior) {
                 // get the behavior entry
                 final BehaviorEntry behaviorEntry = BehaviorEntryFactory.create(behavior);
@@ -222,7 +205,7 @@ public class JarIndex {
                                         FieldEntry calledFieldEntry = JavassistUtil.getFieldEntry(call);
                                         ClassEntry resolvedClassEntry = m_translationIndex.resolveEntryClass(calledFieldEntry);
                                         if (resolvedClassEntry != null && !resolvedClassEntry.equals(calledFieldEntry.getClassEntry())) {
-                                                calledFieldEntry = new FieldEntry(resolvedClassEntry, call.getFieldName());
+                                                calledFieldEntry = new FieldEntry(calledFieldEntry, resolvedClassEntry);
                                         }
                                         EntryReference<FieldEntry,BehaviorEntry> reference = new EntryReference<FieldEntry,BehaviorEntry>(
                                                 calledFieldEntry,
@@ -448,8 +431,7 @@ public class JarIndex {
                 // does the caller use this type?
                 BehaviorEntry caller = references.iterator().next().context;
                 for (FieldEntry fieldEntry : getReferencedFields(caller)) {
-                        ClassEntry fieldClass = getFieldClass(fieldEntry);
-                        if (fieldClass != null && fieldClass.equals(innerClassEntry)) {
+                        if (fieldEntry.getType().hasClass() && fieldEntry.getType().getClassEntry().equals(innerClassEntry)) {
                                 // caller references this type, so it can't be anonymous
                                 return null;
                         }
@@ -475,10 +457,6 @@ public class JarIndex {
                 return m_access.get(entry);
         }
         
-        public ClassEntry getFieldClass(FieldEntry fieldEntry) {
-                return m_fieldClasses.get(fieldEntry);
-        }
-        
         public ClassInheritanceTreeNode getClassInheritance(Translator deobfuscatingTranslator, ClassEntry obfClassEntry) {
                 
                 // get the root node
diff --git a/src/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java b/src/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java
index 4155128..f15a724 100644
--- a/src/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java
+++ b/src/cuchaz/enigma/analysis/SourceIndexBehaviorVisitor.java
@@ -36,6 +36,7 @@ import cuchaz.enigma.mapping.ConstructorEntry;
 import cuchaz.enigma.mapping.FieldEntry;
 import cuchaz.enigma.mapping.MethodEntry;
 import cuchaz.enigma.mapping.Signature;
+import cuchaz.enigma.mapping.Type;
 
 public class SourceIndexBehaviorVisitor extends SourceIndexVisitor {
         
@@ -100,7 +101,7 @@ public class SourceIndexBehaviorVisitor extends SourceIndexVisitor {
                         }
                         
                         ClassEntry classEntry = new ClassEntry(ref.getDeclaringType().getInternalName());
-                        FieldEntry fieldEntry = new FieldEntry(classEntry, ref.getName());
+                        FieldEntry fieldEntry = new FieldEntry(classEntry, ref.getName(), new Type(ref.getSignature()));
                         index.addReference(node.getMemberNameToken(), fieldEntry, m_behaviorEntry);
                 }
                 
@@ -140,7 +141,7 @@ public class SourceIndexBehaviorVisitor extends SourceIndexVisitor {
                 MemberReference ref = node.getUserData(Keys.MEMBER_REFERENCE);
                 if (ref != null) {
                         ClassEntry classEntry = new ClassEntry(ref.getDeclaringType().getInternalName());
-                        FieldEntry fieldEntry = new FieldEntry(classEntry, ref.getName());
+                        FieldEntry fieldEntry = new FieldEntry(classEntry, ref.getName(), new Type(ref.getSignature()));
                         index.addReference(node.getIdentifierToken(), fieldEntry, m_behaviorEntry);
                 }
                 
diff --git a/src/cuchaz/enigma/analysis/SourceIndexClassVisitor.java b/src/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
index 7222035..e2ff300 100644
--- a/src/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
+++ b/src/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
@@ -31,6 +31,7 @@ import cuchaz.enigma.mapping.ClassEntry;
 import cuchaz.enigma.mapping.ConstructorEntry;
 import cuchaz.enigma.mapping.FieldEntry;
 import cuchaz.enigma.mapping.Signature;
+import cuchaz.enigma.mapping.Type;
 
 public class SourceIndexClassVisitor extends SourceIndexVisitor {
         
@@ -94,7 +95,7 @@ public class SourceIndexClassVisitor extends SourceIndexVisitor {
         public Void visitFieldDeclaration(FieldDeclaration node, SourceIndex index) {
                 FieldDefinition def = node.getUserData(Keys.FIELD_DEFINITION);
                 ClassEntry classEntry = new ClassEntry(def.getDeclaringType().getInternalName());
-                FieldEntry fieldEntry = new FieldEntry(classEntry, def.getName());
+                FieldEntry fieldEntry = new FieldEntry(classEntry, def.getName(), new Type(def.getSignature()));
                 assert (node.getVariables().size() == 1);
                 VariableInitializer variable = node.getVariables().firstOrNullObject();
                 index.addDeclaration(variable.getNameToken(), fieldEntry);
@@ -107,7 +108,7 @@ public class SourceIndexClassVisitor extends SourceIndexVisitor {
                 // treat enum declarations as field declarations
                 FieldDefinition def = node.getUserData(Keys.FIELD_DEFINITION);
                 ClassEntry classEntry = new ClassEntry(def.getDeclaringType().getInternalName());
-                FieldEntry fieldEntry = new FieldEntry(classEntry, def.getName());
+                FieldEntry fieldEntry = new FieldEntry(classEntry, def.getName(), new Type(def.getSignature()));
                 index.addDeclaration(node.getNameToken(), fieldEntry);
                 
                 return recurse(node, index);
diff --git a/src/cuchaz/enigma/bytecode/ClassTranslator.java b/src/cuchaz/enigma/bytecode/ClassTranslator.java
index afd3a77..4dba0d8 100644
--- a/src/cuchaz/enigma/bytecode/ClassTranslator.java
+++ b/src/cuchaz/enigma/bytecode/ClassTranslator.java
@@ -55,7 +55,8 @@ public class ClassTranslator {
                                         // translate the name
                                         FieldEntry entry = new FieldEntry(
                                                 new ClassEntry(Descriptor.toJvmName(constants.getFieldrefClassName(i))),
-                                                constants.getFieldrefName(i)
+                                                constants.getFieldrefName(i),
+                                                new Type(constants.getFieldrefType(i))
                                         );
                                         FieldEntry translatedEntry = m_translator.translateEntry(entry);
                                         
@@ -94,7 +95,7 @@ public class ClassTranslator {
                 for (CtField field : c.getDeclaredFields()) {
                         
                         // translate the name
-                        FieldEntry entry = new FieldEntry(classEntry, field.getName());
+                        FieldEntry entry = JavassistUtil.getFieldEntry(field);
                         String translatedName = m_translator.translate(entry);
                         if (translatedName != null) {
                                 field.setName(translatedName);
diff --git a/src/cuchaz/enigma/convert/ClassIdentity.java b/src/cuchaz/enigma/convert/ClassIdentity.java
index 1be6123..bb729a3 100644
--- a/src/cuchaz/enigma/convert/ClassIdentity.java
+++ b/src/cuchaz/enigma/convert/ClassIdentity.java
@@ -116,7 +116,7 @@ public class ClassIdentity {
                 m_references = HashMultiset.create();
                 if (useReferences) {
                         for (CtField field : c.getDeclaredFields()) {
-                                FieldEntry fieldEntry = new FieldEntry(m_classEntry, field.getName());
+                                FieldEntry fieldEntry = JavassistUtil.getFieldEntry(field);
                                 for (EntryReference<FieldEntry,BehaviorEntry> reference : index.getFieldReferences(fieldEntry)) {
                                         addReference(reference);
                                 }
diff --git a/src/cuchaz/enigma/gui/Gui.java b/src/cuchaz/enigma/gui/Gui.java
index ca39c42..187ef5b 100644
--- a/src/cuchaz/enigma/gui/Gui.java
+++ b/src/cuchaz/enigma/gui/Gui.java
@@ -874,6 +874,7 @@ public class Gui {
         private void showFieldEntry(FieldEntry entry) {
                 addNameValue(m_infoPanel, "Field", entry.getName());
                 addNameValue(m_infoPanel, "Class", entry.getClassEntry().getName());
+                addNameValue(m_infoPanel, "Type", entry.getType().toString());
         }
         
         private void showMethodEntry(MethodEntry entry) {
diff --git a/src/cuchaz/enigma/mapping/ClassMapping.java b/src/cuchaz/enigma/mapping/ClassMapping.java
index e2c3d56..7133265 100644
--- a/src/cuchaz/enigma/mapping/ClassMapping.java
+++ b/src/cuchaz/enigma/mapping/ClassMapping.java
@@ -152,78 +152,92 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping> {
                 return m_fieldsByObf.values();
         }
         
-        public boolean containsObfField(String obfName) {
-                return m_fieldsByObf.containsKey(obfName);
+        public boolean containsObfField(String obfName, Type obfType) {
+                return m_fieldsByObf.containsKey(getFieldKey(obfName, obfType));
         }
         
-        public boolean containsDeobfField(String deobfName) {
-                return m_fieldsByDeobf.containsKey(deobfName);
+        public boolean containsDeobfField(String deobfName, Type deobfType) {
+                return m_fieldsByDeobf.containsKey(getFieldKey(deobfName, deobfType));
         }
         
         public void addFieldMapping(FieldMapping fieldMapping) {
-                if (m_fieldsByObf.containsKey(fieldMapping.getObfName())) {
-                        throw new Error("Already have mapping for " + m_obfName + "." + fieldMapping.getObfName());
+                String obfKey = getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfType());
+                if (m_fieldsByObf.containsKey(obfKey)) {
+                        throw new Error("Already have mapping for " + m_obfName + "." + obfKey);
                 }
-                if (m_fieldsByDeobf.containsKey(fieldMapping.getDeobfName())) {
-                        throw new Error("Already have mapping for " + m_deobfName + "." + fieldMapping.getDeobfName());
+                String deobfKey = getFieldKey(fieldMapping.getDeobfName(), fieldMapping.getObfType());
+                if (m_fieldsByDeobf.containsKey(deobfKey)) {
+                        throw new Error("Already have mapping for " + m_deobfName + "." + deobfKey);
                 }
-                boolean obfWasAdded = m_fieldsByObf.put(fieldMapping.getObfName(), fieldMapping) == null;
+                boolean obfWasAdded = m_fieldsByObf.put(obfKey, fieldMapping) == null;
                 assert (obfWasAdded);
-                boolean deobfWasAdded = m_fieldsByDeobf.put(fieldMapping.getDeobfName(), fieldMapping) == null;
+                boolean deobfWasAdded = m_fieldsByDeobf.put(deobfKey, fieldMapping) == null;
                 assert (deobfWasAdded);
                 assert (m_fieldsByObf.size() == m_fieldsByDeobf.size());
         }
         
         public void removeFieldMapping(FieldMapping fieldMapping) {
-                boolean obfWasRemoved = m_fieldsByObf.remove(fieldMapping.getObfName()) != null;
+                boolean obfWasRemoved = m_fieldsByObf.remove(getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfType())) != null;
                 assert (obfWasRemoved);
                 if (fieldMapping.getDeobfName() != null) {
-                        boolean deobfWasRemoved = m_fieldsByDeobf.remove(fieldMapping.getDeobfName()) != null;
+                        boolean deobfWasRemoved = m_fieldsByDeobf.remove(getFieldKey(fieldMapping.getDeobfName(), fieldMapping.getObfType())) != null;
                         assert (deobfWasRemoved);
                 }
         }
         
-        public FieldMapping getFieldByObf(String obfName) {
-                return m_fieldsByObf.get(obfName);
+        public FieldMapping getFieldByObf(String obfName, Type obfType) {
+                return m_fieldsByObf.get(getFieldKey(obfName, obfType));
         }
         
-        public FieldMapping getFieldByDeobf(String deobfName) {
-                return m_fieldsByDeobf.get(deobfName);
+        public FieldMapping getFieldByDeobf(String deobfName, Type obfType) {
+                return m_fieldsByDeobf.get(getFieldKey(deobfName, obfType));
         }
         
-        public String getObfFieldName(String deobfName) {
-                FieldMapping fieldMapping = m_fieldsByDeobf.get(deobfName);
+        public String getObfFieldName(String deobfName, Type obfType) {
+                FieldMapping fieldMapping = m_fieldsByDeobf.get(getFieldKey(deobfName, obfType));
                 if (fieldMapping != null) {
                         return fieldMapping.getObfName();
                 }
                 return null;
         }
         
-        public String getDeobfFieldName(String obfName) {
-                FieldMapping fieldMapping = m_fieldsByObf.get(obfName);
+        public String getDeobfFieldName(String obfName, Type obfType) {
+                FieldMapping fieldMapping = m_fieldsByObf.get(getFieldKey(obfName, obfType));
                 if (fieldMapping != null) {
                         return fieldMapping.getDeobfName();
                 }
                 return null;
         }
         
-        public void setFieldName(String obfName, String deobfName) {
-                FieldMapping fieldMapping = m_fieldsByObf.get(obfName);
+        private String getFieldKey(String name, Type type) {
+                if (name == null) {
+                        throw new IllegalArgumentException("name cannot be null!");
+                }
+                if (type == null) {
+                        throw new IllegalArgumentException("type cannot be null!");
+                }
+                return name + ":" + type;
+        }
+        
+        
+        public void setFieldName(String obfName, Type obfType, String deobfName) {
+                FieldMapping fieldMapping = m_fieldsByObf.get(getFieldKey(obfName, obfType));
                 if (fieldMapping == null) {
-                        fieldMapping = new FieldMapping(obfName, deobfName);
-                        boolean obfWasAdded = m_fieldsByObf.put(obfName, fieldMapping) == null;
+                        fieldMapping = new FieldMapping(obfName, obfType, deobfName);
+                        boolean obfWasAdded = m_fieldsByObf.put(getFieldKey(obfName, obfType), fieldMapping) == null;
                         assert (obfWasAdded);
                 } else {
-                        boolean wasRemoved = m_fieldsByDeobf.remove(fieldMapping.getDeobfName()) != null;
+                        boolean wasRemoved = m_fieldsByDeobf.remove(getFieldKey(fieldMapping.getDeobfName(), obfType)) != null;
                         assert (wasRemoved);
                 }
                 fieldMapping.setDeobfName(deobfName);
                 if (deobfName != null) {
-                        boolean wasAdded = m_fieldsByDeobf.put(deobfName, fieldMapping) == null;
+                        boolean wasAdded = m_fieldsByDeobf.put(getFieldKey(deobfName, obfType), fieldMapping) == null;
                         assert (wasAdded);
                 }
         }
         
+        
         //// METHODS ////////
         
         public Iterable<MethodMapping> methods() {
@@ -235,8 +249,8 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping> {
                 return m_methodsByObf.containsKey(getMethodKey(obfName, obfSignature));
         }
         
-        public boolean containsDeobfMethod(String deobfName, Signature deobfSignature) {
-                return m_methodsByDeobf.containsKey(getMethodKey(deobfName, deobfSignature));
+        public boolean containsDeobfMethod(String deobfName, Signature obfSignature) {
+                return m_methodsByDeobf.containsKey(getMethodKey(deobfName, obfSignature));
         }
         
         public void addMethodMapping(MethodMapping methodMapping) {
@@ -266,12 +280,12 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping> {
                 }
         }
         
-        public MethodMapping getMethodByObf(String obfName, Signature signature) {
-                return m_methodsByObf.get(getMethodKey(obfName, signature));
+        public MethodMapping getMethodByObf(String obfName, Signature obfSignature) {
+                return m_methodsByObf.get(getMethodKey(obfName, obfSignature));
         }
         
-        public MethodMapping getMethodByDeobf(String deobfName, Signature signature) {
-                return m_methodsByDeobf.get(getMethodKey(deobfName, signature));
+        public MethodMapping getMethodByDeobf(String deobfName, Signature obfSignature) {
+                return m_methodsByDeobf.get(getMethodKey(deobfName, obfSignature));
         }
         
         private String getMethodKey(String name, Signature signature) {
diff --git a/src/cuchaz/enigma/mapping/FieldEntry.java b/src/cuchaz/enigma/mapping/FieldEntry.java
index 6cc9eb7..7517254 100644
--- a/src/cuchaz/enigma/mapping/FieldEntry.java
+++ b/src/cuchaz/enigma/mapping/FieldEntry.java
@@ -20,28 +20,33 @@ public class FieldEntry implements Entry, Serializable {
         
         private ClassEntry m_classEntry;
         private String m_name;
+        private Type m_type;
         
         // NOTE: this argument order is important for the MethodReader/MethodWriter
-        public FieldEntry(ClassEntry classEntry, String name) {
+        public FieldEntry(ClassEntry classEntry, String name, Type type) {
                 if (classEntry == null) {
                         throw new IllegalArgumentException("Class cannot be null!");
                 }
                 if (name == null) {
                         throw new IllegalArgumentException("Field name cannot be null!");
                 }
+                if (type == null) {
+                        throw new IllegalArgumentException("Field type cannot be null!");
+                }
                 
                 m_classEntry = classEntry;
                 m_name = name;
+                m_type = type;
         }
         
         public FieldEntry(FieldEntry other) {
-                m_classEntry = new ClassEntry(other.m_classEntry);
-                m_name = other.m_name;
+                this(other, new ClassEntry(other.m_classEntry));
         }
         
-        public FieldEntry(FieldEntry other, String newClassName) {
-                m_classEntry = new ClassEntry(newClassName);
+        public FieldEntry(FieldEntry other, ClassEntry newClassEntry) {
+                m_classEntry = newClassEntry;
                 m_name = other.m_name;
+                m_type = other.m_type;
         }
         
         @Override
@@ -59,14 +64,18 @@ public class FieldEntry implements Entry, Serializable {
                 return m_classEntry.getName();
         }
         
+        public Type getType() {
+                return m_type;
+        }
+        
         @Override
         public FieldEntry cloneToNewClass(ClassEntry classEntry) {
-                return new FieldEntry(this, classEntry.getName());
+                return new FieldEntry(this, classEntry);
         }
         
         @Override
         public int hashCode() {
-                return Util.combineHashesOrdered(m_classEntry, m_name);
+                return Util.combineHashesOrdered(m_classEntry, m_name, m_type);
         }
         
         @Override
@@ -78,11 +87,13 @@ public class FieldEntry implements Entry, Serializable {
         }
         
         public boolean equals(FieldEntry other) {
-                return m_classEntry.equals(other.m_classEntry) && m_name.equals(other.m_name);
+                return m_classEntry.equals(other.m_classEntry)
+                        && m_name.equals(other.m_name)
+                        && m_type.equals(other.m_type);
         }
         
         @Override
         public String toString() {
-                return m_classEntry.getName() + "." + m_name;
+                return m_classEntry.getName() + "." + m_name + ":" + m_type;
         }
 }
diff --git a/src/cuchaz/enigma/mapping/FieldMapping.java b/src/cuchaz/enigma/mapping/FieldMapping.java
index 5f5c270..14b20dd 100644
--- a/src/cuchaz/enigma/mapping/FieldMapping.java
+++ b/src/cuchaz/enigma/mapping/FieldMapping.java
@@ -18,10 +18,12 @@ public class FieldMapping implements Serializable, Comparable<FieldMapping> {
         
         private String m_obfName;
         private String m_deobfName;
+        private Type m_obfType;
         
-        public FieldMapping(String obfName, String deobfName) {
+        public FieldMapping(String obfName, Type obfType, String deobfName) {
                 m_obfName = obfName;
                 m_deobfName = NameValidator.validateFieldName(deobfName);
+                m_obfType = obfType;
         }
         
         public String getObfName() {
@@ -36,8 +38,12 @@ public class FieldMapping implements Serializable, Comparable<FieldMapping> {
                 m_deobfName = NameValidator.validateFieldName(val);
         }
         
+        public Type getObfType() {
+                return m_obfType;
+        }
+        
         @Override
         public int compareTo(FieldMapping other) {
-                return m_obfName.compareTo(other.m_obfName);
+                return (m_obfName + m_obfType).compareTo(other.m_obfName + other.m_obfType);
         }
 }
diff --git a/src/cuchaz/enigma/mapping/JavassistUtil.java b/src/cuchaz/enigma/mapping/JavassistUtil.java
index 0c446c4..0d6ce6a 100644
--- a/src/cuchaz/enigma/mapping/JavassistUtil.java
+++ b/src/cuchaz/enigma/mapping/JavassistUtil.java
@@ -70,14 +70,16 @@ public class JavassistUtil {
         public static FieldEntry getFieldEntry(CtField field) {
                 return new FieldEntry(
                         getClassEntry(field.getDeclaringClass()),
-                        field.getName()
+                        field.getName(),
+                        new Type(field.getFieldInfo().getDescriptor())
                 );
         }
         
         public static FieldEntry getFieldEntry(FieldAccess call) {
                 return new FieldEntry(
                         new ClassEntry(Descriptor.toJvmName(call.getClassName())),
-                        call.getFieldName()
+                        call.getFieldName(),
+                        new Type(call.getSignature())
                 );
         }
 }
diff --git a/src/cuchaz/enigma/mapping/Mappings.java b/src/cuchaz/enigma/mapping/Mappings.java
index 57d8001..675fdf1 100644
--- a/src/cuchaz/enigma/mapping/Mappings.java
+++ b/src/cuchaz/enigma/mapping/Mappings.java
@@ -162,10 +162,10 @@ public class Mappings implements Serializable {
                 return m_classesByDeobf.containsKey(deobfName);
         }
         
-        public boolean containsDeobfField(ClassEntry obfClassEntry, String deobfName) {
+        public boolean containsDeobfField(ClassEntry obfClassEntry, String deobfName, Type obfType) {
                 ClassMapping classMapping = m_classesByObf.get(obfClassEntry.getName());
                 if (classMapping != null) {
-                        return classMapping.containsDeobfField(deobfName);
+                        return classMapping.containsDeobfField(deobfName, obfType);
                 }
                 return false;
         }
diff --git a/src/cuchaz/enigma/mapping/MappingsReader.java b/src/cuchaz/enigma/mapping/MappingsReader.java
index adf460e..1e7b6e3 100644
--- a/src/cuchaz/enigma/mapping/MappingsReader.java
+++ b/src/cuchaz/enigma/mapping/MappingsReader.java
@@ -17,8 +17,6 @@ import java.util.Deque;
 
 import com.google.common.collect.Queues;
 
-import cuchaz.enigma.Constants;
-
 public class MappingsReader {
         
         public Mappings read(Reader in) throws IOException, MappingParseException {
@@ -114,62 +112,21 @@ public class MappingsReader {
         
         private ClassMapping readClass(String[] parts, boolean makeSimple) {
                 if (parts.length == 2) {
-                        String obfName = processName(parts[1], makeSimple);
-                        return new ClassMapping(obfName);
+                        return new ClassMapping(parts[1]);
                 } else {
-                        String obfName = processName(parts[1], makeSimple);
-                        String deobfName = processName(parts[2], makeSimple);
-                        return new ClassMapping(obfName, deobfName);
+                        return new ClassMapping(parts[1], parts[2]);
                 }
         }
         
-        private String processName(String name, boolean makeSimple) {
-                if (makeSimple) {
-                        return new ClassEntry(name).getSimpleName();
-                } else {
-                        return moveClassOutOfDefaultPackage(name, Constants.NonePackage);
-                }
-        }
-        
-        private String moveClassOutOfDefaultPackage(String className, String newPackageName) {
-                ClassEntry classEntry = new ClassEntry(className);
-                if (classEntry.isInDefaultPackage()) {
-                        return newPackageName + "/" + classEntry.getName();
-                }
-                return className;
-        }
-        
         private FieldMapping readField(String[] parts) {
-                return new FieldMapping(parts[1], parts[2]);
+                return new FieldMapping(parts[1], new Type(parts[3]), parts[2]);
         }
         
         private MethodMapping readMethod(String[] parts) {
                 if (parts.length == 3) {
-                        String obfName = parts[1];
-                        Signature obfSignature = moveSignatureOutOfDefaultPackage(new Signature(parts[2]), Constants.NonePackage);
-                        return new MethodMapping(obfName, obfSignature);
+                        return new MethodMapping(parts[1], new Signature(parts[2]));
                 } else {
-                        String obfName = parts[1];
-                        String deobfName = parts[2];
-                        Signature obfSignature = moveSignatureOutOfDefaultPackage(new Signature(parts[3]), Constants.NonePackage);
-                        if (obfName.equals(deobfName)) {
-                                return new MethodMapping(obfName, obfSignature);
-                        } else {
-                                return new MethodMapping(obfName, obfSignature, deobfName);
-                        }
+                        return new MethodMapping(parts[1], new Signature(parts[3]), parts[2]);
                 }
         }
-        
-        private Signature moveSignatureOutOfDefaultPackage(Signature signature, final String newPackageName) {
-                return new Signature(signature, new ClassNameReplacer() {
-                        @Override
-                        public String replace(String className) {
-                                ClassEntry classEntry = new ClassEntry(className);
-                                if (classEntry.isInDefaultPackage()) {
-                                        return newPackageName + "/" + className;
-                                }
-                                return null;
-                        }
-                });
-        }
 }
diff --git a/src/cuchaz/enigma/mapping/MappingsRenamer.java b/src/cuchaz/enigma/mapping/MappingsRenamer.java
index 0a41c2b..095e5e9 100644
--- a/src/cuchaz/enigma/mapping/MappingsRenamer.java
+++ b/src/cuchaz/enigma/mapping/MappingsRenamer.java
@@ -76,23 +76,23 @@ public class MappingsRenamer {
         
         public void setFieldName(FieldEntry obf, String deobfName) {
                 deobfName = NameValidator.validateFieldName(deobfName);
-                FieldEntry targetEntry = new FieldEntry(obf.getClassEntry(), deobfName);
-                if (m_mappings.containsDeobfField(obf.getClassEntry(), deobfName) || m_index.containsObfField(targetEntry)) {
+                FieldEntry targetEntry = new FieldEntry(obf.getClassEntry(), deobfName, obf.getType());
+                if (m_mappings.containsDeobfField(obf.getClassEntry(), deobfName, obf.getType()) || m_index.containsObfField(targetEntry)) {
                         throw new IllegalNameException(deobfName, "There is already a field with that name");
                 }
                 
                 ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping(obf.getClassEntry());
-                classMapping.setFieldName(obf.getName(), deobfName);
+                classMapping.setFieldName(obf.getName(), obf.getType(), deobfName);
         }
         
         public void removeFieldMapping(FieldEntry obf) {
                 ClassMapping classMapping = getClassMappingOrInnerClassMapping(obf.getClassEntry());
-                classMapping.setFieldName(obf.getName(), null);
+                classMapping.setFieldName(obf.getName(), obf.getType(), null);
         }
         
         public void markFieldAsDeobfuscated(FieldEntry obf) {
                 ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping(obf.getClassEntry());
-                classMapping.setFieldName(obf.getName(), obf.getName());
+                classMapping.setFieldName(obf.getName(), obf.getType(), obf.getName());
         }
         
         public void setMethodTreeName(MethodEntry obf, String deobfName) {
@@ -171,8 +171,8 @@ public class MappingsRenamer {
         public boolean moveFieldToObfClass(ClassMapping classMapping, FieldMapping fieldMapping, ClassEntry obfClass) {
                 classMapping.removeFieldMapping(fieldMapping);
                 ClassMapping targetClassMapping = getOrCreateClassMapping(obfClass);
-                if (!targetClassMapping.containsObfField(fieldMapping.getObfName())) {
-                        if (!targetClassMapping.containsDeobfField(fieldMapping.getDeobfName())) {
+                if (!targetClassMapping.containsObfField(fieldMapping.getObfName(), fieldMapping.getObfType())) {
+                        if (!targetClassMapping.containsDeobfField(fieldMapping.getDeobfName(), fieldMapping.getObfType())) {
                                 targetClassMapping.addFieldMapping(fieldMapping);
                                 return true;
                         } else {
diff --git a/src/cuchaz/enigma/mapping/MappingsWriter.java b/src/cuchaz/enigma/mapping/MappingsWriter.java
index 5ac409f..c7c2cc0 100644
--- a/src/cuchaz/enigma/mapping/MappingsWriter.java
+++ b/src/cuchaz/enigma/mapping/MappingsWriter.java
@@ -50,7 +50,7 @@ public class MappingsWriter {
         }
         
         private void write(PrintWriter out, FieldMapping fieldMapping, int depth) throws IOException {
-                out.format("%sFIELD %s %s\n", getIndent(depth), fieldMapping.getObfName(), fieldMapping.getDeobfName());
+                out.format("%sFIELD %s %s %s\n", getIndent(depth), fieldMapping.getObfName(), fieldMapping.getDeobfName(), fieldMapping.getObfType().toString());
         }
         
         private void write(PrintWriter out, MethodMapping methodMapping, int depth) throws IOException {
diff --git a/src/cuchaz/enigma/mapping/Translator.java b/src/cuchaz/enigma/mapping/Translator.java
index 5eba18c..759dddf 100644
--- a/src/cuchaz/enigma/mapping/Translator.java
+++ b/src/cuchaz/enigma/mapping/Translator.java
@@ -112,8 +112,8 @@ public class Translator {
                                 
                                 // look for the field
                                 String translatedName = m_direction.choose(
-                                        classMapping.getDeobfFieldName(in.getName()),
-                                        classMapping.getObfFieldName(in.getName())
+                                        classMapping.getDeobfFieldName(in.getName(), in.getType()),
+                                        classMapping.getObfFieldName(in.getName(), translateType(in.getType()))
                                 );
                                 if (translatedName != null) {
                                         return translatedName;
@@ -128,7 +128,7 @@ public class Translator {
                 if (name == null) {
                         name = in.getName();
                 }
-                return new FieldEntry(translateEntry(in.getClassEntry()), name);
+                return new FieldEntry(translateEntry(in.getClassEntry()), name, translateType(in.getType()));
         }
         
         public String translate(MethodEntry in) {
diff --git a/test/cuchaz/enigma/EntryFactory.java b/test/cuchaz/enigma/EntryFactory.java
index fa90779..8c94bdf 100644
--- a/test/cuchaz/enigma/EntryFactory.java
+++ b/test/cuchaz/enigma/EntryFactory.java
@@ -18,6 +18,7 @@ import cuchaz.enigma.mapping.ConstructorEntry;
 import cuchaz.enigma.mapping.FieldEntry;
 import cuchaz.enigma.mapping.MethodEntry;
 import cuchaz.enigma.mapping.Signature;
+import cuchaz.enigma.mapping.Type;
 
 public class EntryFactory {
         
@@ -25,12 +26,12 @@ public class EntryFactory {
                 return new ClassEntry(name);
         }
         
-        public static FieldEntry newField(String className, String fieldName) {
-                return newField(newClass(className), fieldName);
+        public static FieldEntry newField(String className, String fieldName, String fieldType) {
+                return newField(newClass(className), fieldName, fieldType);
         }
         
-        public static FieldEntry newField(ClassEntry classEntry, String fieldName) {
-                return new FieldEntry(classEntry, fieldName);
+        public static FieldEntry newField(ClassEntry classEntry, String fieldName, String fieldType) {
+                return new FieldEntry(classEntry, fieldName, new Type(fieldType));
         }
         
         public static MethodEntry newMethod(String className, String methodName, String methodSignature) {
diff --git a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java
index 1d6e5a5..349d33b 100644
--- a/test/cuchaz/enigma/TestJarIndexInheritanceTree.java
+++ b/test/cuchaz/enigma/TestJarIndexInheritanceTree.java
@@ -37,8 +37,8 @@ public class TestJarIndexInheritanceTree {
         private ClassEntry m_subClassA = newClass("none/b");
         private ClassEntry m_subClassAA = newClass("none/d");
         private ClassEntry m_subClassB = newClass("none/c");
-        private FieldEntry m_nameField = new FieldEntry(m_baseClass, "a");
-        private FieldEntry m_numThingsField = new FieldEntry(m_subClassB, "a");
+        private FieldEntry m_nameField = newField(m_baseClass, "a", "Ljava/lang/String;");
+        private FieldEntry m_numThingsField = newField(m_subClassB, "a", "I");
         
         public TestJarIndexInheritanceTree()
         throws Exception {
diff --git a/test/cuchaz/enigma/TestJarIndexLoneClass.java b/test/cuchaz/enigma/TestJarIndexLoneClass.java
index c6a9e55..c0ac8d7 100644
--- a/test/cuchaz/enigma/TestJarIndexLoneClass.java
+++ b/test/cuchaz/enigma/TestJarIndexLoneClass.java
@@ -64,9 +64,10 @@ public class TestJarIndexLoneClass {
         
         @Test
         public void access() {
-                assertThat(m_index.getAccess(newField("none/a", "a")), is(Access.Private));
+                assertThat(m_index.getAccess(newField("none/a", "a", "Ljava/lang/String;")), is(Access.Private));
                 assertThat(m_index.getAccess(newMethod("none/a", "a", "()Ljava/lang/String;")), is(Access.Public));
-                assertThat(m_index.getAccess(newField("none/a", "b")), is(nullValue()));
+                assertThat(m_index.getAccess(newField("none/a", "b", "Ljava/lang/String;")), is(nullValue()));
+                assertThat(m_index.getAccess(newField("none/a", "a", "LFoo;")), is(nullValue()));
         }
         
         @Test
@@ -110,7 +111,7 @@ public class TestJarIndexLoneClass {
         @Test
         @SuppressWarnings("unchecked")
         public void fieldReferences() {
-                FieldEntry source = newField("none/a", "a");
+                FieldEntry source = newField("none/a", "a", "Ljava/lang/String;");
                 Collection<EntryReference<FieldEntry,BehaviorEntry>> references = m_index.getFieldReferences(source);
                 assertThat(references, containsInAnyOrder(
                         newFieldReferenceByConstructor(source, "none/a", "(Ljava/lang/String;)V"),
@@ -157,8 +158,9 @@ public class TestJarIndexLoneClass {
         public void contains() {
                 assertThat(m_index.containsObfClass(newClass("none/a")), is(true));
                 assertThat(m_index.containsObfClass(newClass("none/b")), is(false));
-                assertThat(m_index.containsObfField(newField("none/a", "a")), is(true));
-                assertThat(m_index.containsObfField(newField("none/a", "b")), is(false));
+                assertThat(m_index.containsObfField(newField("none/a", "a", "Ljava/lang/String;")), is(true));
+                assertThat(m_index.containsObfField(newField("none/a", "b", "Ljava/lang/String;")), is(false));
+                assertThat(m_index.containsObfField(newField("none/a", "a", "LFoo;")), is(false));
                 assertThat(m_index.containsObfBehavior(newMethod("none/a", "a", "()Ljava/lang/String;")), is(true));
                 assertThat(m_index.containsObfBehavior(newMethod("none/a", "b", "()Ljava/lang/String;")), is(false));
         }
diff --git a/test/cuchaz/enigma/TestTranslator.java b/test/cuchaz/enigma/TestTranslator.java
index 290f6f0..f91c585 100644
--- a/test/cuchaz/enigma/TestTranslator.java
+++ b/test/cuchaz/enigma/TestTranslator.java
@@ -35,5 +35,8 @@ public class TestTranslator {
         throws Exception {
                 Translator translator = m_deobfuscator.getTranslator(TranslationDirection.Deobfuscating);
                 assertThat(translator.translateEntry(newClass("none/a")), is(newClass("deobf/A")));
+                assertThat(translator.translateEntry(newField("none/a", "a", "I")), is(newField("deobf/A", "one", "I")));
+                assertThat(translator.translateEntry(newField("none/a", "a", "F")), is(newField("deobf/A", "two", "F")));
+                assertThat(translator.translateEntry(newField("none/a", "a", "Ljava/lang/String;")), is(newField("deobf/A", "three", "Ljava/lang/String;")));
         }
 }
diff --git a/test/cuchaz/enigma/resources/translation.mappings b/test/cuchaz/enigma/resources/translation.mappings
index 70755bf..c71493e 100644
--- a/test/cuchaz/enigma/resources/translation.mappings
+++ b/test/cuchaz/enigma/resources/translation.mappings
@@ -1,4 +1,4 @@
 CLASS none/a deobf/A
-        FIELD a one
-        FIELD b two
-        FIELD c three
\ No newline at end of file
+        FIELD a one I
+        FIELD a two F
+        FIELD a three Ljava/lang/String;
\ No newline at end of file