started adding minimal support for generics

fixed mark-as-deobfuscated issue

11 files changed, 294 insertions, 130 deletions

diff --git a/src/cuchaz/enigma/Deobfuscator.java b/src/cuchaz/enigma/Deobfuscator.java
index 5a23ce5..b63f163 100644
--- a/src/cuchaz/enigma/Deobfuscator.java
+++ b/src/cuchaz/enigma/Deobfuscator.java
@@ -439,12 +439,9 @@ public class Deobfuscator {
                 Translator translator = getTranslator(TranslationDirection.Deobfuscating);
                 if (obfEntry instanceof ClassEntry) {
                         ClassEntry obfClass = (ClassEntry)obfEntry;
-                        ClassEntry translated = translator.translateEntry(obfClass);
-                        if (obfClass.isInnerClass()) {
-                                return !obfClass.getInnermostClassName().equals(translated.getInnermostClassName());
-                        } else {
-                                return !obfClass.equals(translated);
-                        }
+                        List<ClassMapping> mappingChain = m_mappings.getClassMappingChain(obfClass);
+                        ClassMapping classMapping = mappingChain.get(mappingChain.size() - 1);
+                        return classMapping != null && classMapping.getDeobfName() != null;
                 } else if (obfEntry instanceof FieldEntry) {
                         return translator.translate((FieldEntry)obfEntry) != null;
                 } else if (obfEntry instanceof MethodEntry) {
diff --git a/src/cuchaz/enigma/analysis/JarIndex.java b/src/cuchaz/enigma/analysis/JarIndex.java
index 7ebbd97..e255468 100644
--- a/src/cuchaz/enigma/analysis/JarIndex.java
+++ b/src/cuchaz/enigma/analysis/JarIndex.java
@@ -28,6 +28,7 @@ import javassist.CtMethod;
 import javassist.NotFoundException;
 import javassist.bytecode.AccessFlag;
 import javassist.bytecode.Descriptor;
+import javassist.bytecode.EnclosingMethodAttribute;
 import javassist.bytecode.FieldInfo;
 import javassist.bytecode.InnerClassesAttribute;
 import javassist.expr.ConstructorCall;
@@ -314,15 +315,6 @@ public class JarIndex {
                 if (classEntry.isInnerClass()) {
                         return classEntry.getOuterClassEntry();
                 }
-                InnerClassesAttribute innerClassesAttribute = (InnerClassesAttribute)c.getClassFile().getAttribute(InnerClassesAttribute.tag);
-                if (innerClassesAttribute != null) {
-                        for (int i=0; i<innerClassesAttribute.tableLength(); i++) {
-                                ClassEntry innerClassEntry = new ClassEntry(Descriptor.toJvmName(innerClassesAttribute.innerClass(i)));
-                                if (classEntry.equals(innerClassEntry)) {
-                                        return new ClassEntry(Descriptor.toJvmName(innerClassesAttribute.outerClass(i)));
-                                }
-                        }
-                }
                 
                 // inner classes:
                 // have constructors that can (illegally) set synthetic fields
@@ -481,6 +473,27 @@ public class JarIndex {
         
         private BehaviorEntry isAnonymousClass(CtClass c, ClassEntry outerClassEntry) {
                 
+                // is this class already marked anonymous?
+                EnclosingMethodAttribute enclosingMethodAttribute = (EnclosingMethodAttribute)c.getClassFile().getAttribute(EnclosingMethodAttribute.tag);
+                if (enclosingMethodAttribute != null) {
+                        if (enclosingMethodAttribute.methodIndex() > 0) {
+                                return EntryFactory.getBehaviorEntry(
+                                        Descriptor.toJvmName(enclosingMethodAttribute.className()),
+                                        enclosingMethodAttribute.methodName(),
+                                        enclosingMethodAttribute.methodDescriptor()
+                                );
+                        } else {
+                                // an attribute but no method? assume not anonymous
+                                return null;
+                        }
+                }
+                
+                // if there's an inner class attribute, but not an enclosing method attribute, then it's not anonymous
+                InnerClassesAttribute innerClassesAttribute = (InnerClassesAttribute)c.getClassFile().getAttribute(InnerClassesAttribute.tag);
+                if (innerClassesAttribute != null) {
+                        return null;
+                }
+                
                 ClassEntry innerClassEntry = new ClassEntry(Descriptor.toJvmName(c.getName()));
                 
                 // anonymous classes:
diff --git a/src/cuchaz/enigma/analysis/SourceIndexClassVisitor.java b/src/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
index f4f4956..f4202b5 100644
--- a/src/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
+++ b/src/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
@@ -30,7 +30,6 @@ import cuchaz.enigma.mapping.ClassEntry;
 import cuchaz.enigma.mapping.ConstructorEntry;
 import cuchaz.enigma.mapping.EntryFactory;
 import cuchaz.enigma.mapping.FieldEntry;
-import cuchaz.enigma.mapping.Type;
 
 public class SourceIndexClassVisitor extends SourceIndexVisitor {
         
@@ -93,8 +92,7 @@ public class SourceIndexClassVisitor extends SourceIndexVisitor {
         @Override
         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(), new Type(def.getErasedSignature()));
+                FieldEntry fieldEntry = EntryFactory.getFieldEntry(def);
                 assert (node.getVariables().size() == 1);
                 VariableInitializer variable = node.getVariables().firstOrNullObject();
                 index.addDeclaration(variable.getNameToken(), fieldEntry);
@@ -106,8 +104,7 @@ public class SourceIndexClassVisitor extends SourceIndexVisitor {
         public Void visitEnumValueDeclaration(EnumValueDeclaration node, SourceIndex index) {
                 // 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(), new Type(def.getErasedSignature()));
+                FieldEntry fieldEntry = EntryFactory.getFieldEntry(def);
                 index.addDeclaration(node.getNameToken(), fieldEntry);
                 
                 return recurse(node, index);
diff --git a/src/cuchaz/enigma/bytecode/ClassRenamer.java b/src/cuchaz/enigma/bytecode/ClassRenamer.java
index e9cdea3..8bc084d 100644
--- a/src/cuchaz/enigma/bytecode/ClassRenamer.java
+++ b/src/cuchaz/enigma/bytecode/ClassRenamer.java
@@ -23,60 +23,100 @@ import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
 
 import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ClassNameReplacer;
+import cuchaz.enigma.mapping.ParameterizedType;
+import cuchaz.enigma.mapping.Translator;
+import cuchaz.enigma.mapping.Type;
 
 public class ClassRenamer {
         
-        public static void renameClasses(CtClass c, Map<ClassEntry,ClassEntry> map) {
-                
-                // build the map used by javassist
-                ClassMap nameMap = new ClassMap();
-                for (Map.Entry<ClassEntry,ClassEntry> entry : map.entrySet()) {
-                        nameMap.put(entry.getKey().getName(), entry.getValue().getName());
-                }
-                
-                c.replaceClassName(nameMap);
-                
-                // replace simple names in the InnerClasses attribute too
-                ConstPool constants = c.getClassFile().getConstPool();
-                InnerClassesAttribute attr = (InnerClassesAttribute)c.getClassFile().getAttribute(InnerClassesAttribute.tag);
-                if (attr != null) {
-                        for (int i = 0; i < attr.tableLength(); i++) {
-                                ClassEntry classEntry = new ClassEntry(Descriptor.toJvmName(attr.innerClass(i)));
-                                if (attr.innerNameIndex(i) != 0) {
-                                        attr.setInnerNameIndex(i, constants.addUtf8Info(classEntry.getInnermostClassName()));
+        public static void renameClasses(CtClass c, final Translator translator) {
+                renameClasses(c, new ClassNameReplacer() {
+                        @Override
+                        public String replace(String className) {
+                                ClassEntry entry = translator.translateEntry(new ClassEntry(className));
+                                if (entry != null) {
+                                        return entry.getName();
                                 }
-                                
-                                /* DEBUG
-                                System.out.println(String.format("\tDEOBF: %s-> ATTR: %s,%s,%s", classEntry, attr.outerClass(i), attr.innerClass(i), attr.innerName(i)));
-                                */
+                                return null;
                         }
-                }
+                });
         }
         
-        public static Set<ClassEntry> getAllClassEntries(final CtClass c) {
+        public static void moveAllClassesOutOfDefaultPackage(CtClass c, final String newPackageName) {
+                renameClasses(c, new ClassNameReplacer() {
+                        @Override
+                        public String replace(String className) {
+                                ClassEntry entry = new ClassEntry(className);
+                                if (entry.isInDefaultPackage()) {
+                                        return newPackageName + "/" + entry.getName();
+                                }
+                                return null;
+                        }
+                });
+        }
+        
+        public static void moveAllClassesIntoDefaultPackage(CtClass c, final String oldPackageName) {
+                renameClasses(c, new ClassNameReplacer() {
+                        @Override
+                        public String replace(String className) {
+                                ClassEntry entry = new ClassEntry(className);
+                                if (entry.getPackageName().equals(oldPackageName)) {
+                                        return entry.getSimpleName();
+                                }
+                                return null;
+                        }
+                });
+        }
+        
+        public static void renameClasses(CtClass c, ClassNameReplacer replacer) {
+                Map<ParameterizedType,ParameterizedType> map = Maps.newHashMap();
+                for (ParameterizedType type : ClassRenamer.getAllClassTypes(c)) {
+                        ParameterizedType renamedType = new ParameterizedType(type, replacer);
+                        if (!type.equals(renamedType)) {
+                                map.put(type, renamedType);
+                        }
+                }
+                renameTypes(c, map);
+        }
+
+        public static Set<ParameterizedType> getAllClassTypes(final CtClass c) {
                 
-                // get the classes that javassist knows about
-                final Set<ClassEntry> entries = Sets.newHashSet();
+                // TODO: might have to scan SignatureAttributes directly because javassist is buggy
+                
+                // get the class types that javassist knows about
+                final Set<ParameterizedType> types = Sets.newHashSet();
                 ClassMap map = new ClassMap() {
                         @Override
                         public Object get(Object obj) {
                                 if (obj instanceof String) {
                                         String str = (String)obj;
                                         
-                                        // javassist throws a lot of weird things at this map
-                                        // I either have to implement my on class scanner, or just try to filter out the weirdness
-                                        // I'm opting to filter out the weirdness for now
+                                        // sometimes javasist gives us dot-separated classes... whadda hell?
+                                        str = str.replace('.', '/');
                                         
-                                        // skip anything with generic arguments
-                                        if (str.indexOf('<') >= 0 || str.indexOf('>') >= 0 || str.indexOf(';') >= 0) {
+                                        // skip weird types
+                                        boolean hasNestedParams = str.indexOf('<') >= 0 && str.indexOf('<', str.indexOf('<')+1) >= 0;
+                                        boolean hasWeirdChars = str.indexOf('*') >= 0 || str.indexOf('-') >= 0 || str.indexOf('+') >= 0;
+                                        if (hasNestedParams || hasWeirdChars) {
+                                                // TEMP
+                                                System.out.println("Skipped translating: " + str);
                                                 return null;
                                         }
                                         
-                                        // convert path/to/class.inner to path/to/class$inner
-                                        str = str.replace('.', '$');
+                                        ParameterizedType type = new ParameterizedType(new Type("L" + str + ";"));
+                                        assert(type.isClass());
+                                        // TEMP
+                                        try {
+                                                type.getClassEntry();
+                                        } catch (Throwable t) {
+                                                // bad type
+                                                // TEMP
+                                                System.out.println("Skipped translating: " + str);
+                                                return null;
+                                        }
                                         
-                                        // remember everything else
-                                        entries.add(new ClassEntry(str));
+                                        types.add(type);
                                 }
                                 return null;
                         }
@@ -85,26 +125,46 @@ public class ClassRenamer {
                 };
                 c.replaceClassName(map);
                 
-                return entries;
+                return types;
         }
-        
-        public static void moveAllClassesOutOfDefaultPackage(CtClass c, String newPackageName) {
-                Map<ClassEntry,ClassEntry> map = Maps.newHashMap();
-                for (ClassEntry classEntry : ClassRenamer.getAllClassEntries(c)) {
-                        if (classEntry.isInDefaultPackage()) {
-                                map.put(classEntry, new ClassEntry(newPackageName + "/" + classEntry.getName()));
-                        }
+
+        public static void renameTypes(CtClass c, Map<ParameterizedType,ParameterizedType> map) {
+                
+                // convert the type map to a javassist class map
+                ClassMap nameMap = new ClassMap();
+                for (Map.Entry<ParameterizedType,ParameterizedType> entry : map.entrySet()) {
+                        String source = entry.getKey().toString();
+                        String dest = entry.getValue().toString();
+                        
+                        // don't forget to chop off the L ... ;
+                        // javassist doesn't want it there
+                        source = source.substring(1, source.length() - 1);
+                        dest = dest.substring(1, dest.length() - 1);
+                        
+                        nameMap.put(source, dest);
                 }
-                ClassRenamer.renameClasses(c, map);
-        }
-        
-        public static void moveAllClassesIntoDefaultPackage(CtClass c, String oldPackageName) {
-                Map<ClassEntry,ClassEntry> map = Maps.newHashMap();
-                for (ClassEntry classEntry : ClassRenamer.getAllClassEntries(c)) {
-                        if (classEntry.getPackageName().equals(oldPackageName)) {
-                                map.put(classEntry, new ClassEntry(classEntry.getSimpleName()));
+                
+                // replace!!
+                c.replaceClassName(nameMap);
+
+                // replace simple names in the InnerClasses attribute too
+                ConstPool constants = c.getClassFile().getConstPool();
+                InnerClassesAttribute attr = (InnerClassesAttribute)c.getClassFile().getAttribute(InnerClassesAttribute.tag);
+                if (attr != null) {
+                        for (int i = 0; i < attr.tableLength(); i++) {
+                                
+                                // get the inner class full name (which has already been translated)
+                                ClassEntry classEntry = new ClassEntry(Descriptor.toJvmName(attr.innerClass(i)));
+                                
+                                if (attr.innerNameIndex(i) != 0) {
+                                        // update the inner name
+                                        attr.setInnerNameIndex(i, constants.addUtf8Info(classEntry.getInnermostClassName()));
+                                }
+                                
+                                /* DEBUG
+                                System.out.println(String.format("\tDEOBF: %s-> ATTR: %s,%s,%s", classEntry, attr.outerClass(i), attr.innerClass(i), attr.innerName(i)));
+                                */
                         }
                 }
-                ClassRenamer.renameClasses(c, map);
         }
 }
diff --git a/src/cuchaz/enigma/bytecode/ClassTranslator.java b/src/cuchaz/enigma/bytecode/ClassTranslator.java
index 94ab2c4..7952577 100644
--- a/src/cuchaz/enigma/bytecode/ClassTranslator.java
+++ b/src/cuchaz/enigma/bytecode/ClassTranslator.java
@@ -10,8 +10,6 @@
  ******************************************************************************/
 package cuchaz.enigma.bytecode;
 
-import java.util.Map;
-
 import javassist.CtBehavior;
 import javassist.CtClass;
 import javassist.CtField;
@@ -19,9 +17,6 @@ import javassist.CtMethod;
 import javassist.bytecode.ConstPool;
 import javassist.bytecode.Descriptor;
 import javassist.bytecode.SourceFileAttribute;
-
-import com.google.common.collect.Maps;
-
 import cuchaz.enigma.mapping.BehaviorEntry;
 import cuchaz.enigma.mapping.ClassEntry;
 import cuchaz.enigma.mapping.EntryFactory;
@@ -50,20 +45,15 @@ public class ClassTranslator {
                                 
                                 case ConstPool.CONST_Fieldref: {
                                         
-                                        // translate the name
-                                        FieldEntry entry = new FieldEntry(
-                                                new ClassEntry(Descriptor.toJvmName(constants.getFieldrefClassName(i))),
+                                        // translate the name and type
+                                        FieldEntry entry = EntryFactory.getFieldEntry(
+                                                Descriptor.toJvmName(constants.getFieldrefClassName(i)),
                                                 constants.getFieldrefName(i),
-                                                new Type(constants.getFieldrefType(i))
+                                                constants.getFieldrefType(i)
                                         );
                                         FieldEntry translatedEntry = m_translator.translateEntry(entry);
-                                        
-                                        // translate the type
-                                        Type type = new Type(constants.getFieldrefType(i));
-                                        Type translatedType = m_translator.translateType(type);
-                                        
-                                        if (!entry.equals(translatedEntry) || !type.equals(translatedType)) {
-                                                editor.changeMemberrefNameAndType(i, translatedEntry.getName(), translatedType.toString());
+                                        if (!entry.equals(translatedEntry)) {
+                                                editor.changeMemberrefNameAndType(i, translatedEntry.getName(), translatedEntry.getType().toString());
                                         }
                                 }
                                 break;
@@ -71,15 +61,14 @@ public class ClassTranslator {
                                 case ConstPool.CONST_Methodref:
                                 case ConstPool.CONST_InterfaceMethodref: {
                                         
-                                        // translate the name and type
+                                        // translate the name and type (ie signature)
                                         BehaviorEntry entry = EntryFactory.getBehaviorEntry(
                                                 Descriptor.toJvmName(editor.getMemberrefClassname(i)),
                                                 editor.getMemberrefName(i),
                                                 editor.getMemberrefType(i)
                                         );
                                         BehaviorEntry translatedEntry = m_translator.translateEntry(entry);
-                                        
-                                        if (!entry.getName().equals(translatedEntry.getName()) || !entry.getSignature().equals(translatedEntry.getSignature())) {
+                                        if (!entry.equals(translatedEntry)) {
                                                 editor.changeMemberrefNameAndType(i, translatedEntry.getName(), translatedEntry.getSignature().toString());
                                         }
                                 }
@@ -120,25 +109,18 @@ public class ClassTranslator {
                         }
                         
                         if (entry.getSignature() != null) {
-                                // translate the type
+                                // translate the signature
                                 Signature translatedSignature = m_translator.translateSignature(entry.getSignature());
                                 behavior.getMethodInfo().setDescriptor(translatedSignature.toString());
                         }
                 }
                 
                 // translate all the class names referenced in the code
-                // the above code only changed method/field/reference names and types, but not the class names themselves
-                Map<ClassEntry,ClassEntry> map = Maps.newHashMap();
-                for (ClassEntry obfClassEntry : ClassRenamer.getAllClassEntries(c)) {
-                        ClassEntry deobfClassEntry = m_translator.translateEntry(obfClassEntry);
-                        if (!obfClassEntry.equals(deobfClassEntry)) {
-                                map.put(obfClassEntry, deobfClassEntry);
-                        }
-                }
-                ClassRenamer.renameClasses(c, map);
+                // the above code only changed method/field/reference names and types, but not the rest of the class references
+                ClassRenamer.renameClasses(c, m_translator);
                 
                 // translate the source file attribute too
-                ClassEntry deobfClassEntry = map.get(classEntry);
+                ClassEntry deobfClassEntry = m_translator.translateEntry(classEntry);
                 if (deobfClassEntry != null) {
                         String sourceFile = Descriptor.toJvmName(deobfClassEntry.getOutermostClassName()) + ".java";
                         c.getClassFile().addAttribute(new SourceFileAttribute(constants, sourceFile));
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++) {