[WIP, I have no idea what I'm doing] Trying to get generic parameters working

Let's see if putting them all into one TypeVariableContext works..?

Also, a lambda that returns void cannot conclude the generic header. How should we deal with this?

JavaIntegration/src/main/java/org/openzen/zencode/java/JavaNativeModule.java

 	private final Map<Class<?>, HighLevelDefinition> definitionByClass = new HashMap<>();
 	private final Map<Class<?>, TypeID> typeByClass = new HashMap<>();
 	private final Map<Class<?>, TypeID> unsignedByClass = new HashMap<>();
+	private final TypeVariableContext context = new TypeVariableContext();
 	
 	public final Map<String, ISymbol> globals = new HashMap<>();
 	private BracketExpressionParser bep;
 		JavaClass jcls = JavaClass.fromInternalName(getInternalName(cls), JavaClass.Kind.CLASS);
 		compiled.setClassInfo(definition, jcls);
 		StoredType thisType = registry.getForMyDefinition(definition).stored();
-		TypeVariableContext context = new TypeVariableContext();
+		//TypeVariableContext context = new TypeVariableContext();
 		
 		for (Field field : cls.getDeclaredFields()) {
 			if (!field.isAnnotationPresent(ZenCodeGlobals.Global.class))
 		HighLevelDefinition definition = addClass(method.getDeclaringClass());
 		JavaClass jcls = JavaClass.fromInternalName(getInternalName(method.getDeclaringClass()), JavaClass.Kind.CLASS);
 		
-		TypeVariableContext context = new TypeVariableContext();
+		//TypeVariableContext context = new TypeVariableContext();
 		MethodMember methodMember = new MethodMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC | Modifiers.STATIC, method.getName(), getHeader(context, method), null);
 		definition.addMember(methodMember);
 		boolean isGenericResult = methodMember.header.getReturnType().isGeneric();
 		//Moved up here so that circular dependencies are caught (hopefully)
 		definitionByClass.put(cls, definition);
 
-		TypeVariableContext context = new TypeVariableContext();
+		//TypeVariableContext context = new TypeVariableContext();
 		TypeVariable<Class<T>>[] javaTypeParameters = cls.getTypeParameters();
 		TypeParameter[] typeParameters = new TypeParameter[cls.getTypeParameters().length];
 		definition.typeParameters = typeParameters;
             if(methodAnnotation != null) {
                 String name = !methodAnnotation.value().isEmpty() ? methodAnnotation.value() : method.getName();
 
-                TypeVariableContext context = new TypeVariableContext();
+                //TypeVariableContext context = new TypeVariableContext();
 
                 final Parameter[] parameters = getExpansionParameters(method);
 
                 if (implicit) {
                     modifiers |= Modifiers.IMPLICIT;
                 }
-                TypeVariableContext context = new TypeVariableContext();
+                //TypeVariableContext context = new TypeVariableContext();
                 StoredType toType = loadStoredType(context, method.getAnnotatedReturnType());
                 final CasterMember member = new CasterMember(CodePosition.NATIVE, expansion, modifiers, toType,  null);
 
 			Parameter parameter = javaParameters[i];
 
 			//AnnotatedType parameterType = parameter.getAnnotatedType();
-			StoredType type = loadStoredType(context, parameter);
+ 			StoredType type = loadStoredType(context, parameter);
 			Expression defaultValue = getDefaultValue(parameter, type);
 			parameters[i] = new FunctionParameter(type, parameter.getName(), defaultValue, parameter.isVarArgs());
 		}
 	}
 	
 	private <T> TypeVariableContext convertTypeParameters(Class<T> cls) {
-		TypeVariableContext context = new TypeVariableContext();
+		//TypeVariableContext context = new TypeVariableContext();
 		TypeVariable<Class<T>>[] javaTypeParameters = cls.getTypeParameters();
 		TypeParameter[] typeParameters = new TypeParameter[cls.getTypeParameters().length];
 

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

 			
 			header.setReturnType(returnType);
 		}
-		
-		if (!scope.genericInferenceMap.isEmpty()) {
+
+
+		if (genericHeader.typeParameters.length > 0 && !scope.genericInferenceMap.isEmpty()) {
 			// perform type parameter inference
 			StoredType returnType = statements.getReturnType();
-			if(returnType == null) {
-				throw new NullPointerException();
-			}
+			if (returnType != null) {
+				Map<TypeParameter, StoredType> inferredTypes = returnType.type.inferTypeParameters(scope.getMemberCache(), genericHeader
+						.getReturnType());
+				if (inferredTypes == null) {
+					throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE, "Could not infer generic type parameters");
+				}
 
-			if(returnType.type == null) {
-				throw new NullPointerException();
+				scope.genericInferenceMap.putAll(inferredTypes);
 			}
 
-			Map<TypeParameter, StoredType> inferredTypes = returnType.type.inferTypeParameters(scope.getMemberCache(), genericHeader.getReturnType());
-			if (inferredTypes == null)
-				throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE, "Could not infer generic type parameters");
-			
-			scope.genericInferenceMap.putAll(inferredTypes);
 		}
-		
+
+		final FunctionHeader thatOtherHeader = genericHeader.withGenericArguments(new GenericMapper(position, scope.getTypeRegistry(), scope.genericInferenceMap));
+		if(thatOtherHeader.getReturnType().isBasic(BasicTypeID.UNDETERMINED)) {
+			thatOtherHeader.setReturnType(header.getReturnType());
+		}
 		StoredType functionType = scope.getTypeRegistry()
-				.getFunction(genericHeader.withGenericArguments(new GenericMapper(position, scope.getTypeRegistry(), scope.genericInferenceMap)))
+				.getFunction(thatOtherHeader)
 				.stored(storage);
 		return new FunctionExpression(position, functionType, closure, header, statements);
 	}