added types to fields

9 files changed, 96 insertions, 106 deletions

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) {