More work on generics

This time for nonexpansions.
The method signatures should be calculated correctly now, though they are still only filled with nulls

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

 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.javashared.JavaField;
 import org.openzen.zenscript.javashared.JavaParameterInfo;
 
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
     }
 
     public static void tagConstructorParameters(JavaBytecodeContext context, JavaCompiledModule module, HighLevelDefinition definition, FunctionHeader header, boolean isEnum) {
+		int index = 1;
+		for (TypeParameter typeParameter : definition.typeParameters) {
+			final JavaField field = new JavaField(context.getJavaClass(definition),
+					"typeOf" + typeParameter.name,
+					"Ljava/lang/Class;",
+					//"Ljava/lang/Class;"
+					"Ljava/lang/Class<T" + typeParameter.name + ";>;"
+			);
+			final JavaTypeParameterInfo info = new JavaTypeParameterInfo(index, field);
+			module.setTypeParameterInfo(typeParameter, info);
+			index++;
+		}
+
+		for (int i = 0; i < header.typeParameters.length; i++) {
+			TypeParameter typeParameter = header.typeParameters[i];
+			final JavaField field = new JavaField(context.getJavaClass(definition),
+					"typeOf" + typeParameter.name,
+					"Ljava/lang/Class;",
+					//"Ljava/lang/Class;"
+					"Ljava/lang/Class<T" + typeParameter.name + ";>;"
+					);
+			final JavaTypeParameterInfo info = new JavaTypeParameterInfo(index, field);
+			module.setTypeParameterInfo(typeParameter, info);
+			index++;
+		}
+		for (int i = 0; i < header.parameters.length; i++) {
+			FunctionParameter parameter = header.parameters[i];
+			String parameterType = context.getDescriptor(parameter.type);
+			module.setParameterInfo(parameter, new JavaParameterInfo(index, parameterType));
+			index++;
+		}
+		/*
 		int index = header.getNumberOfTypeParameters();
 		for (int i = 0; i < definition.typeParameters.length; i++) {
 			JavaTypeParameterInfo info = module.getTypeParameterInfo(definition.typeParameters[i]);
             String parameterType = context.getDescriptor(parameter.type);
 			module.setParameterInfo(parameter, new JavaParameterInfo(isEnum ? i + 3 : i + 1, parameterType));
         }
+		 */
     }
 
     public static void writeDefaultFieldInitializers(JavaBytecodeContext context, JavaWriter constructorWriter, HighLevelDefinition definition, boolean staticFields) {

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

 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.annotations.NativeTag;
 import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 			final List<TypeParameter> typeParameters;
 			{
-				final List<TypeParameter> parameters = new ArrayList<>(
-						Arrays.asList(expression.member.getTarget().definition.typeParameters)
-				);
+
+				final List<TypeParameter> parameters = new ArrayList<>();
+				if(expression.member.getTarget().definition.isExpansion()) {
+					parameters.addAll(Arrays.asList(expression.member.getTarget().definition.typeParameters));
+				}
 
 				//expression.member.getOwnerType().type.extractTypeParameters(parameters);
-				for (TypeParameter typeParameter : expression.instancedHeader.typeParameters) {
+				//expression.instancedHeader.typeParameters
+				for (TypeParameter typeParameter : expression.member.getTarget().getHeader().typeParameters) {
 					if(!parameters.contains(typeParameter)) {
 						parameters.add(typeParameter);
 					}
 			if(methodInfo.compile) {
 				for (TypeParameter typeParameter : typeParameters) {
 					javaWriter.aConstNull(); // TODO: Replace with actual class
+					javaWriter.checkCast("java/lang/Class");
 				}
 			}
 
 		//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");
+		if (expression.member.member.definition.isExpansion()) {
+			for (TypeParameter typeParameter : typeParameters) {
+				javaWriter.aConstNull(); //Todo: Replace with actual Type
+				javaWriter.checkCast("java/lang/Class");
+			}
 		}
 
 		BuiltinID builtin = expression.member.member.builtin;
 	public Void visitGetField(GetFieldExpression expression) {
 		expression.target.accept(this);
 		getField(expression.field);
+		javaWriter.checkCast(context.getType(expression.field.getType()));
 		return null;
 	}
 
 		if (builtin == null) {
 			if (context.hasJavaField(expression.getter)) {
 				javaWriter.getField(context.getJavaField(expression.getter));
+				javaWriter.checkCast(context.getType(expression.getter.getType()));
 				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(expression.getter.member.definition.isExpansion()) {
+				for (TypeParameter typeParameter : typeParameters) {
+					javaWriter.aConstNull(); //TODO: Replace with actual type
+					javaWriter.checkCast("java/lang/Class");
+				}
 			}
 
 			if (!checkAndExecuteMethodInfo(expression.getter, expression.type, expression))
 				throw new IllegalStateException("Call target has no method info!");
 
+			javaWriter.checkCast(context.getType(expression.getter.getType()));
 			return null;
 		}
 
 		javaWriter.newObject(method.cls);
 		javaWriter.dup();
 
+
+		if(!expression.constructor.getTarget().hasTag(NativeTag.class)) {
+			for (StoredType typeArgument : expression.type.asDefinition().typeArguments) {
+				javaWriter.aConstNull();
+				javaWriter.checkCast("java/lang/Class");
+			}
+		}
+
+
 		for (Expression argument : expression.arguments.arguments) {
 			argument.accept(this);
 		}

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

 	@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");
+
+		if (expression.setter.member.definition.isExpansion()) {
+			for (TypeParameter typeParameter : expression.setter.member.definition.typeParameters) {
+				javaWriter.aConstNull(); //TODO replace with actual type
+				javaWriter.checkCast("java/lang/Class");
+			}
 		}
 
 		expression.value.accept(original);

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

 			String[] exceptions,
 			String... annotations) {
 		this(position, visitor, nameVariables, method, forDefinition, false, signature, method.descriptor, exceptions, annotations);
+		this.position(position.fromLine);
 	}
 	
 	

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

 			if (member instanceof ImplementationMember)
 				interfaces.add(context.getInternalName(((ImplementationMember) member).type));
 		}
-        String signature = null;
+        String signature;
+
+		{
+			final StringBuilder signatureBuilder = new StringBuilder();
+			if(definition.typeParameters.length != 0) {
+				signatureBuilder.append("<");
+				for (TypeParameter typeParameter : definition.typeParameters) {
+					signatureBuilder.append(typeParameter.name);
+					signatureBuilder.append(":");
+					signatureBuilder.append("Ljava/lang/Object;");
+				}
+				signatureBuilder.append(">");
+			}
+
+			signatureBuilder.append("L").append(superTypeInternalName).append(";");
+			for (IDefinitionMember member : definition.members) {
+				if(member instanceof ImplementationMember) {
+					signatureBuilder.append(context.getInternalName(((ImplementationMember) member).type));
+				}
+			}
+
+			signature = signatureBuilder.toString();
+		}
 
         writer.visit(Opcodes.V1_8, definition.modifiers, toClass.internalName, signature, superTypeInternalName, interfaces.toArray(new String[0]));
+		for (TypeParameter typeParameter : definition.typeParameters) {
+			//Add it to the class
+			writer.visitField(
+					Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL,
+					"typeOf" + typeParameter.name,
+					"Ljava/lang/Class;",
+					"Ljava/lang/Class<T" + typeParameter.name + ";>;",
+					//"Ljava/lang/Class;",
+					null
+			);
+		}
+
 		JavaMemberVisitor memberVisitor = new JavaMemberVisitor(context, writer, toClass, definition);
         for (IDefinitionMember member : definition.members) {
             member.accept(memberVisitor);

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

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.annotations.NativeTag;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
+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.compiler.*;
 
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
-import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javashared.JavaCompiledModule;
-import org.openzen.zenscript.javashared.JavaField;
-import org.openzen.zenscript.javashared.JavaImplementation;
-import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.*;
 
 public class JavaMemberVisitor implements MemberVisitor<Void> {
     private final ClassWriter writer;
         final JavaWriter constructorWriter = new JavaWriter(member.position, writer, method, definition, context.getMethodSignature(member.header), null);
         constructorWriter.label(constructorStart);
         CompilerUtils.tagConstructorParameters(context, javaModule, member.definition, member.header, isEnum);
+        if(isEnum) {
+			constructorWriter.nameParameter(0, "name");
+			constructorWriter.nameParameter(0, "index");
+		}
+
+		for (TypeParameter typeParameter : definition.typeParameters) {
+			constructorWriter.nameParameter(0, "typeof" + typeParameter.name);
+			constructorWriter.nameVariable(
+					javaModule.getTypeParameterInfo(typeParameter).parameterIndex,
+					"typeOf" + typeParameter.name,
+					constructorStart,
+					constructorEnd,
+					Type.getType(Class.class)
+			);
+		}
+
         for (FunctionParameter parameter : member.header.parameters) {
             constructorWriter.nameVariable(
                     javaModule.getParameterInfo(parameter).index,
 			}
         }
 
+		for (TypeParameter typeParameter : definition.typeParameters) {
+			final JavaTypeParameterInfo typeParameterInfo = javaModule.getTypeParameterInfo(typeParameter);
+			final JavaField field = typeParameterInfo.field;
+
+			//Init from Constructor
+			final int parameterIndex = typeParameterInfo.parameterIndex;
+			constructorWriter.loadObject(0);
+			constructorWriter.loadObject(parameterIndex);
+			constructorWriter.putField(field);
+		}
+
 		if (member.body != null) {
 			member.body.accept(statementVisitor);
 		}
 
 	@Override
 	public Void visitGetter(GetterMember member) {
+		if (member.hasTag(NativeTag.class)) {
+			return null;
+		}
+
+		final String descriptor = context.getMethodDescriptor(member.getHeader());
+		final String signature = context.getMethodSignature(member.getHeader(), true);
+
+		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, false, signature, descriptor, new String[0]);
+
+		methodWriter.label(methodStart);
+		final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);
+		statementVisitor.start();
+		member.body.accept(statementVisitor);
+		methodWriter.label(methodEnd);
+		statementVisitor.end();
+
 		return null;
 	}
 
 	@Override
 	public Void visitSetter(SetterMember member) {
+		final String signature = context.getMethodSignature(member.getHeader());
+		final String description = context.getMethodDescriptor(member.getHeader());
+
+		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, false, signature, description, new String[0]);
+		methodWriter.label(methodStart);
+
+		//in script you use $ but the parameter is named "value", which to choose?
+		//final String name = member.parameter.name;
+		final String name = "$";
+		methodWriter.nameVariable(1, name, methodStart, methodEnd, context.getType(member.getType()));
+		methodWriter.nameParameter(0, name);
+
+		javaModule.setParameterInfo(member.parameter, new JavaParameterInfo(1, context.getDescriptor(member.getType())));
+
+		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 JavaMethod javaMethod = context.getJavaMethod(member);
+		if(javaMethod == null || !javaMethod.compile) {
+			return null;
+		}
+
+		final ArrayList<TypeParameter> typeParameters = new ArrayList<>(Arrays.asList(this.definition.typeParameters));
+
+		CompilerUtils.tagMethodParameters(context, javaModule, member.getHeader(), false, typeParameters);
+		member.toType.type.extractTypeParameters(typeParameters);
+
+		final String methodSignature = context.getMethodSignature(member.getHeader());
+		final String methodDescriptor = context.getMethodDescriptor(member.getHeader());
+
+		final Label methodStart = new Label();
+		final Label methodEnd = new Label();
+
+
+		final JavaWriter methodWriter = new JavaWriter(member.position, writer, true, javaMethod, member.definition, false, methodSignature, methodDescriptor, new String[0]);
+
+		methodWriter.label(methodStart);
+
+		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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.member.DefinitionMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 	 *                        Can be null or an empty string if this is not an expansion method header
 	 * @return Method descriptor {@code (<LClass;*No.TypeParameters><LString;I if enum><expandedType><headerTypes>)<retType> }
 	 */
-	private String getMethodDescriptor(FunctionHeader header, boolean isEnumConstructor, String expandedType) {
+	public String getMethodDescriptor(FunctionHeader header, boolean isEnumConstructor, String expandedType) {
         StringBuilder descBuilder = new StringBuilder("(");
 		for (int i = 0; i < header.getNumberOfTypeParameters(); i++)
 			descBuilder.append("Ljava/lang/Class;");
         descBuilder.append(getDescriptor(header.getReturnType()));
         return descBuilder.toString();
     }
+
+	public String getMethodDescriptorConstructor(FunctionHeader header, DefinitionMember member) {
+		StringBuilder startBuilder = new StringBuilder();
+		for (TypeParameter typeParameter : member.definition.typeParameters) {
+			startBuilder.append("Ljava/lang/Class;");
+		}
+		return getMethodDescriptor(header, member.definition instanceof EnumDefinition, startBuilder.toString());
+	}
 }

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

 		this.parameterIndex = -1;
 		this.field = field;
 	}
+
+	public JavaTypeParameterInfo(int parameterIndex, JavaField field) {
+		this.parameterIndex = parameterIndex;
+		this.field = field;
+	}
 }

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareClassMethodVisitor.java

 					header.getReturnType().type instanceof GenericTypeID,
 					header.useTypeParameters());
 		} else if (method == null) {
-			method = new JavaMethod(
-					cls,
-					getKind(member),
-					name,
-					true,
-					context.getMethodDescriptor(header),
-					modifiers | JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
-					header.getReturnType().type instanceof GenericTypeID,
-					header.useTypeParameters());
+			if(member instanceof ConstructorMember) {
+				method = new JavaMethod(
+						cls,
+						getKind(member),
+						name,
+						true,
+						context.getMethodDescriptorConstructor(header, member),
+						modifiers | JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
+						false,
+						header.useTypeParameters()
+				);
+			} else {
+				method = new JavaMethod(
+						cls,
+						getKind(member),
+						name,
+						true,
+						context.getMethodDescriptor(header),
+						modifiers | JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
+						header.getReturnType().type instanceof GenericTypeID,
+						header.useTypeParameters());
+			}
 		}
 		
 		if (method.compile && member.getBuiltin() != BuiltinID.CLASS_DEFAULT_CONSTRUCTOR) {

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareExpansionMethodVisitor.java

 		if (nativeTag != null && nativeClass != null)
 			method = nativeClass.getMethod(nativeTag.value);
 		if (method == null) {
-			final JavaMethod.Kind kind = getKind(member);
-			final String descriptor;
-			if (kind == JavaMethod.Kind.EXPANSION && member.definition instanceof ExpansionDefinition) {
-				descriptor = context.getMethodDescriptorExpansion(header, ((ExpansionDefinition) member.definition).target);
+
+			if(member instanceof ConstructorMember) {
+				method = new JavaMethod(
+						cls,
+						getKind(member),
+						name,
+						true,
+						context.getMethodDescriptorConstructor(header, member),
+						JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
+						false,
+						header.useTypeParameters()
+				);
 			} else {
-				descriptor = context.getMethodDescriptor(header);
+				final JavaMethod.Kind kind = getKind(member);
+				final String descriptor;
+				if (kind == JavaMethod.Kind.EXPANSION && member.definition instanceof ExpansionDefinition) {
+					descriptor = context.getMethodDescriptorExpansion(header, ((ExpansionDefinition) member.definition).target);
+				} else {
+					descriptor = context.getMethodDescriptor(header);
+				}
+				method = new JavaMethod(
+						cls,
+						kind,
+						name,
+						true,
+						descriptor,
+						JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
+						header.getReturnType().type instanceof GenericTypeID,
+						header.useTypeParameters());
 			}
-			method = new JavaMethod(
-					cls,
-					kind,
-					name,
-					true,
-					descriptor,
-					JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
-					header.getReturnType().type instanceof GenericTypeID,
-					header.useTypeParameters());
 		}
 		
 		if (method.compile) {