From 5e3743a0aca3529eacf9be400c8b8d7547f66e7f Mon Sep 17 00:00:00 2001 From: jeff Date: Mon, 16 Mar 2015 19:22:22 -0400 Subject: started adding minimal support for generics fixed mark-as-deobfuscated issue --- src/cuchaz/enigma/Deobfuscator.java | 9 +- src/cuchaz/enigma/analysis/JarIndex.java | 31 ++-- .../enigma/analysis/SourceIndexClassVisitor.java | 7 +- src/cuchaz/enigma/bytecode/ClassRenamer.java | 164 ++++++++++++++------- src/cuchaz/enigma/bytecode/ClassTranslator.java | 42 ++---- src/cuchaz/enigma/mapping/EntryFactory.java | 17 ++- src/cuchaz/enigma/mapping/MappingsChecker.java | 2 +- src/cuchaz/enigma/mapping/MappingsRenamer.java | 10 +- src/cuchaz/enigma/mapping/ParameterizedType.java | 54 +++++++ src/cuchaz/enigma/mapping/Signature.java | 10 -- src/cuchaz/enigma/mapping/Type.java | 78 ++++++++-- test/cuchaz/enigma/TestSourceIndex.java | 2 +- test/cuchaz/enigma/TestTranslator.java | 17 ++- test/cuchaz/enigma/TestType.java | 163 +++++++++++++++++++- test/cuchaz/enigma/resources/translation.mappings | 11 +- 15 files changed, 478 insertions(+), 139 deletions(-) create mode 100644 src/cuchaz/enigma/mapping/ParameterizedType.java diff --git a/src/cuchaz/enigma/Deobfuscator.java b/src/cuchaz/enigma/Deobfuscator.java index 5a23ce5b..b63f1639 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 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 7ebbd974..e255468a 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 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 f4f49568..f4202b5b 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 e9cdea3c..8bc084d3 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 map) { - - // build the map used by javassist - ClassMap nameMap = new ClassMap(); - for (Map.Entry 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 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 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 getAllClassTypes(final CtClass c) { - // get the classes that javassist knows about - final Set entries = Sets.newHashSet(); + // TODO: might have to scan SignatureAttributes directly because javassist is buggy + + // get the class types that javassist knows about + final Set 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 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 map) { + + // convert the type map to a javassist class map + ClassMap nameMap = new ClassMap(); + for (Map.Entry 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 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 94ab2c4b..7952577b 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 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 7bc61839..4898e6de 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 c5ff7a7e..57ea90ce 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 d7766dc8..ad6c8785 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 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 00000000..af24ef44 --- /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;"); + 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 ea83e40e..f4850ac3 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 classes() { - List 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 72118b04..d5300839 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 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() { + 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;").isClass(), is(true)); + assertThat(new Type("LFoo;").isClass(), is(true)); + assertThat(new Type("LFoo;>;").isClass(), is(true)); assertThat(new Type("[I").isClass(), is(false)); + assertThat(new Type("TFoo;").isClass(), is(false)); } @Test public void getClassEntry() { assertThat(new Type("LFoo;").getClassEntry(), is(newClass("Foo"))); assertThat(new Type("LFoo;").getClassEntry(), is(newClass("Foo"))); + assertThat(new Type("LFoo;").getClassEntry(), is(newClass("Foo"))); + assertThat(new Type("LFoo;").getClassEntry(), is(newClass("Foo"))); + assertThat(new Type("LFoo;>;").getClassEntry(), is(newClass("Foo"))); } @Test @@ -89,6 +98,7 @@ public class TestType { assertThat(new Type("D").isArray(), is(false)); assertThat(new Type("LFoo;").isArray(), is(false)); assertThat(new Type("[I").isArray(), is(true)); + assertThat(new Type("TFoo;").isArray(), is(false)); } @Test @@ -106,6 +116,30 @@ public class TestType { assertThat(new Type("[Ljava/lang/String;").getArrayType(), is(new Type("Ljava/lang/String;"))); } + @Test + public void isTemplate() { + assertThat(new Type("V").isTemplate(), is(false)); + assertThat(new Type("Z").isTemplate(), is(false)); + assertThat(new Type("B").isTemplate(), is(false)); + assertThat(new Type("C").isTemplate(), is(false)); + assertThat(new Type("I").isTemplate(), is(false)); + assertThat(new Type("J").isTemplate(), is(false)); + assertThat(new Type("F").isTemplate(), is(false)); + assertThat(new Type("D").isTemplate(), is(false)); + assertThat(new Type("LFoo;").isTemplate(), is(false)); + assertThat(new Type("LFoo;").isTemplate(), is(false)); + assertThat(new Type("LFoo;").isTemplate(), is(false)); + assertThat(new Type("LFoo;>;").isTemplate(), is(false)); + assertThat(new Type("[I").isTemplate(), is(false)); + assertThat(new Type("TFoo;").isTemplate(), is(true)); + } + + @Test + public void getTemplate() { + assertThat(new Type("TT;").getTemplate(), is("T")); + assertThat(new Type("TFoo;").getTemplate(), is("Foo")); + } + @Test public void hasClass() { assertThat(new Type("LFoo;").hasClass(), is(true)); @@ -117,6 +151,37 @@ public class TestType { assertThat(new Type("[I").hasClass(), is(false)); assertThat(new Type("[[[I").hasClass(), is(false)); assertThat(new Type("Z").hasClass(), is(false)); + assertThat(new Type("TFoo;").hasClass(), is(false)); + } + + @Test + public void parameters() { + assertThat(new Type("LFoo;").parameters(), contains( + new Type("I") + )); + assertThat(new Type("LFoo;").parameters(), contains( + new Type("I"), + new Type("I"), + new Type("I"), + new Type("I") + )); + assertThat(new Type("LFoo;").parameters(), contains( + new Type("LBar;") + )); + assertThat(new Type("LFoo;").parameters(), contains( + new Type("LBar;"), + new Type("LCow;"), + new Type("LCheese;") + )); + + assertThat(new Type("LFoo;>;").parameters(), contains( + new Type("LBar;") + )); + + assertThat(new Type("LFoo;>;").parameters().iterator().next().parameters(), contains( + new Type("LCow;"), + new Type("LCheese;") + )); } @Test @@ -171,7 +236,18 @@ public class TestType { assertThat(Type.parseFirst("LFoo;[LFoo;"), is(answer)); } } - + + @Test + public void parseTemplate() { + final String answer = "TFoo;"; + assertThat(Type.parseFirst("TFoo;"), is(answer)); + assertThat(Type.parseFirst("TFoo;I"), is(answer)); + assertThat(Type.parseFirst("TFoo;JZ"), is(answer)); + assertThat(Type.parseFirst("TFoo;[I"), is(answer)); + assertThat(Type.parseFirst("TFoo;LFoo;"), is(answer)); + assertThat(Type.parseFirst("TFoo;[LFoo;"), is(answer)); + } + @Test public void parseArray() { { @@ -215,15 +291,90 @@ public class TestType { assertThat(new Type("[[[I"), is(new Type("[[[I"))); assertThat(new Type("[LFoo;"), is(new Type("[LFoo;"))); assertThat(new Type("LFoo;"), is(new Type("LFoo;"))); + assertThat(new Type("LFoo;"), is(new Type("LFoo;"))); + assertThat(new Type("TFoo;"), is(new Type("TFoo;"))); assertThat(new Type("V"), is(not(new Type("I")))); assertThat(new Type("I"), is(not(new Type("J")))); assertThat(new Type("I"), is(not(new Type("LBar;")))); assertThat(new Type("I"), is(not(new Type("[I")))); assertThat(new Type("LFoo;"), is(not(new Type("LBar;")))); - assertThat(new Type("LFoo;"), is(not(new Type("LFoo;")))); assertThat(new Type("[I"), is(not(new Type("[Z")))); assertThat(new Type("[[[I"), is(not(new Type("[I")))); assertThat(new Type("[LFoo;"), is(not(new Type("[LBar;")))); + assertThat(new Type("TFoo;"), is(not(new Type("TBar;")))); + } + + @Test + public void testToString() { + assertThat(new Type("V").toString(), is("V")); + assertThat(new Type("Z").toString(), is("Z")); + assertThat(new Type("B").toString(), is("B")); + assertThat(new Type("C").toString(), is("C")); + assertThat(new Type("I").toString(), is("I")); + assertThat(new Type("J").toString(), is("J")); + assertThat(new Type("F").toString(), is("F")); + assertThat(new Type("D").toString(), is("D")); + assertThat(new Type("LFoo;").toString(), is("LFoo;")); + assertThat(new Type("[I").toString(), is("[I")); + assertThat(new Type("[[[I").toString(), is("[[[I")); + assertThat(new Type("[LFoo;").toString(), is("[LFoo;")); + assertThat(new Type("LFoo;").toString(), is("LFoo;")); + assertThat(new Type("LFoo;").toString(), is("LFoo;")); + assertThat(new Type("LFoo;>;").toString(), is("LFoo;")); + assertThat(new Type("TFoo;").toString(), is("TFoo;")); + } + + private ParameterizedType ptype(String name) { + return new ParameterizedType(new Type(name)); + } + + @Test + public void equalsWithParameters() { + assertThat(ptype("V"), is(ptype("V"))); + assertThat(ptype("Z"), is(ptype("Z"))); + assertThat(ptype("B"), is(ptype("B"))); + assertThat(ptype("C"), is(ptype("C"))); + assertThat(ptype("I"), is(ptype("I"))); + assertThat(ptype("J"), is(ptype("J"))); + assertThat(ptype("F"), is(ptype("F"))); + assertThat(ptype("D"), is(ptype("D"))); + assertThat(ptype("LFoo;"), is(ptype("LFoo;"))); + assertThat(ptype("[I"), is(ptype("[I"))); + assertThat(ptype("[[[I"), is(ptype("[[[I"))); + assertThat(ptype("[LFoo;"), is(ptype("[LFoo;"))); + assertThat(ptype("LFoo;"), is(ptype("LFoo;"))); + assertThat(ptype("TFoo;"), is(ptype("TFoo;"))); + + assertThat(ptype("V"), is(not(ptype("I")))); + assertThat(ptype("I"), is(not(ptype("J")))); + assertThat(ptype("I"), is(not(ptype("LBar;")))); + assertThat(ptype("I"), is(not(ptype("[I")))); + assertThat(ptype("LFoo;"), is(not(ptype("LBar;")))); + assertThat(ptype("[I"), is(not(ptype("[Z")))); + assertThat(ptype("[[[I"), is(not(ptype("[I")))); + assertThat(ptype("[LFoo;"), is(not(ptype("[LBar;")))); + assertThat(ptype("LFoo;"), is(not(ptype("LFoo;")))); + assertThat(ptype("TFoo;"), is(not(ptype("TBar;")))); + } + + @Test + public void testToStringWithParams() { + assertThat(ptype("V").toString(), is("V")); + assertThat(ptype("Z").toString(), is("Z")); + assertThat(ptype("B").toString(), is("B")); + assertThat(ptype("C").toString(), is("C")); + assertThat(ptype("I").toString(), is("I")); + assertThat(ptype("J").toString(), is("J")); + assertThat(ptype("F").toString(), is("F")); + assertThat(ptype("D").toString(), is("D")); + assertThat(ptype("LFoo;").toString(), is("LFoo;")); + assertThat(ptype("[I").toString(), is("[I")); + assertThat(ptype("[[[I").toString(), is("[[[I")); + assertThat(ptype("[LFoo;").toString(), is("[LFoo;")); + assertThat(ptype("LFoo;").toString(), is("LFoo;")); + assertThat(ptype("LFoo;").toString(), is("LFoo;")); + assertThat(ptype("LFoo;>;").toString(), is("LFoo;>;")); + assertThat(ptype("TFoo;").toString(), is("TFoo;")); } } diff --git a/test/cuchaz/enigma/resources/translation.mappings b/test/cuchaz/enigma/resources/translation.mappings index 55bd7e5c..db78c19d 100644 --- a/test/cuchaz/enigma/resources/translation.mappings +++ b/test/cuchaz/enigma/resources/translation.mappings @@ -29,4 +29,13 @@ CLASS none/g deobf/G_OuterClass CLASS none/g$b$a A_NamedInnerClass FIELD a f4 I CLASS none/h -CLASS none/i I_Generics +CLASS none/i deobf/I_Generics + CLASS none/i$a A_Type + CLASS none/i$b B_Generic + FIELD a f4 Ljava/lang/Object; + METHOD a m1 ()Ljava/lang/Object; + FIELD a f1 Ljava/util/List; + FIELD b f2 Ljava/util/List; + FIELD a f3 Ljava/util/Map; + FIELD a f5 Lnone/i$b; + FIELD b f6 Lnone/i$b; -- cgit v1.2.3