Fix annotation scanning argument object types (#76)

* Fix annotation scanning argument object wrappers

* rename

* Renames and minor changes

* Minor rename

Author: qouteall

patchwork-fml/src/main/java/net/minecraftforge/fml/loading/moddiscovery/ModAnnotation.java

@@ -0,0 +1,123 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package net.minecraftforge.fml.loading.moddiscovery;
+
+import java.lang.annotation.ElementType;
+import java.util.ArrayList;
+import java.util.Map;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import net.minecraftforge.forgespi.language.ModFileScanData;
+import org.objectweb.asm.Type;
+
+public class ModAnnotation {
+	private final ElementType type;
+	private final Type asmType;
+	private final String member;
+	private final Map<String, Object> elements;
+	private ArrayList<Object> arrayList;
+	private String arrayName;
+
+	public static ModFileScanData.AnnotationData fromModAnnotation(Type clazz, ModAnnotation annotation) {
+		return new ModFileScanData.AnnotationData(
+				annotation.asmType, annotation.type, clazz, annotation.member, annotation.elements
+		);
+	}
+
+	public ModAnnotation(ElementType type, Type asmType, String member) {
+		this.elements = Maps.newHashMap();
+		this.type = type;
+		this.asmType = asmType;
+		this.member = member;
+	}
+
+	public ModAnnotation(Type asmType, ModAnnotation parent) {
+		this.elements = Maps.newHashMap();
+		this.type = parent.type;
+		this.asmType = asmType;
+		this.member = parent.member;
+	}
+
+	public String toString() {
+		return MoreObjects.toStringHelper("Annotation")
+				.add("type", this.type).add("name", this.asmType.getClassName())
+				.add("member", this.member).add("values", this.elements).toString();
+	}
+
+	public ElementType getType() {
+		return this.type;
+	}
+
+	public String getMember() {
+		return this.member;
+	}
+
+	public Map<String, Object> getValues() {
+		return this.elements;
+	}
+
+	public void addArray(String name) {
+		this.arrayList = Lists.newArrayList();
+		this.arrayName = name;
+	}
+
+	public void addProperty(String key, Object value) {
+		if (this.arrayList != null) {
+			this.arrayList.add(value);
+		} else {
+			this.elements.put(key, value);
+		}
+	}
+
+	public void addEnumProperty(String key, String enumName, String value) {
+		this.addProperty(key, new ModAnnotation.EnumHolder(enumName, value));
+	}
+
+	public void endArray() {
+		this.elements.put(this.arrayName, this.arrayList);
+		this.arrayList = null;
+	}
+
+	public ModAnnotation addChildAnnotation(String name, String desc) {
+		ModAnnotation child = new ModAnnotation(Type.getType(desc), this);
+		this.addProperty(name, child.getValues());
+		return child;
+	}
+
+	public static class EnumHolder {
+		private final String desc;
+		private final String value;
+
+		public EnumHolder(String desc, String value) {
+			this.desc = desc;
+			this.value = value;
+		}
+
+		public String getDesc() {
+			return this.desc;
+		}
+
+		public String getValue() {
+			return this.value;
+		}
+	}
+}

patchwork-fml/src/main/java/net/minecraftforge/forgespi/language/ModFileScanData.java

@@ -35,6 +35,7 @@
 import java.util.stream.Collectors;
 
 import com.google.gson.Gson;
+import net.minecraftforge.fml.loading.moddiscovery.ModAnnotation;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.objectweb.asm.Type;
@@ -110,8 +111,7 @@ public static class AnnotationData {
 		private final Type clazz;
 		private final String memberName;
 
-		//lazy evaluated
-		private Map<String, Object> annotationData;
+		private Map<String, Object> elements;
 
 		public AnnotationData(
 				final Type annotationType, final ElementType targetType,
@@ -123,6 +123,17 @@ public AnnotationData(
 			this.memberName = memberName;
 		}
 
+		public AnnotationData(
+				Type annotationType, ElementType targetType, Type clazz,
+				String memberName, Map<String, Object> elements
+		) {
+			this.annotationType = annotationType;
+			this.targetType = targetType;
+			this.clazz = clazz;
+			this.memberName = memberName;
+			this.elements = elements;
+		}
+
 		public Type getAnnotationType() {
 			return annotationType;
 		}
@@ -140,15 +151,15 @@ public String getMemberName() {
 		}
 
 		public Map<String, Object> getAnnotationData() {
-			if (annotationData == null) {
+			if (elements == null) {
 				initAnnotationData();
 			}
 
-			return annotationData;
+			return elements;
 		}
 
 		private void initAnnotationData() {
-			annotationData = new HashMap<>();
+			elements = new HashMap<>();
 
 			try {
 				// TODO: This *may* load classes in the wrong order, but it shouldn't be an issue
@@ -163,22 +174,21 @@ private void initAnnotationData() {
 					return;
 				}
 
-				Method[] argMethods = annotationObject.getClass().getDeclaredMethods();
+				Method[] elementGetters = annotationObject.getClass().getDeclaredMethods();
 
-				for (Method argMethod : argMethods) {
-					if (isArgumentMethod(argMethod)) {
-						annotationData.put(
-								argMethod.getName(),
-								argMethod.invoke(annotationObject)
-						);
+				for (Method elementGetter : elementGetters) {
+					if (isElementGetter(elementGetter)) {
+						Object value = elementGetter.invoke(annotationObject);
+
+						elements.put(elementGetter.getName(), processElementObject(value));
 					}
 				}
 			} catch (Throwable e) {
 				LOGGER.catching(e);
 			}
 		}
 
-		private static boolean isArgumentMethod(Method method) {
+		private static boolean isElementGetter(Method method) {
 			String name = method.getName();
 			if (name.equals("toString")) return false;
 			if (name.equals("hashCode")) return false;
@@ -199,15 +209,14 @@ private Annotation getAnnotationObject(Class<?> clazzObj, Class annotationType)
 			case METHOD:
 				String methodName = memberName.substring(0, memberName.indexOf('('));
 				Method[] methods = Arrays.stream(clazzObj.getDeclaredMethods())
-					.filter(method -> method.getName().equals(methodName))
-					.toArray(Method[]::new);
+						.filter(method -> method.getName().equals(methodName))
+						.toArray(Method[]::new);
 				if (methods.length == 0) {
 					throw new RuntimeException("Cannot find method " + methodName);
 				}
 
 				if (methods.length > 1) {
 					//TODO handle overloaded methods
-
 					throw new RuntimeException("Currently Cannot Handle Overloaded Methods");
 				}
 
@@ -235,4 +244,23 @@ public int hashCode() {
 			return Objects.hash(annotationType, targetType, clazz, memberName);
 		}
 	}
+
+	private static Object processElementObject(Object object) {
+		if (object instanceof Object[]) {
+			return Arrays.stream((Object[]) object)
+					.map(ModFileScanData::processElementObject)
+					.collect(Collectors.toList());
+		}
+
+		if (object instanceof Enum) {
+			Enum enumObject = (Enum) object;
+			String className = enumObject.getDeclaringClass().getName();
+			return new ModAnnotation.EnumHolder(
+					className.replace('.', '/'),
+					enumObject.toString()
+			);
+		}
+
+		return object;
+	}
 }