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/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 +++++++++++++++++++-----
 6 files changed, 143 insertions(+), 28 deletions(-)
 create mode 100644 src/cuchaz/enigma/mapping/ParameterizedType.java

(limited to 'src/cuchaz/enigma/mapping')

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++) {
-- 
cgit v1.2.3