WIP: More work on generic parameters in expansions

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/CompilerUtils.java

 import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.JavaTypeParameterInfo;
 
+import java.util.List;
+
 public class CompilerUtils {
 
 	private CompilerUtils() {}
 		return out;
 	}
 
-    public static void tagMethodParameters(JavaBytecodeContext context, JavaCompiledModule module, FunctionHeader header, boolean isStatic) {
+    public static void tagMethodParameters(JavaBytecodeContext context, JavaCompiledModule module, FunctionHeader header, boolean isStatic, List<TypeParameter> baseTypeTypeParameters) {
 		int index = isStatic ? 0 : 1;
+
+		for (TypeParameter baseTypeTypeParameter : baseTypeTypeParameters) {
+			module.setTypeParameterInfo(baseTypeTypeParameter, new JavaTypeParameterInfo(index));
+			index++;
+		}
+
 		for (int i = 0; i < header.typeParameters.length; i++) {
 			TypeParameter parameter = header.typeParameters[i];
 			module.setTypeParameterInfo(parameter, new JavaTypeParameterInfo(index));

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaExpressionVisitor.java

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.Objects;
-import java.util.StringJoiner;
+import java.util.*;
+import java.util.stream.Collectors;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void>, JavaNativeTranslator<Void> {
     private static final JavaMethod OBJECTS_TOSTRING = JavaMethod.getNativeStatic(new JavaClass("java.util", "Objects", JavaClass.Kind.CLASS), "toString", "(Ljava/lang/Object;)Ljava/lang/String;");
 		if (builtin == null) {
 			expression.target.accept(this);
 
+			final List<TypeParameter> typeParameters;
+			{
+				final List<TypeParameter> parameters = new ArrayList<>(
+						Arrays.asList(expression.member.getTarget().definition.typeParameters)
+				);
+
+				expression.member.getOwnerType().type.extractTypeParameters(parameters);
+				for (FunctionParameter parameter : expression.instancedHeader.parameters) {
+					parameter.type.type.extractTypeParameters(parameters);
+				}
+				typeParameters = parameters.stream().distinct().collect(Collectors.toList());
+			}
+
 			JavaMethod methodInfo = context.getJavaMethod(expression.member);
-			for (int i = 0; i < expression.arguments.typeArguments.length; i++) {
-				if (methodInfo.typeParameterArguments[i]) {
-					StoredType arguments = expression.arguments.typeArguments[i];
 
+			if(methodInfo.compile) {
+				for (TypeParameter typeParameter : typeParameters) {
+					javaWriter.aConstNull(); // TODO: Replace with actual class
 				}
 			}
 
 
 	@Override
 	public Void visitFunction(FunctionExpression expression) {
-		CompilerUtils.tagMethodParameters(context, module, expression.header, false);
+		CompilerUtils.tagMethodParameters(context, module, expression.header, false, Collections.emptyList());
 
         /*if (expression.header.parameters.length == 0 && expression.body instanceof ReturnStatement && expression.body.hasTag(MatchExpression.class) && expression.closure.captures.isEmpty()) {
             ((ReturnStatement) expression.body).value.accept(this);
 				javaWriter.getField(context.getJavaField(expression.getter));
 				return null;
 			}
+
+
+			final List<TypeParameter> typeParameters = new ArrayList<>();
+			expression.getter.member.getType().type.extractTypeParameters(typeParameters);
+
+			for (TypeParameter typeParameter : typeParameters) {
+				javaWriter.aConstNull(); //TODO: Replace with actual type
+			}
+
 			if (!checkAndExecuteMethodInfo(expression.getter, expression.type, expression))
 				throw new IllegalStateException("Call target has no method info!");
 
 								}
 								
 								if (funcExpression instanceof FunctionExpression && ((FunctionExpression) funcExpression).body instanceof ReturnStatement) {
-									CompilerUtils.tagMethodParameters(context, module, ((FunctionExpression) funcExpression).header, false);
+									CompilerUtils.tagMethodParameters(context, module, ((FunctionExpression) funcExpression).header, false, Collections
+                                            .emptyList());
 									((ReturnStatement) ((FunctionExpression) funcExpression).body).value.accept(visitor);
 									javaWriter.addVariableInfo(new JavaLocalVariableInfo(projectedElementType, projectedElementLocal, inlineBegin, ((FunctionExpression) funcExpression).header.parameters[0].name, inlineEnd));
 									

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaDefinitionVisitor.java

 import org.openzen.zenscript.javashared.JavaVariantOption;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 
 
 	@Override
 	public byte[] visitFunction(FunctionDefinition definition) {
-		CompilerUtils.tagMethodParameters(context, context.getJavaModule(definition.module), definition.header, true);
+		CompilerUtils.tagMethodParameters(context, context.getJavaModule(definition.module), definition.header, true, Collections
+                .emptyList());
 
         final String signature = context.getMethodSignature(definition.header);
 		final JavaMethod method = context.getJavaMethod(definition.caller);

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaExpansionMemberVisitor.java

 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.*;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javashared.JavaField;
 import org.openzen.zenscript.javashared.JavaMethod;
 
+import java.util.ArrayList;
+import java.util.stream.Collectors;
+
 public class JavaExpansionMemberVisitor implements MemberVisitor<Void> {
 
 	private final ClassWriter writer;
 		if (!method.compile)
 			return null;
 
+		final ArrayList<TypeParameter> typeParameters = new ArrayList<>();
+		expandedClass.type.extractTypeParameters(typeParameters);
 
-		CompilerUtils.tagMethodParameters(context, javaModule, member.header, member.isStatic());
+		CompilerUtils.tagMethodParameters(context, javaModule, member.header, member.isStatic(), typeParameters);
 
 		final String expandedClassDescriptor = context.getDescriptor(expandedClass);
+		final String expandedClassSignature = context.getSignature(expandedClass);
 		final Label methodStart = new Label();
 		final Label methodEnd = new Label();
 		final String methodSignature;
+		final String methodDescriptor;
+
+
 
 		if (!isStatic) {
-			methodSignature = "(" + expandedClassDescriptor + context.getMethodSignature(member.header).substring(1);
+			String methodSignature1 = context.getMethodSignature(member.header);
+
+			//Add the expanded type as first generic parameter to the list.
+			if(!typeParameters.isEmpty()){
+				final String collect = typeParameters.stream()
+						.map(t -> t.name + ":" + "Ljava/lang/Object;")
+						.collect(Collectors.joining("", "<", ""));
+				if(methodSignature1.startsWith("<")) {
+					methodSignature1 = collect + methodSignature1.substring(1);
+				} else {
+					methodSignature1 = collect + ">" + methodSignature1;
+				}
+			}
+
+			final StringBuilder typeParamSigBuilder = new StringBuilder();
+			final StringBuilder typeParamDescBuilder = new StringBuilder();
+			int i = 1;
+			for (TypeParameter typeParameter : typeParameters) {
+				typeParamSigBuilder.append("Ljava/lang/Class<T").append(typeParameter.name).append(";>;");
+				typeParamDescBuilder.append("Ljava/lang/Class;");
+			}
+
+
+			final int index = methodSignature1.lastIndexOf('(') + 1;
+			methodSignature = methodSignature1.substring(0, index) + expandedClassSignature + typeParamSigBuilder.toString() + methodSignature1.substring(index);
+			methodDescriptor = "(" + expandedClassDescriptor + typeParamDescBuilder.toString() + context.getMethodDescriptor(member.header).substring(1);
 		} else {
 			methodSignature = context.getMethodSignature(member.header);
+			methodDescriptor = context.getMethodDescriptor(member.header);
 		}
 
 
-		final JavaWriter methodWriter = new JavaWriter(member.position, writer, true, method, definition, true, methodSignature, methodSignature, null);
+		final JavaWriter methodWriter = new JavaWriter(member.position, writer, true, method, definition, true, methodSignature, methodDescriptor, null);
 		methodWriter.label(methodStart);
 
 		if (!isStatic) {
 			methodWriter.nameVariable(0, "expandedObj", methodStart, methodEnd, Type.getType(expandedClassDescriptor));
 			methodWriter.nameParameter(0, "expandedObj");
-			for (final FunctionParameter parameter : member.header.parameters) {
-				methodWriter.nameParameter(0, parameter.name);
-				methodWriter.nameVariable(javaModule.getParameterInfo(parameter).index, parameter.name, methodStart, methodEnd, context.getType(parameter.type));
-			}
-		} else {
-			for (final FunctionParameter parameter : member.header.parameters) {
-				methodWriter.nameParameter(0, parameter.name);
-				methodWriter.nameVariable(javaModule.getParameterInfo(parameter).index, parameter.name, methodStart, methodEnd, context.getType(parameter.type));
+
+			for (TypeParameter typeParameter : typeParameters) {
+				methodWriter.nameParameter(0, "typeOf" + typeParameter.name);
+				methodWriter.nameVariable(javaModule.getTypeParameterInfo(typeParameter).parameterIndex, "typeOf" + typeParameter.name, methodStart, methodEnd, Type.getType(Class.class));
 			}
 		}
 
+		for (TypeParameter typeParameter : member.header.typeParameters) {
+			methodWriter.nameParameter(0, "typeOf" + typeParameter.name);
+			methodWriter.nameVariable(javaModule.getTypeParameterInfo(typeParameter).parameterIndex, "typeOf" + typeParameter.name, methodStart, methodEnd, Type.getType(Class.class));
+		}
+
+		for (final FunctionParameter parameter : member.header.parameters) {
+			methodWriter.nameParameter(0, parameter.name);
+			methodWriter.nameVariable(javaModule.getParameterInfo(parameter).index, parameter.name, methodStart, methodEnd, context.getType(parameter.type));
+		}
+
 
 		{
 			final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);
 
 	@Override
 	public Void visitGetter(GetterMember member) {
+		final boolean isStatic = member.isStatic();
+		final StoredType returnType = member.getType();
+		final String descriptor;
+		final String signature;
+
+		final ArrayList<TypeParameter> typeParameters = new ArrayList<>();
+		expandedClass.type.extractTypeParameters(typeParameters);
+
+		final String descMiddle, signatureMiddle, signatureStart;
+		if(typeParameters.isEmpty()) {
+			descMiddle = signatureMiddle = signatureStart = "";
+		} else {
+			final StringBuilder descMiddleBuilder = new StringBuilder();
+			final StringBuilder signatureMiddleBuilder = new StringBuilder();
+			final StringBuilder signatureStartBuilder = new StringBuilder("<");
+
+			for (TypeParameter typeParameter : typeParameters) {
+				descMiddleBuilder.append("Ljava/lang/Class;");
+				signatureMiddleBuilder.append("Ljava/lang/Class<T").append(typeParameter.name).append(";>;");
+				signatureStartBuilder.append(typeParameter.name).append(":Ljava/lang/Object;");
+			}
+
+			descMiddle = descMiddleBuilder.toString();
+			signatureMiddle = signatureMiddleBuilder.toString();
+			signatureStart = signatureStartBuilder.append(">").toString();
+		}
+
+		if (isStatic) {
+			descriptor = "(" + descMiddle + ")" + context.getDescriptor(returnType);
+			signature = signatureStart + "(" + signatureMiddle + ")" + context.getSignature(returnType);
+		} else {
+			descriptor = "(" + context.getDescriptor(expandedClass) + descMiddle + ")" + context.getDescriptor(returnType);
+			signature = signatureStart + "(" + context.getSignature(expandedClass) + signatureMiddle + ")" + context.getSignature(returnType);
+		}
+
+		final Label methodStart = new Label();
+		final Label methodEnd = new Label();
+
+		final JavaMethod method = context.getJavaMethod(member);
+		final JavaWriter methodWriter = new JavaWriter(member.position, this.writer, true, method, definition, true, signature, descriptor, new String[0]);
+
+		methodWriter.label(methodStart);
+
+		if (!isStatic) {
+			methodWriter.nameVariable(0, "expandedObj", methodStart, methodEnd, context.getType(this.expandedClass));
+			methodWriter.nameParameter(0, "expandedObj");
+		}
+
+		int i = isStatic ? 0 : 1;
+		for (TypeParameter typeParameter : typeParameters) {
+			final String name = "typeOf" + typeParameter.name;
+			methodWriter.nameVariable(i, name, methodStart, methodEnd, Type.getType(Class.class));
+			methodWriter.nameParameter(0, name);
+		}
+
+		{
+			final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);
+			statementVisitor.start();
+			member.body.accept(statementVisitor);
+			methodWriter.label(methodEnd);
+			statementVisitor.end();
+		}
+
 		return null;
 	}
 

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaMemberVisitor.java

 import org.openzen.zenscript.codemodel.member.*;
 import org.openzen.zenscript.javabytecode.compiler.*;
 
+import java.util.Collections;
 import java.util.List;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javashared.JavaClass;
 
     @Override
     public Void visitMethod(MethodMember member) {
-        CompilerUtils.tagMethodParameters(context, javaModule, member.header, member.isStatic());
+        CompilerUtils.tagMethodParameters(context, javaModule, member.header, member.isStatic(), Collections.emptyList());
 
         final boolean isAbstract = member.body == null || Modifiers.isAbstract(member.getEffectiveModifiers());
         final JavaMethod method = context.getJavaMethod(member);

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaContext.java

 	public abstract String getDescriptor(TypeID type);
 	
 	public abstract String getDescriptor(StoredType type);
-	
+
+	public String getSignature(StoredType type) {
+		return new JavaTypeGenericVisitor(this).getGenericSignature(type);
+	}
+
 	public void addModule(Module module, JavaCompiledModule target) {
 		modules.put(module, target);
 
 	}
 
 	public String getMethodDescriptorExpansion(FunctionHeader header, StoredType expandedType) {
-		return getMethodDescriptor(header, false, getDescriptor(expandedType));
+		StringBuilder startBuilder = new StringBuilder(getDescriptor(expandedType));
+		final List<TypeParameter> typeParameters = new ArrayList<>();
+		expandedType.type.extractTypeParameters(typeParameters);
+		for (TypeParameter typeParameter : typeParameters) {
+			startBuilder.append("Ljava/lang/Class;");
+		}
+
+		return getMethodDescriptor(header, false, startBuilder.toString());
 	}
 	
     public String getMethodSignature(FunctionHeader header) {
-        return new JavaTypeGenericVisitor(this).getGenericMethodSignature(header);
+        return getMethodSignature(header, true);
     }
+
+    public String getMethodSignature(FunctionHeader header, boolean withGenerics) {
+		return new JavaTypeGenericVisitor(this).getGenericMethodSignature(header, withGenerics);
+	}
 	
 	public String getEnumConstructorDescriptor(FunctionHeader header) {
 		return getMethodDescriptor(header, true, "");

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaTypeGenericVisitor.java

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.generic.*;
 import org.openzen.zenscript.codemodel.type.*;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
+import java.util.Arrays;
 import java.util.Collection;
 
 public class JavaTypeGenericVisitor implements TypeVisitorWithContext<StoredType, String, RuntimeException> {
 				getGenericSignature(header.getReturnType());
 	}
 
+	public String getGenericMethodSignature(FunctionHeader header, boolean addGenerics) {
+		final StringBuilder sb = new StringBuilder();
+		final boolean doGenerics = addGenerics && header.typeParameters.length > 0;
+
+		if(doGenerics) {
+			sb.append("<");
+			for (TypeParameter typeParameter : header.typeParameters) {
+				//TODO: Eventually replace with upper bound
+				sb.append(typeParameter.name).append(":").append("Ljava/lang/Object;");
+			}
+			sb.append(">");
+		}
+
+
+		sb.append("(");
+		if(doGenerics) {
+			for (TypeParameter typeParameter : header.typeParameters) {
+				//TODO: Eventually replace with -TT; or +TT; for "? super T" and "? extends T"
+				sb.append("Ljava/lang/Class<T").append(typeParameter.name).append(";>;");
+			}
+		}
+
+		sb.append(getGenericSignature(header.parameters));
+		sb.append(")");
+		sb.append(getGenericSignature(header.getReturnType()));
+		return sb.toString();
+	}
+
 
 	public String getGenericBounds(Collection<TypeParameterBound> collection) {
 		if (collection == null)
 
 	@Override
 	public String visitArray(StoredType context, ArrayTypeID array) {
-		return this.context.getDescriptor(array);
+		final char[] dim = new char[array.dimension];
+		Arrays.fill(dim, '[');
+		return new String(dim) + this.context.getSignature(array.elementType);
 	}
 
 	@Override
 	public String visitAssoc(StoredType context, AssocTypeID assoc) {
-		return this.context.getDescriptor(assoc);
+		return "Ljava/util/Map<"
+				+ assoc.keyType.type.accept(context, this)
+				+ assoc.valueType.type.accept(context, this)
+				+ ">;";
 	}
 
 	@Override
 
 	@Override
 	public String visitFunction(StoredType context, FunctionTypeID function) {
-		return this.context.getDescriptor(function);
+		final JavaSynthesizedFunctionInstance function1 = this.context.getFunction(function);
+		if(function1.typeArguments == null || function1.typeArguments.length == 0) {
+			return this.context.getDescriptor(function);
+		}
+
+		StringBuilder sb = new StringBuilder("L").append(function1.getCls().internalName).append("<");
+		for (TypeID typeArgument : function1.typeArguments) {
+			final String n = typeArgument instanceof GenericTypeID
+					? ((GenericTypeID) typeArgument).parameter.name
+					: "Ljava/lang/Object"; //Can latter even happen?
+
+			sb.append("T").append(n).append(";");
+		}
+
+		return sb.append(">;").toString();
 	}
 
 	@Override