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;
 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) {
-		int index = header.getNumberOfTypeParameters();
+    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++));
+			module.setTypeParameterInfo(parameter, new JavaTypeParameterInfo(index));
+			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(isStatic ? index : index + 1, parameterType));
+            module.setParameterInfo(parameter, new JavaParameterInfo(index, parameterType));
 			index++;
         }
     }
 
     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;
 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<>();
+				if(expression.member.getTarget().definition.isExpansion()) {
+					parameters.addAll(Arrays.asList(expression.member.getTarget().definition.typeParameters));
+				}
+
+				//expression.member.getOwnerType().type.extractTypeParameters(parameters);
+				//expression.instancedHeader.typeParameters
+				for (TypeParameter typeParameter : expression.member.getTarget().getHeader().typeParameters) {
+					if(!parameters.contains(typeParameter)) {
+						parameters.add(typeParameter);
+					}
+				}
+				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
+					javaWriter.checkCast("java/lang/Class");
 				}
 			}
 
 	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);
+
+		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;
 		if (builtin == null) {
 			if (!checkAndExecuteMethodInfo(expression.member, expression.type, expression))
 
 	@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);
 				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()));
 			}
 	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);
+
+			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);
 		}
 								}
 								
 								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));
 									
 
 		//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);
+
+		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);
 		original.checkAndExecuteMethodInfo(expression.setter, expression.type, expression);
 		return null;

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);
 	}
 	
 	
 		this.method = method;
 		this.forDefinition = forDefinition;
 		this.position = position;
-		
-		final MethodVisitor methodVisitor = visitor.visitMethod(isExtension ? method.modifiers | Opcodes.ACC_STATIC : method.modifiers, method.name, descriptor, signature, exceptions);
+
+		final int access = isExtension ? method.modifiers | ACC_STATIC : method.modifiers;
+		final MethodVisitor methodVisitor = visitor.visitMethod(access, method.name, descriptor, signature, exceptions);
 		
 		for (String annotation : annotations) {
 			methodVisitor.visitAnnotation(annotation, true).visitEnd();
 		}
 		
-		this.visitor = new LocalVariablesSorter(isExtension ? method.modifiers | Opcodes.ACC_STATIC : method.modifiers, descriptor, methodVisitor);
+		this.visitor = new LocalVariablesSorter(access, descriptor, methodVisitor);
 		this.nameVariables = nameVariables;
 	}
 	
 		
 		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/JavaDefinitionVisitor.java

 import org.openzen.zenscript.javashared.JavaVariantOption;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 
 			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);
 
 	@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.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;
 
 public class JavaExpansionMemberVisitor implements MemberVisitor<Void> {
 
 		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;
 	}
 
 	@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

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 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);
 
 	@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;
 	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 getMethodSignatureExpansion(FunctionHeader header, StoredType expandedClass) {
+		return new JavaTypeGenericVisitor(this).getMethodSignatureExpansion(header, expandedClass);
 	}
 	
     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, "");
 	 *                        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/JavaField.java

 	public final JavaClass cls;
 	public final String name;
 	public final String descriptor;
-	public final String signature = null; // TODO: calculate signature too
+	public final String signature; // TODO: calculate signature too
 	
 	public JavaField(JavaClass cls, String name, String descriptor) {
+		this(cls, name, descriptor, null);
+	}
+
+	public JavaField(JavaClass cls, String name, String descriptor, String signature) {
 		this.cls = cls;
 		this.name = name;
 		this.descriptor = descriptor;
+		this.signature = signature;
 	}
 	
 	public String getMapping(JavaClass definition) {

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.ArrayList;
+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
 	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();
+	}
 }

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

 			System.out.println("Class " + cls.fullName + " not empty because of const " + member.name);
 		
 		cls.empty = false;
-		module.setFieldInfo(member, new JavaField(cls, member.name, context.getDescriptor(member.getType())));
+		module.setFieldInfo(member, new JavaField(cls, member.name, context.getDescriptor(member.getType()), context.getSignature(member.getType())));
 		return null;
 	}
 	
 	@Override
 	public Void visitField(FieldMember member) {
-		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.getType()));
+		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.getType()), context.getSignature(member.getType()));
 		module.setFieldInfo(member, field);
 		if (member.hasAutoGetter()) {
 			visitGetter(member.autoGetter);
 					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

 	
 	@Override
 	public Void visitConst(ConstMember member) {
-		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.getType()));
+		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.getType()), context.getSignature(member.getType()));
 		module.setFieldInfo(member, field);
 		
 		if (DEBUG_EMPTY && cls.empty)
 	@Override
 	public Void visitField(FieldMember member) {
 		// TODO: expansion fields
-		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.getType()));
+		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.getType()), context.getSignature(member.getType()));
 		module.setFieldInfo(member, field);
 		
 		if (member.hasAutoGetter() || member.hasAutoSetter())
 		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) {