WIP: More work on Generics in Expansions

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

 						Arrays.asList(expression.member.getTarget().definition.typeParameters)
 				);
 
-				expression.member.getOwnerType().type.extractTypeParameters(parameters);
-				for (FunctionParameter parameter : expression.instancedHeader.parameters) {
-					parameter.type.type.extractTypeParameters(parameters);
+				//expression.member.getOwnerType().type.extractTypeParameters(parameters);
+				for (TypeParameter typeParameter : expression.instancedHeader.typeParameters) {
+					if(!parameters.contains(typeParameter)) {
+						parameters.add(typeParameter);
+					}
 				}
 				typeParameters = parameters.stream().distinct().collect(Collectors.toList());
 			}
 	public Void visitCast(CastExpression expression) {
 		expression.target.accept(this);
 
+		final ArrayList<TypeParameter> typeParameters = new ArrayList<>(Arrays.asList(expression.member.member.definition.typeParameters));
+		//expression.member.type.type.extractTypeParameters(typeParameters);
+		expression.member.toType.type.extractTypeParameters(typeParameters);
+
+		for (TypeParameter typeParameter : typeParameters) {
+			javaWriter.aConstNull(); //Todo: Replace with actual Type
+			javaWriter.checkCast("java/lang/Class");
+		}
+
 		BuiltinID builtin = expression.member.member.builtin;
 		if (builtin == null) {
 			if (!checkAndExecuteMethodInfo(expression.member, expression.type, expression))
 				final Method functionalInterfaceMethod = ((JavaFunctionalInterfaceStorageTag) actualStorage).functionalInterfaceMethod;
 				
 				//Should be the same, should it not?
-				signature = context.getMethodSignature(expression.header);
+				signature = context.getMethodSignature(expression.header, true);
 				descriptor = context.getMethodDescriptor(expression.header);
 				interfaces = new String[]{Type.getInternalName(functionalInterfaceMethod.getDeclaringClass())};
 			} else {
 				//Normal way, no casting to functional interface
-				signature = context.getMethodSignature(expression.header);
+				signature = context.getMethodSignature(expression.header, true);
 				descriptor = context.getMethodDescriptor(expression.header);
 				interfaces = new String[]{context.getInternalName(new FunctionTypeID(null, expression.header).stored(UniqueStorageTag.INSTANCE))};
 			}
 				}
 			}
 			
-			bridgeWriter.invokeVirtual(new JavaMethod(JavaClass.fromInternalName(className, JavaClass.Kind.CLASS), JavaMethod.Kind.INSTANCE, methodInfo.name, methodInfo.compile, signature, methodInfo.modifiers, methodInfo.genericResult));
+			bridgeWriter.invokeVirtual(new JavaMethod(JavaClass.fromInternalName(className, JavaClass.Kind.CLASS), JavaMethod.Kind.INSTANCE, methodInfo.name, methodInfo.compile, descriptor, methodInfo.modifiers, methodInfo.genericResult));
 			if(expression.header.getReturnType().type != BasicTypeID.VOID) {
 				bridgeWriter.returnType(context.getType(expression.header.getReturnType()));
 			}
 
 		//Make sure that method results are popped if ZC thinks its a void but it actually is not.
 		//Fixes an issue for List#add() returning void in ZC but Z in Java.
-		if(resultType.type == BasicTypeID.VOID && !methodInfo.descriptor.endsWith(")V")) {
-			final boolean isLarge = methodInfo.descriptor.endsWith(")D") && methodInfo.descriptor.endsWith(")L");
+		if(resultType.type == BasicTypeID.VOID && !methodInfo.descriptor.equals("") && !methodInfo.descriptor.endsWith(")V")) {
+			final boolean isLarge = methodInfo.descriptor.endsWith(")D") && methodInfo.descriptor.endsWith(")J");
 			getJavaWriter().pop(isLarge);
 		}
 
 
 	@Override
 	public Void copyTo(CallExpression call) {
+		//Copy this (source) to dest
+		//              source.copyTo(dest, sourceOffset, destOffset, length)
+		//=> System.arraycopy(source, sourceOffset, dest, destOffset, length);
+		javaWriter.dup2X2();
+		javaWriter.pop2();
+		javaWriter.swap();
+		javaWriter.dup2X2();
+		javaWriter.pop2();
+		final JavaClass system = JavaClass.fromInternalName("java/lang/System", JavaClass.Kind.CLASS);
+		final JavaMethod javaMethod = JavaMethod.getStatic(system, "arraycopy", "(Ljava/lang/Object;ILjava/lang/Object;II)V", JavaModifiers.PUBLIC);
+		javaWriter.invokeStatic(javaMethod);
 		return null;
 	}
 

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

 import org.openzen.zenscript.codemodel.expression.TryRethrowAsResultExpression;
 import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 	@Override
 	public Void visitSetter(SetterExpression expression) {
 		expression.target.accept(original);
+		for (TypeParameter typeParameter : expression.setter.member.definition.typeParameters) {
+			javaWriter.aConstNull(); //TODO replace with actual type
+			javaWriter.checkCast("java/lang/Class");
+		}
+
 		expression.value.accept(original);
 		original.checkAndExecuteMethodInfo(expression.setter, expression.type, expression);
 		return null;

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

 		
 		visitor.visitInsn(large ? POP2 : POP);
 	}
+
+	public void pop2() {
+		if(debug)
+			System.out.println("pop2");
+
+		visitor.visitInsn(POP2);
+	}
 	
 	public void dup() {
 		if (debug)

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

 import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.JavaField;
 import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaParameterInfo;
 
 import java.util.ArrayList;
 import java.util.stream.Collectors;
 
 		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("<");
+			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;");
+				}
 
-			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();
 			}
 
-			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);
+			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();
 
 	@Override
 	public Void visitSetter(SetterMember member) {
+		final boolean isStatic = member.isStatic();
+		final StoredType setterType = member.parameter.type;
+
+		final ArrayList<TypeParameter> typeParameters = new ArrayList<>();
+		expandedClass.type.extractTypeParameters(typeParameters);
+		CompilerUtils.tagMethodParameters(context, javaModule, member.getHeader(), isStatic, typeParameters);
+		setterType.type.extractTypeParameters(typeParameters);
+
+
+		final String signature = context.getMethodSignatureExpansion(member.getHeader(), expandedClass);
+		final String description = context.getMethodDescriptorExpansion(member.getHeader(), expandedClass);
+
+		final Label methodStart = new Label();
+		final Label methodEnd = new Label();
+
+		final JavaMethod javaMethod = context.getJavaMethod(member);
+		final JavaWriter methodWriter = new JavaWriter(member.position, writer, true, javaMethod, member.definition, true, signature, description, 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);
+			i++;
+		}
+
+		//in script you use $ but the parameter is named "value", which to choose?
+		//final String name = member.parameter.name;
+		final String name = "$";
+		methodWriter.nameVariable(i, name, methodStart, methodEnd, context.getType(setterType));
+		methodWriter.nameParameter(0, name);
+
+		javaModule.setParameterInfo(member.parameter, new JavaParameterInfo(i, context.getDescriptor(setterType)));
+
+		final JavaStatementVisitor javaStatementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);
+		javaStatementVisitor.start();
+		member.body.accept(javaStatementVisitor);
+		javaStatementVisitor.end();
+		methodWriter.label(methodEnd);
+
 		return null;
 	}
 
 	@Override
 	public Void visitOperator(OperatorMember member) {
-		return null;
+		final JavaMethod javaMethod = context.getJavaMethod(member);
+		final MethodMember methodMember = new MethodMember(member.position, member.definition, member.getEffectiveModifiers(), javaMethod.name, member.header, member.builtin);
+		methodMember.body = member.body;
+		methodMember.annotations = member.annotations;
+		javaModule.setMethodInfo(methodMember, javaMethod);
+
+		return methodMember.accept(this);
 	}
 
 	@Override
 	public Void visitCaster(CasterMember member) {
+
+		final ArrayList<TypeParameter> typeParameters = new ArrayList<>();
+		expandedClass.type.extractTypeParameters(typeParameters);
+
+		CompilerUtils.tagMethodParameters(context, javaModule, member.getHeader(), false, typeParameters);
+		member.toType.type.extractTypeParameters(typeParameters);
+
+		final String methodSignature = context.getMethodSignatureExpansion(member.getHeader(), expandedClass);
+		final String methodDescriptor = context.getMethodDescriptorExpansion(member.getHeader(), expandedClass);
+
+		final Label methodStart = new Label();
+		final Label methodEnd = new Label();
+
+		final JavaMethod javaMethod = context.getJavaMethod(member);
+		final JavaWriter methodWriter = new JavaWriter(member.position, writer, true, javaMethod, member.definition, true, methodSignature, methodDescriptor, new String[0]);
+
+		methodWriter.label(methodStart);
+		methodWriter.nameVariable(0, "expandedObj", methodStart, methodEnd, context.getType(this.expandedClass));
+		methodWriter.nameParameter(0, "expandedObj");
+
+		int i = 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 javaStatementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);
+		javaStatementVisitor.start();
+		member.body.accept(javaStatementVisitor);
+		javaStatementVisitor.end();
+		methodWriter.label(methodEnd);
 		return null;
 	}
 
 
 	@Override
 	public Void visitCaller(CallerMember member) {
-		return null;
+		//It's gonna be a method anyways, so why not reuse the code ^^
+		final JavaMethod javaMethod = context.getJavaMethod(member);
+		final MethodMember call = new MethodMember(member.position, member.definition, member.getEffectiveModifiers(), javaMethod.name, member.header, member.builtin);
+		call.body = member.body;
+		call.annotations = member.annotations;
+
+		javaModule.setMethodInfo(call, javaMethod);
+		return call.accept(this);
 	}
 
 	@Override

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

 
 		return getMethodDescriptor(header, false, startBuilder.toString());
 	}
+
+	public String getMethodSignatureExpansion(FunctionHeader header, StoredType expandedClass) {
+		return new JavaTypeGenericVisitor(this).getMethodSignatureExpansion(header, expandedClass);
+	}
 	
     public String getMethodSignature(FunctionHeader header) {
         return getMethodSignature(header, true);

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

 import org.openzen.zenscript.codemodel.type.*;
 import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 
 	public String visitOptional(StoredType context, OptionalTypeID type) {
 		return type.baseType.accept(context, this);
 	}
+
+	public String getMethodSignatureExpansion(FunctionHeader header, StoredType expandedClass) {
+		final StringBuilder stringBuilder = new StringBuilder();
+		final ArrayList<TypeParameter> typeParameters = new ArrayList<>();
+		expandedClass.type.extractTypeParameters(typeParameters);
+		for (TypeParameter typeParameter : header.typeParameters) {
+			if(!typeParameters.contains(typeParameter)){
+				typeParameters.add(typeParameter);
+			}
+		}
+
+		if(typeParameters.size() != 0) {
+			stringBuilder.append("<");
+			for (TypeParameter typeParameter : typeParameters) {
+				stringBuilder.append(typeParameter.name);
+				stringBuilder.append(":Ljava/lang/Object;");
+			}
+			stringBuilder.append(">");
+		}
+		stringBuilder.append("(");
+		stringBuilder.append(context.getSignature(expandedClass));
+		for (TypeParameter typeParameter : typeParameters) {
+			stringBuilder.append("Ljava/lang/Class<T");
+			stringBuilder.append(typeParameter.name);
+			stringBuilder.append(";>;");
+		}
+		stringBuilder.append(getGenericSignature(header.parameters));
+		stringBuilder.append(")");
+		stringBuilder.append(context.getSignature(header.getReturnType()));
+
+		return stringBuilder.toString();
+	}
 }