Fixed results from generic methods not being cast to the right type. Also fixed some bugs related to variants and added the variant value creation syntax VariantName.Option(arguments).

CodeModel/src/main/java/org/openzen/zenscript/codemodel/FunctionHeader.java

 		return true;
 	}
 	
-	public FunctionHeader withGenericArguments(GenericMapper mapper) {
+	public FunctionHeader withGenericArguments(GlobalTypeRegistry registry, GenericMapper mapper) {
 		if (typeParameters.length > 0) {
 			Map<TypeParameter, ITypeID> innerMap = new HashMap<>();
 			for (TypeParameter parameter : typeParameters)
 				innerMap.put(parameter, mapper.registry.getGeneric(parameter));
 			
-			mapper = mapper.getInner(innerMap);
+			mapper = mapper.getInner(registry, innerMap);
 		}
 		
 		ITypeID returnType = this.returnType.instance(mapper);
 		Map<TypeParameter, ITypeID> typeArguments = new HashMap<>();
 		for (int i = 0; i < typeParameters.length; i++)
 			typeArguments.put(typeParameters[i], arguments[i]);
-		GenericMapper mapper = typeParameterMapping.getInner(typeArguments);
+		GenericMapper mapper = typeParameterMapping.getInner(registry, typeArguments);
 		
 		ITypeID returnType = this.returnType.instance(mapper);
 		FunctionParameter[] parameters = new FunctionParameter[this.parameters.length];
 				result.append(", ");
 			result.append(parameters[i].toString());
 		}
-		result.append(")");
+		result.append(") as ");
+		result.append(returnType.toString());
 		return result.toString();
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/GenericMapper.java

 	}
 	
 	public FunctionHeader map(FunctionHeader original) {
-		return mapping.isEmpty() ? original : original.withGenericArguments(this);
+		return mapping.isEmpty() ? original : original.withGenericArguments(registry, this);
 	}
 	
-	public GenericMapper getInner(Map<TypeParameter, ITypeID> mapping) {
+	public GenericMapper getInner(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
 		Map<TypeParameter, ITypeID> resultMap = new HashMap<>(this.mapping);
 		resultMap.putAll(mapping);
 		return new GenericMapper(registry, resultMap);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/VariantDefinition.java

 			this.types = types;
 		}
 		
-		public VariantOptionRef instance(GenericMapper mapper) {
-			return new VariantOptionRef(this, mapper.map(types));
+		public VariantOptionRef instance(ITypeID variantType, GenericMapper mapper) {
+			return new VariantOptionRef(this, variantType, mapper.map(types));
 		}
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/VariantOptionRef.java

  */
 public class VariantOptionRef {
 	private final VariantDefinition.Option option;
+	public final ITypeID variant;
 	public final ITypeID[] types;
 	
-	public VariantOptionRef(VariantDefinition.Option option, ITypeID[] types) {
+	public VariantOptionRef(VariantDefinition.Option option, ITypeID variant, ITypeID[] types) {
 		this.option = option;
+		this.variant = variant;
 		this.types = types;
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialVariantOptionExpression.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.partial;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
+import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class PartialVariantOptionExpression implements IPartialExpression {
+	private final CodePosition position;
+	private final TypeScope scope;
+	private final VariantOptionRef option;
+	
+	public PartialVariantOptionExpression(CodePosition position, TypeScope scope, VariantOptionRef option) {
+		this.position = position;
+		this.scope = scope;
+		this.option = option;
+	}
+	
+	@Override
+	public Expression eval() {
+		throw new CompileException(position, CompileExceptionCode.VARIANT_OPTION_NOT_AN_EXPRESSION, "Cannot use a variant option as expression");
+	}
+
+	@Override
+	public List<ITypeID>[] predictCallTypes(TypeScope scope, List<ITypeID> hints, int arguments) {
+		if (arguments != option.getOption().types.length)
+			return new List[0];
+		
+		return new List[] { Arrays.asList(option.getOption().types) };
+	}
+
+	@Override
+	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<ITypeID> hints, int arguments) {
+		if (arguments != option.getOption().types.length)
+			return Collections.emptyList();
+		
+		return Collections.singletonList(new FunctionHeader(option.variant, option.types));
+	}
+
+	@Override
+	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<ITypeID> hints, GenericName name) {
+		throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Variant options don't have members");
+	}
+
+	@Override
+	public Expression call(CodePosition position, TypeScope scope, List<ITypeID> hints, CallArguments arguments) {
+		return new VariantValueExpression(position, option.variant, option, arguments.arguments);
+	}
+
+	@Override
+	public ITypeID[] getGenericCallTypes() {
+		return ITypeID.NONE;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/DefinitionScope.java

 		}
 		
 		members = withMembers ? outer.getMemberCache().get(type) : null;
-		typeParameterMap = outer.getLocalTypeParameters().getInner(typeParameters);
+		typeParameterMap = outer.getLocalTypeParameters().getInner(getTypeRegistry(), typeParameters);
 	}
 	
 	public void addInnerType(String name, Supplier<HighLevelDefinition> innerType) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/ExpressionScope.java

 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 	
 	public ExpressionScope(BaseScope scope, ITypeID hint) {
 		this.outer = scope;
-		this.hints = Collections.singletonList(hint);
+		this.hints = hint == BasicTypeID.UNDETERMINED ? Collections.emptyList() : Collections.singletonList(hint);
 		this.dollar = null;
 		this.genericInferenceMap = Collections.emptyMap();
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/DefinitionTypeID.java

 			return this;
 		if (mapper.getMapping().isEmpty())
 			return this;
+		if (mapper.registry == null)
+			throw new NullPointerException();
 		
 		ITypeID[] instancedArguments = ITypeID.NONE;
 		if (hasTypeParameters()) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/DefinitionMemberGroup.java

 				for (ITypeID resultHint : typeHints) {
 					Map<TypeParameter, ITypeID> mapping = new HashMap<>();
 					if (header.returnType.inferTypeParameters(scope.getMemberCache(), resultHint, mapping)) {
-						header = header.withGenericArguments(scope.getLocalTypeParameters().getInner(mapping));
+						header = header.withGenericArguments(scope.getTypeRegistry(), scope.getLocalTypeParameters().getInner(scope.getTypeRegistry(), mapping));
 						break;
 					}
 				}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/TypeMemberBuilder.java

 		if (definition instanceof VariantDefinition) {
 			VariantDefinition variant = (VariantDefinition) definition;
 			for (VariantDefinition.Option option : variant.options)
-				members.addVariantOption(option.instance(mapper));
+				members.addVariantOption(option.instance(type, mapper));
 		}
 		
 		if (definition instanceof EnumDefinition) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/TypeMembers.java

 import org.openzen.zenscript.codemodel.partial.PartialMemberGroupExpression;
 import org.openzen.zenscript.codemodel.partial.PartialStaticMemberGroupExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
+import org.openzen.zenscript.codemodel.partial.PartialVariantOptionExpression;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
 			return new PartialStaticMemberGroupExpression(position, scope, type, members.get(name.name), name.arguments);
 		if (innerTypes.containsKey(name.name))
 			return new PartialTypeExpression(position, innerTypes.get(name.name).instance(cache.getRegistry(), name.arguments, (DefinitionTypeID)type), name.arguments);
+		if (variantOptions.containsKey(name.name))
+			return new PartialVariantOptionExpression(position, scope, variantOptions.get(name.name));
 		
 		return null;
 	}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaCompiler.java

 			// convert scripts into methods (add them to a Scripts class?)
 			// (TODO: can we break very long scripts into smaller methods? for the extreme scripts)
 			final JavaClassWriter visitor = scriptFile.classWriter;
-			JavaMethod method = new JavaMethod(new JavaClass(script.pkg.fullName, className, JavaClass.Kind.CLASS), JavaMethod.Kind.STATIC, methodName, true, "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+			JavaMethod method = JavaMethod.getStatic(new JavaClass(script.pkg.fullName, className, JavaClass.Kind.CLASS), methodName, "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 			scriptFile.scriptMethods.add(method);
 
 			final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, new JavaWriter(visitor, method, null, null, null));
 			statementVisitor.end();
 		}
 		
-		JavaMethod runMethod = new JavaMethod(new JavaClass("script", "Scripts", JavaClass.Kind.CLASS), JavaMethod.Kind.STATIC, "run", true, "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+		JavaMethod runMethod = JavaMethod.getStatic(new JavaClass("script", "Scripts", JavaClass.Kind.CLASS), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 		final JavaWriter runWriter = new JavaWriter(scriptsClassWriter, runMethod, null, null, null);
 		runWriter.start();
 		for (Map.Entry<String, JavaScriptFile> entry : scriptBlocks.entrySet()) {

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

 					throw new UnsupportedOperationException("Unknown builtin comparator: " + expression.operator.getBuiltin());
 			}
 		} else {
-			if (!checkAndExecuteMethodInfo(expression.operator))
+			if (!checkAndExecuteMethodInfo(expression.operator, expression.type))
 				throw new IllegalStateException("Call target has no method info!");
 
 			expression.left.accept(this);
 				argument.accept(this);
 			}
 
-			if (!checkAndExecuteMethodInfo(expression.member))
+			if (!checkAndExecuteMethodInfo(expression.member, expression.type))
 				throw new IllegalStateException("Call target has no method info!");
 			return null;
 		}
 					}
 				} else {
 					javaWriter.invokeStatic(ARRAYS_COPY_OF_RANGE_OBJECTS);
-					javaWriter.checkCast(context.getDescriptor(type));
+					javaWriter.checkCast(context.getInternalName(type));
 				}
 				break;
 			}
 
 		BuiltinID builtin = expression.member.getBuiltin();
 		if (builtin == null) {
-			if (!checkAndExecuteMethodInfo(expression.member))
+			if (!checkAndExecuteMethodInfo(expression.member, expression.type))
 				throw new IllegalStateException("Call target has no method info!");
 
 			return null;
 
 		BuiltinID builtin = expression.member.member.builtin;
 		if (builtin == null) {
-			if (!checkAndExecuteMethodInfo(expression.member))
+			if (!checkAndExecuteMethodInfo(expression.member, expression.type))
 				throw new IllegalStateException("Call target has no method info!");
 
 			return null;
 	public Void visitGetMatchingVariantField(GetMatchingVariantField expression) {
 		javaWriter.loadObject(0);
 		final ITypeID type = expression.value.option.getParameterType(expression.index);
-		final JavaClass tag = expression.value.option.getTag(JavaClass.class);
-		javaWriter.checkCast("L" + tag.internalName + ";");
-		javaWriter.getField(new JavaField(tag, "field" + expression.index, context.getDescriptor(type)));
+		final JavaVariantOption tag = expression.value.option.getTag(JavaVariantOption.class);
+		javaWriter.checkCast(tag.variantOptionClass.internalName);
+		javaWriter.getField(new JavaField(tag.variantOptionClass, "field" + expression.index, context.getDescriptor(type)));
 		return null;
 	}
 
 
 		BuiltinID builtin = expression.getter.member.builtin;
 		if (builtin == null) {
-			if (!checkAndExecuteMethodInfo(expression.getter))
+			if (!checkAndExecuteMethodInfo(expression.getter, expression.type))
 				throw new IllegalStateException("Call target has no method info!");
 
 			return null;
     @Override
     public Void visitInterfaceCast(InterfaceCastExpression expression) {
         expression.value.accept(this);
-        javaWriter.checkCast(context.getDescriptor(expression.type));
+        javaWriter.checkCast(context.getInternalName(expression.type));
         return null;
     }
 
     @Override
     public Void visitIs(IsExpression expression) {
         expression.value.accept(this);
-        javaWriter.instanceOf(context.getDescriptor(expression.isType));
+        javaWriter.instanceOf(context.getInternalName(expression.isType));
         return null;
     }
 
 	public Void visitPostCall(PostCallExpression expression) {
 		expression.target.accept(this);
 		javaWriter.dup(context.getType(expression.type));
-		if (!checkAndExecuteMethodInfo(expression.member))
+		if (!checkAndExecuteMethodInfo(expression.member, expression.type))
 			throw new IllegalStateException("Call target has no method info!");
 
 		return null;
 	public Void visitStaticGetter(StaticGetterExpression expression) {
 		BuiltinID builtin = expression.getter.member.builtin;
 		if (builtin == null) {
-			if (!checkAndExecuteMethodInfo(expression.getter))
+			if (!checkAndExecuteMethodInfo(expression.getter, expression.type))
 				throw new IllegalStateException("Call target has no method info!");
 
 			return null;
 
 	@Override
 	public Void visitVariantValue(VariantValueExpression expression) {
-		final String internalName = expression.option.getTag(JavaClass.class).internalName;
+		JavaVariantOption tag = expression.option.getTag(JavaVariantOption.class);
+		final String internalName = tag.variantOptionClass.internalName;
 		javaWriter.newObject(internalName);
 		javaWriter.dup();
 
     }
 
     //Will return true if a JavaMethodInfo.class tag exists, and will compile that tag
-    private boolean checkAndExecuteMethodInfo(DefinitionMemberRef member) {
+    private boolean checkAndExecuteMethodInfo(DefinitionMemberRef member, ITypeID resultType) {
         JavaMethod methodInfo = member.getTag(JavaMethod.class);
         if (methodInfo == null)
             return false;
         } else {
             getJavaWriter().invokeVirtual(methodInfo);
         }
+		if (methodInfo.genericResult)
+			getJavaWriter().checkCast(context.getInternalName(resultType));
+		
         return true;
     }
 

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

         }
     }
 
-    public void checkCast(String descriptor) {
+    public void checkCast(String internalName) {
         if (debug)
-            System.out.println("checkCast " + descriptor);
+            System.out.println("checkCast " + internalName);
 
-        visitor.visitTypeInsn(CHECKCAST, descriptor);
+        visitor.visitTypeInsn(CHECKCAST, internalName);
     }
 
     public void checkCast(Type type) {

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

             member.accept(visitor);
         }
 		
-		JavaMethod valuesMethod = new JavaMethod(toClass, JavaMethod.Kind.STATIC, "values", true, "()[L" + toClass.internalName + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
+		JavaMethod valuesMethod = JavaMethod.getStatic(toClass, "values", "()[L" + toClass.internalName + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
 		JavaWriter valuesWriter = new JavaWriter(writer, true, valuesMethod, definition, null, null);
 		valuesWriter.start();
 		valuesWriter.getStaticField(toClass.internalName, "$VALUES", "[L" + toClass.internalName + ";");
 		valuesWriter.returnObject();
 		valuesWriter.end();
 
-		JavaMethod valueOfMethod = new JavaMethod(toClass, JavaMethod.Kind.STATIC, "valueOf", true, "(Ljava/lang/String;)L" + toClass.internalName + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
+		JavaMethod valueOfMethod = JavaMethod.getStatic(toClass, "valueOf", "(Ljava/lang/String;)L" + toClass.internalName + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
 		JavaWriter valueOfWriter = new JavaWriter(writer, true, valueOfMethod, definition, null, null);
 		valueOfWriter.start();
 		valueOfWriter.invokeStatic(CLASS_FORNAME);
 		valueOfWriter.loadObject(0);
 		valueOfWriter.invokeStatic(ENUM_VALUEOF);
-		valueOfWriter.checkCast("L" + toClass.internalName + ";");
+		valueOfWriter.checkCast(toClass.internalName);
 		valueOfWriter.returnObject();
 		valueOfWriter.end();
 		
 
 			ITypeID[] types = option.types;
 			for (int i = 0; i < types.length; ++i) {
-				final String internalName = context.getInternalName(types[i]);
-				optionInitDescBuilder.append(internalName);
-				optionWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "field" + i, internalName, "TT" + i + ";", null).visitEnd();
+				final String descriptor = context.getDescriptor(types[i]);
+				optionInitDescBuilder.append(descriptor);
+				optionWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "field" + i, descriptor, "TT" + i + ";", null).visitEnd();
 			}
 			optionInitDescBuilder.append(")V");
 			
-			JavaMethod constructorMethod = new JavaMethod(optionTag.variantOptionClass, JavaMethod.Kind.CONSTRUCTOR, "<init>", true, optionInitDescBuilder.toString(), JavaModifiers.PUBLIC);
+			JavaMethod constructorMethod = JavaMethod.getConstructor(optionTag.variantOptionClass, optionInitDescBuilder.toString(), JavaModifiers.PUBLIC);
 			final JavaWriter initWriter = new JavaWriter(optionWriter, constructorMethod, variant, optionInitDescBuilder.toString(), null);
 			initWriter.start();
 			initWriter.loadObject(0);
 			initWriter.end();
 			
 			//Denominator for switch-cases
-			JavaMethod denominator = new JavaMethod(optionTag.variantOptionClass, JavaMethod.Kind.INSTANCE, "getDenominator", true, "()I", JavaModifiers.PUBLIC);
+			JavaMethod denominator = JavaMethod.getVirtual(optionTag.variantOptionClass, "getDenominator", "()I", JavaModifiers.PUBLIC);
 			final JavaWriter getDenominator = new JavaWriter(optionWriter, denominator, null, null, null, "java/lang/Override");
 			getDenominator.start();
 			getDenominator.constant(option.ordinal);
 			member.accept(visitor);
 		}
 
-		final JavaWriter superInitWriter = new JavaWriter(writer, new JavaMethod(toClass, JavaMethod.Kind.CONSTRUCTOR, "<init>", true, "()V", Opcodes.ACC_PUBLIC), variant, "()V", null);
+		final JavaWriter superInitWriter = new JavaWriter(writer, JavaMethod.getConstructor(toClass, "()V", Opcodes.ACC_PUBLIC), variant, "()V", null);
 		superInitWriter.start();
 		superInitWriter.loadObject(0);
 		superInitWriter.invokeSpecial("java/lang/Object", "<init>", "()V");

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

         this.definition = definition;
 		this.context = context;
 
-        final JavaWriter javaWriter = new JavaWriter(writer, new JavaMethod(toClass, JavaMethod.Kind.STATICINIT, "<clinit>", true, "()V", 0), definition, null, null);
+        final JavaWriter javaWriter = new JavaWriter(writer, new JavaMethod(toClass, JavaMethod.Kind.STATICINIT, "<clinit>", true, "()V", 0, false), definition, null, null);
         this.clinitStatementVisitor = new JavaStatementVisitor(context, javaWriter);
         this.clinitStatementVisitor.start();
         CompilerUtils.writeDefaultFieldInitializers(context, javaWriter, definition, true);
 
 	@Override
 	public Void visitDestructor(DestructorMember member) {
-		final JavaMethod method = new JavaMethod(toClass, JavaMethod.Kind.INSTANCE, "close", true, "()V", Opcodes.ACC_PUBLIC);
+		final JavaMethod method = JavaMethod.getVirtual(toClass, "close", "()V", Opcodes.ACC_PUBLIC);
 
 		final Label constructorStart = new Label();
 		final Label constructorEnd = new Label();

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

  */
 public class JavaMethod {
 	public static JavaMethod getConstructor(JavaClass cls, String descriptor, int modifiers) {
-		return new JavaMethod(cls, Kind.CONSTRUCTOR, "<init>", true, descriptor, modifiers);
+		return new JavaMethod(cls, Kind.CONSTRUCTOR, "<init>", true, descriptor, modifiers, false);
 	}
 	
 	public static JavaMethod getNativeConstructor(JavaClass cls, String descriptor) {
-		return new JavaMethod(cls, Kind.CONSTRUCTOR, "<init>", false, descriptor, JavaModifiers.PUBLIC);
+		return new JavaMethod(cls, Kind.CONSTRUCTOR, "<init>", false, descriptor, JavaModifiers.PUBLIC, false);
 	}
 	
 	public static JavaMethod getDestructor(JavaClass cls, int modifiers) {
-		return new JavaMethod(cls, Kind.INSTANCE, "close", true, "()V", modifiers);
+		return new JavaMethod(cls, Kind.INSTANCE, "close", true, "()V", modifiers, false);
 	}
 	
 	public static JavaMethod getStatic(JavaClass cls, String name, String descriptor, int modifiers) {
-		return new JavaMethod(cls, Kind.STATIC, name, true, descriptor, modifiers | JavaModifiers.STATIC);
+		return new JavaMethod(cls, Kind.STATIC, name, true, descriptor, modifiers | JavaModifiers.STATIC, false);
 	}
 	
 	public static JavaMethod getNativeStatic(JavaClass cls, String name, String descriptor) {
-		return new JavaMethod(cls, Kind.STATIC, name, false, descriptor, JavaModifiers.STATIC | JavaModifiers.PUBLIC);
+		return new JavaMethod(cls, Kind.STATIC, name, false, descriptor, JavaModifiers.STATIC | JavaModifiers.PUBLIC, false);
 	}
 	
 	public static JavaMethod getVirtual(JavaClass cls, String name, String descriptor, int modifiers) {
-		return new JavaMethod(cls, Kind.INSTANCE, name, true, descriptor, modifiers);
+		return new JavaMethod(cls, Kind.INSTANCE, name, true, descriptor, modifiers, false);
 	}
 	
 	public static JavaMethod getNativeVirtual(JavaClass cls, String name, String descriptor) {
-		return new JavaMethod(cls, Kind.INSTANCE, name, false, descriptor, JavaModifiers.PUBLIC);
+		return new JavaMethod(cls, Kind.INSTANCE, name, false, descriptor, JavaModifiers.PUBLIC, false);
+	}
+
+	public static JavaMethod getNativeExpansion(JavaClass cls, String name, String descriptor) {
+		return new JavaMethod(cls, Kind.EXPANSION, name, false, descriptor, JavaModifiers.PUBLIC | JavaModifiers.STATIC, false);
 	}
 	
 	public final JavaClass cls;
 	
 	public final String descriptor;
 	public final int modifiers;
+	public final boolean genericResult;
 	
-	public JavaMethod(JavaClass cls, Kind kind, String name, boolean compile, String descriptor, int modifiers) {
+	public JavaMethod(JavaClass cls, Kind kind, String name, boolean compile, String descriptor, int modifiers, boolean genericResult) {
 		this.cls = cls;
 		this.kind = kind;
 		this.name = name;
 		
 		this.descriptor = descriptor;
 		this.modifiers = modifiers;
+		this.genericResult = genericResult;
 	}
 	
 	public JavaMethod(JavaNativeTranslation<?> translation) {
 		this.translation = translation;
 		this.descriptor = "";
 		this.modifiers = 0;
+		this.genericResult = false;
 	}
 	
 	public enum Kind {

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

 	}
 	
 	public void addConstructor(String key, String descriptor) {
-		methods.put(key, new JavaMethod(cls, JavaMethod.Kind.CONSTRUCTOR, "<init>", false, descriptor, JavaModifiers.PUBLIC));
+		methods.put(key, new JavaMethod(cls, JavaMethod.Kind.CONSTRUCTOR, "<init>", false, descriptor, JavaModifiers.PUBLIC, false));
 	}
 	
 	public void addInstanceMethod(String key, String name, String descriptor) {
-		methods.put(key, new JavaMethod(cls, JavaMethod.Kind.INSTANCE, name, false, descriptor, JavaModifiers.PUBLIC));
+		methods.put(key, new JavaMethod(cls, JavaMethod.Kind.INSTANCE, name, false, descriptor, JavaModifiers.PUBLIC, false));
 	}
 	
 	public JavaMethod getMethod(String name) {

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

 
 import org.openzen.zenscript.javashared.JavaNativeClass;
 import org.openzen.zencode.shared.StringExpansion;
-import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.annotations.NativeTag;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
+import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.javashared.JavaTypeNameVisitor;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaField;
 			if (baseMethod == null)
 				throw new IllegalStateException("Base method not yet prepared!");
 			
-			method = new JavaMethod(cls, baseMethod.kind, baseMethod.name, true, context.getMethodDescriptor(member.header), JavaModifiers.getJavaModifiers(member.modifiers));
+			method = new JavaMethod(
+					cls,
+					baseMethod.kind,
+					baseMethod.name,
+					true,
+					context.getMethodDescriptor(member.header),
+					JavaModifiers.getJavaModifiers(member.modifiers),
+					member.header.returnType instanceof GenericTypeID);
 		} else if (method == null) {
-			method = new JavaMethod(cls, getKind(member), name, true, context.getMethodDescriptor(member.header), JavaModifiers.getJavaModifiers(member.modifiers));
+			method = new JavaMethod(
+					cls,
+					getKind(member),
+					name,
+					true,
+					context.getMethodDescriptor(member.header),
+					JavaModifiers.getJavaModifiers(member.modifiers),
+					member.header.returnType instanceof GenericTypeID);
 		}
 		
 		if (method.compile) {

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaMethod;
-import org.openzen.zenscript.javashared.JavaModifiers;
 import org.openzen.zenscript.javashared.JavaVariantOption;
 
 /**
 		{
 			JavaNativeClass list = new JavaNativeClass(new JavaClass("java.util", "List", JavaClass.Kind.INTERFACE));
 			JavaClass arrayList = new JavaClass("java.util", "ArrayList", JavaClass.Kind.CLASS);
-			list.addMethod("constructor", new JavaMethod(arrayList, JavaMethod.Kind.CONSTRUCTOR, "", false, "()V", JavaModifiers.PUBLIC));
+			list.addMethod("constructor", JavaMethod.getNativeConstructor(arrayList, "()V"));
 			list.addInstanceMethod("add", "add", "(Ljava/lang/Object;)Z"); List<?> l;
 			list.addInstanceMethod("insert", "add", "(Ljava/lang/Object;I)V");
 			list.addInstanceMethod("remove", "remove", "(java/lang/Object;)Z");
 			JavaClass math = new JavaClass("java.lang", "Math", JavaClass.Kind.CLASS);
 			
 			JavaNativeClass cls = new JavaNativeClass(integer);
-			cls.addMethod("min", new JavaMethod(math, JavaMethod.Kind.STATIC, "min", false, "(II)I", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
-			cls.addMethod("max", new JavaMethod(math, JavaMethod.Kind.STATIC, "max", false, "(II)I", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
-			cls.addMethod("toHexString", new JavaMethod(integer, JavaMethod.Kind.EXPANSION, "toHexString", false, "()Ljava/lang/String;", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
+			cls.addMethod("min", JavaMethod.getNativeStatic(math, "min", "(II)I"));
+			cls.addMethod("max", JavaMethod.getNativeStatic(math, "max", "(II)I"));
+			cls.addMethod("toHexString", JavaMethod.getNativeExpansion(integer, "toHexString", "(I)Ljava/lang/String;"));
 			nativeClasses.put("stdlib::Integer", cls);
 		}
 		
 		{
 			JavaClass arrays = new JavaClass("java.lang", "Arrays", JavaClass.Kind.CLASS);
 			JavaNativeClass cls = new JavaNativeClass(arrays);
-			cls.addMethod("sort", new JavaMethod(arrays, JavaMethod.Kind.EXPANSION, "sort", false, "([Ljava/lang/Object;)[Ljava/lang/Object;", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
+			cls.addMethod("sort", JavaMethod.getNativeExpansion(arrays, "sort", "([Ljava/lang/Object;)[Ljava/lang/Object;"));
 			cls.addMethod("sorted", new JavaMethod((expression, translator) -> {
 				return translator.sorted(((CallExpression)expression).target);
 			}));
-			cls.addMethod("sortWithComparator", new JavaMethod(arrays, JavaMethod.Kind.EXPANSION, "sort", false, "([Ljava/lang/Object;Ljava/lang/Comparator;)[Ljava/lang/Object;", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
+			cls.addMethod("sortWithComparator", JavaMethod.getNativeExpansion(arrays, "sort", "([Ljava/lang/Object;Ljava/lang/Comparator;)[Ljava/lang/Object;"));
 			cls.addMethod("sortedWithComparator", new JavaMethod((expression, translator) -> {
 				return translator.sortedWithComparator(
 						((CallExpression)expression).target,
 			cls.addMethod("copy", new JavaMethod((expression, translator) -> {
 				return translator.copy(((CallExpression)expression).target);
 			}));
-			cls.addMethod("copyResize", new JavaMethod(arrays, JavaMethod.Kind.EXPANSION, "copyOf", false, "([Ljava/lang/Object;I)[Ljava/lang/Object;", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
+			cls.addMethod("copyResize", JavaMethod.getNativeExpansion(arrays, "copyOf", "([Ljava/lang/Object;I)[Ljava/lang/Object;"));
 			cls.addMethod("copyTo", new JavaMethod((expression, translator) -> {
 				return translator.copyTo((CallExpression)expression);
 			}));
 		variant.setTag(JavaClass.class, cls);
 		
 		for (VariantDefinition.Option option : variant.options) {
-			JavaClass variantCls = new JavaClass(cls.fullName, option.name, JavaClass.Kind.CLASS);
+			JavaClass variantCls = new JavaClass(cls, option.name, JavaClass.Kind.CLASS);
 			option.setTag(JavaVariantOption.class, new JavaVariantOption(cls, variantCls));
 		}
 		

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

 import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
+import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.javashared.JavaTypeNameVisitor;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaField;
 		if (nativeTag != null && nativeClass != null)
 			method = nativeClass.getMethod(nativeTag.value);
 		if (method == null)
-			method = new JavaMethod(cls, getKind(member), name, true, context.getMethodDescriptor(member.header), JavaModifiers.getJavaModifiers(member.modifiers)); 
+			method = new JavaMethod(cls, getKind(member), name, true, context.getMethodDescriptor(member.header), JavaModifiers.getJavaModifiers(member.modifiers), member.header.returnType instanceof GenericTypeID); 
 		
 		if (method.compile) {
 			if (DEBUG_EMPTY && cls.empty)

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceSyntheticHelperGenerator.java

 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaContext;
 import org.openzen.zenscript.javashared.JavaMethod;
-import org.openzen.zenscript.javashared.JavaModifiers;
 
 /**
  *
 		addMember(arrayHelpers, method);
 		
 		String descriptor = "(" + context.getDescriptor(type) + context.getDescriptor(type.elementType) + ")Z";
-		JavaMethod sourceMethod = new JavaMethod(arrayHelpers, JavaMethod.Kind.EXPANSION, kind.containsName, false, descriptor, JavaModifiers.PUBLIC | JavaModifiers.STATIC);
+		JavaMethod sourceMethod = JavaMethod.getNativeExpansion(arrayHelpers, kind.containsName, descriptor);
 		existingContains.put(kind, sourceMethod);
 		return sourceMethod;
 	}
 		addMember(arrayHelpers, method);
 		
 		String descriptor = "(" + context.getDescriptor(type) + ")I";
-		JavaMethod sourceMethod = new JavaMethod(arrayHelpers, JavaMethod.Kind.EXPANSION, kind.containsName, false, descriptor, JavaModifiers.PUBLIC | JavaModifiers.STATIC);
+		JavaMethod sourceMethod = JavaMethod.getNativeExpansion(arrayHelpers, kind.containsName, descriptor);
 		existingContains.put(kind, sourceMethod);
 		return sourceMethod;
 	}

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedCallArguments.java

 		}
 		
 		ITypeID[] typeParameters = genericParameters;
-		if (typeParameters == null) {
+		if (typeParameters == null || typeParameters.length == 0) {
 			for (FunctionHeader candidate : candidates) {
 				if (candidate.typeParameters != null) {
 					typeParameters = new ITypeID[candidate.typeParameters.length];

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionFunction.java

 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.scope.LambdaScope;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 import org.openzen.zenscript.parser.statements.ParsedFunctionBody;
 
 		LambdaClosure closure = new LambdaClosure();
 		StatementScope innerScope = new LambdaScope(scope, closure, header);
 		Statement statements = body.compile(innerScope, header);
+		
+		if (header.returnType == BasicTypeID.UNDETERMINED) {
+			header.returnType = statements.getReturnType();
+		}
 		if (!scope.genericInferenceMap.isEmpty()) {
 			// perform type parameter inference
 			ITypeID returnType = statements.getReturnType();
 			Map<TypeParameter, ITypeID> inferredTypes = new HashMap<>();
-			if (!genericHeader.returnType.inferTypeParameters(scope.getMemberCache(), returnType, inferredTypes))
+			if (!returnType.inferTypeParameters(scope.getMemberCache(), genericHeader.returnType, inferredTypes))
 				throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE, "Could not infer generic type parameters");
 			
 			scope.genericInferenceMap.putAll(inferredTypes);
 		}
 		
-		FunctionTypeID functionType = scope.getTypeRegistry().getFunction(genericHeader.withGenericArguments(new GenericMapper(scope.getTypeRegistry(), scope.genericInferenceMap)));
+		FunctionTypeID functionType = scope.getTypeRegistry().getFunction(genericHeader.withGenericArguments(scope.getTypeRegistry(), new GenericMapper(scope.getTypeRegistry(), scope.genericInferenceMap)));
 		return new FunctionExpression(position, functionType, closure, header, statements);
 	}
 	

Shared/src/main/java/org/openzen/zencode/shared/CompileExceptionCode.java

 	UNTYPED_EMPTY_MAP(),
 	VAR_WITHOUT_TYPE_OR_INITIALIZER(),
 	NO_BRACKET_PARSER(),
-	INVALID_BRACKET_EXPRESSION()
+	INVALID_BRACKET_EXPRESSION(),
+	VARIANT_OPTION_NOT_AN_EXPRESSION
 }