started adding minimal support for generics

fixed mark-as-deobfuscated issue

6 files changed, 143 insertions, 28 deletions

diff --git a/src/cuchaz/enigma/mapping/EntryFactory.java b/src/cuchaz/enigma/mapping/EntryFactory.java
index 7bc6183..4898e6d 100644
--- a/src/cuchaz/enigma/mapping/EntryFactory.java
+++ b/src/cuchaz/enigma/mapping/EntryFactory.java
@@ -11,6 +11,7 @@ import javassist.expr.FieldAccess;
 import javassist.expr.MethodCall;
 import javassist.expr.NewExpr;
 
+import com.strobel.assembler.metadata.FieldDefinition;
 import com.strobel.assembler.metadata.MethodDefinition;
 
 import cuchaz.enigma.analysis.JarIndex;
@@ -54,6 +55,18 @@ public class EntryFactory {
                 );
         }
         
+        public static FieldEntry getFieldEntry(FieldDefinition def) {
+                return new FieldEntry(
+                        new ClassEntry(def.getDeclaringType().getInternalName()),
+                        def.getName(),
+                        new Type(def.getErasedSignature())
+                );
+        }
+        
+        public static FieldEntry getFieldEntry(String className, String name, String type) {
+                return new FieldEntry(new ClassEntry(className), name, new Type(type));
+        }
+        
         public static FieldEntry getObfFieldEntry(ClassMapping classMapping, FieldMapping fieldMapping) {
                 return new FieldEntry(
                         getObfClassEntry(classMapping),
@@ -82,7 +95,7 @@ public class EntryFactory {
                 return new MethodEntry(
                         new ClassEntry(def.getDeclaringType().getInternalName()),
                         def.getName(),
-                        new Signature(def.getSignature())
+                        new Signature(def.getErasedSignature())
                 );
         }
         
@@ -121,7 +134,7 @@ public class EntryFactory {
                 } else {
                         return new ConstructorEntry(
                                 new ClassEntry(def.getDeclaringType().getInternalName()),
-                                new Signature(def.getSignature())
+                                new Signature(def.getErasedSignature())
                         );
                 }
         }
diff --git a/src/cuchaz/enigma/mapping/MappingsChecker.java b/src/cuchaz/enigma/mapping/MappingsChecker.java
index c5ff7a7..57ea90c 100644
--- a/src/cuchaz/enigma/mapping/MappingsChecker.java
+++ b/src/cuchaz/enigma/mapping/MappingsChecker.java
@@ -66,7 +66,7 @@ public class MappingsChecker {
                 
                 // check the fields
                 for (FieldMapping fieldMapping : Lists.newArrayList(classMapping.fields())) {
-                        FieldEntry obfFieldEntry = new FieldEntry(classEntry, fieldMapping.getObfName(), fieldMapping.getObfType());
+                        FieldEntry obfFieldEntry = EntryFactory.getObfFieldEntry(classMapping, fieldMapping);
                         if (!m_index.containsObfField(obfFieldEntry)) {
                                 classMapping.removeFieldMapping(fieldMapping);
                                 m_droppedFieldMappings.put(obfFieldEntry, fieldMapping);
diff --git a/src/cuchaz/enigma/mapping/MappingsRenamer.java b/src/cuchaz/enigma/mapping/MappingsRenamer.java
index d7766dc..ad6c878 100644
--- a/src/cuchaz/enigma/mapping/MappingsRenamer.java
+++ b/src/cuchaz/enigma/mapping/MappingsRenamer.java
@@ -66,7 +66,15 @@ public class MappingsRenamer {
         }
         
         public void markClassAsDeobfuscated(ClassEntry obf) {
-                setClassName(obf, obf.isInnerClass() ? obf.getInnermostClassName() : obf.getSimpleName());
+                String deobfName = obf.isInnerClass() ? obf.getInnermostClassName() : obf.getName();
+                List<ClassMapping> mappingChain = getOrCreateClassMappingChain(obf);
+                if (mappingChain.size() == 1) {
+                        ClassMapping classMapping = mappingChain.get(0);
+                        m_mappings.setClassDeobfName(classMapping, deobfName);
+                } else {
+                        ClassMapping outerClassMapping = mappingChain.get(mappingChain.size() - 2);
+                        outerClassMapping.setInnerClassName(obf, deobfName);
+                }
         }
         
         public void setFieldName(FieldEntry obf, String deobfName) {
diff --git a/src/cuchaz/enigma/mapping/ParameterizedType.java b/src/cuchaz/enigma/mapping/ParameterizedType.java
new file mode 100644
index 0000000..af24ef4
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/ParameterizedType.java
@@ -0,0 +1,54 @@
+package cuchaz.enigma.mapping;
+
+import cuchaz.enigma.Util;
+
+
+
+public class ParameterizedType extends Type {
+
+        private static final long serialVersionUID = 1758975507937309011L;
+
+        public ParameterizedType(Type other) {
+                super(other);
+                for (int i=0; i<m_parameters.size(); i++) {
+                        m_parameters.set(i, new ParameterizedType(m_parameters.get(i)));
+                }
+        }
+        
+        public ParameterizedType(ParameterizedType type, ClassNameReplacer replacer) {
+                this(new Type(type, replacer));
+        }
+
+        @Override
+        public String toString() {
+                if (hasParameters()) {
+                        StringBuilder buf = new StringBuilder();
+                        buf.append(m_name.substring(0, m_name.length() - 1));
+                        buf.append("<");
+                        for (Type parameter : parameters()) {
+                                buf.append(parameter.toString());
+                        }
+                        buf.append(">;");
+                        return buf.toString();
+                } else {
+                        return m_name;
+                }
+        }
+        
+        @Override
+        public boolean equals(Object other) {
+                if (other instanceof ParameterizedType) {
+                        return equals((ParameterizedType)other);
+                }
+                return false;
+        }
+        
+        public boolean equals(ParameterizedType other) {
+                return m_name.equals(other.m_name) && m_parameters.equals(other.m_parameters);
+        }
+        
+        public int hashCode() {
+                return Util.combineHashesOrdered(m_name.hashCode(), m_parameters.hashCode());
+        }
+        
+}
diff --git a/src/cuchaz/enigma/mapping/Signature.java b/src/cuchaz/enigma/mapping/Signature.java
index ea83e40..f4850ac 100644
--- a/src/cuchaz/enigma/mapping/Signature.java
+++ b/src/cuchaz/enigma/mapping/Signature.java
@@ -79,16 +79,6 @@ public class Signature implements Serializable {
                 return types;
         }
         
-        public Iterable<ClassEntry> classes() {
-                List<ClassEntry> out = Lists.newArrayList();
-                for (Type type : types()) {
-                        if (type.isClass()) {
-                                out.add(type.getClassEntry());
-                        }
-                }
-                return out;
-        }
-        
         @Override
         public boolean equals(Object other) {
                 if (other instanceof Signature) {
diff --git a/src/cuchaz/enigma/mapping/Type.java b/src/cuchaz/enigma/mapping/Type.java
index 72118b0..d530083 100644
--- a/src/cuchaz/enigma/mapping/Type.java
+++ b/src/cuchaz/enigma/mapping/Type.java
@@ -1,8 +1,10 @@
 package cuchaz.enigma.mapping;
 
 import java.io.Serializable;
+import java.util.List;
 import java.util.Map;
 
+import com.beust.jcommander.internal.Lists;
 import com.google.common.collect.Maps;
 
 public class Type implements Serializable {
@@ -84,33 +86,66 @@ public class Type implements Serializable {
                 throw new IllegalArgumentException("don't know how to parse: " + in);
         }
                 
-        private String m_name;
+        protected String m_name;
+        protected List<Type> m_parameters;
         
         public Type(String name) {
-                m_name = name;
+                m_name = null;
+                m_parameters = Lists.newArrayList();
+                
+                int start = name.indexOf('<');
+                int stop = name.lastIndexOf('>');
+                if (start > 0 && stop > start) {
+                        
+                        // deal with generic parameters
+                        m_name = name.substring(0, start) + name.substring(stop + 1);
+                        
+                        String parameters = name.substring(start + 1, stop);
+                        int i=0;
+                        while (i<parameters.length()) {
+                                String typeName = Type.parseFirst(parameters.substring(i));
+                                if (typeName == null) {
+                                        throw new Error("Don't know how to parse parameters: " + name);
+                                }
+                                m_parameters.add(new Type(typeName));
+                                i += typeName.length();
+                        }
+                        
+                } else {
+                        m_name = name;
+                }
         }
         
         public Type(Type other) {
                 m_name = other.m_name;
+                m_parameters = Lists.newArrayList();
+                for (Type parameter : other.m_parameters) {
+                        m_parameters.add(new Type(parameter));
+                }
         }
         
         public Type(ClassEntry classEntry) {
                 m_name = "L" + classEntry.getClassName() + ";";
         }
         
-        public Type(Type type, ClassNameReplacer replacer) {
-                m_name = type.m_name;
-                if (type.isClass()) {
-                        String replacedName = replacer.replace(type.getClassEntry().getClassName());
+        public Type(Type other, ClassNameReplacer replacer) {
+                m_name = other.m_name;
+                if (other.isClass()) {
+                        String replacedName = replacer.replace(other.getClassEntry().getClassName());
                         if (replacedName != null) {
                                 m_name = "L" + replacedName + ";";
                         }
-                } else if (type.isArray() && type.hasClass()) {
-                        String replacedName = replacer.replace(type.getClassEntry().getClassName());
+                } else if (other.isArray() && other.hasClass()) {
+                        String replacedName = replacer.replace(other.getClassEntry().getClassName());
                         if (replacedName != null) {
-                                m_name = Type.getArrayPrefix(type.getArrayDimension()) + "L" + replacedName + ";";
+                                m_name = Type.getArrayPrefix(other.getArrayDimension()) + "L" + replacedName + ";";
                         }
                 }
+                
+                m_parameters = Lists.newArrayList();
+                for (Type parameter : other.m_parameters) {
+                        m_parameters.add(new Type(parameter, replacer));
+                }
         }
         
         @Override
@@ -137,10 +172,6 @@ public class Type implements Serializable {
                 return m_name.charAt(0) == 'L' && m_name.charAt(m_name.length() - 1) == ';';
         }
         
-        public boolean isTemplate() {
-                return m_name.charAt(0) == 'T' && m_name.charAt(m_name.length() - 1) == ';';
-        }
-        
         public ClassEntry getClassEntry() {
                 if (isClass()) {
                         String name = m_name.substring(1, m_name.length() - 1);
@@ -160,6 +191,17 @@ public class Type implements Serializable {
                 }
         }
         
+        public boolean isTemplate() {
+                return m_name.charAt(0) == 'T' && m_name.charAt(m_name.length() - 1) == ';';
+        }
+
+        public String getTemplate() {
+                if (!isTemplate()) {
+                        throw new IllegalStateException("not an template");
+                }
+                return m_name.substring(1, m_name.length() - 1);
+        }
+        
         public boolean isArray() {
                 return m_name.charAt(0) == '[';
         }
@@ -190,6 +232,14 @@ public class Type implements Serializable {
                 return isClass() || (isArray() && getArrayType().hasClass());
         }
         
+        public boolean hasParameters() {
+                return !m_parameters.isEmpty();
+        }
+        
+        public Iterable<Type> parameters() {
+                return m_parameters;
+        }
+        
         @Override
         public boolean equals(Object other) {
                 if (other instanceof Type) {
@@ -214,7 +264,7 @@ public class Type implements Serializable {
         
         private static String readClass(String in) {
                 // read all the characters in the buffer until we hit a ';'
-                // remember to treat parameters correctly
+                // include the parameters too
                 StringBuilder buf = new StringBuilder();
                 int depth = 0;
                 for (int i=0; i<in.length(); i++) {