WIP: Saving so that it is safe :smile:

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

 		TypeVariableContext context = new TypeVariableContext();
 		TypeVariable<Class<T>>[] javaTypeParameters = cls.getTypeParameters();
 		TypeParameter[] typeParameters = new TypeParameter[cls.getTypeParameters().length];
+		definition.typeParameters = typeParameters;
+
 		for (int i = 0; i < javaTypeParameters.length; i++) {
+			//Put up here for nested parameters?
 			TypeVariable<Class<T>> typeVariable = javaTypeParameters[i];
 			TypeParameter parameter = new TypeParameter(CodePosition.NATIVE, typeVariable.getName());
+			typeParameters[i] = parameter;
+			context.put(typeVariable, parameter);
+		}
+
+		for (int i = 0; i < javaTypeParameters.length; i++) {
+			TypeVariable<Class<T>> typeVariable = javaTypeParameters[i];
+			TypeParameter parameter = typeParameters[i];
 			for (AnnotatedType bound : typeVariable.getAnnotatedBounds()) {
 				TypeID type = loadType(context, bound).type;
 				parameter.addBound(new ParameterTypeBound(CodePosition.NATIVE, type));
 			}
 			typeParameters[i] = parameter;
-			context.put(typeVariable, parameter);
 		}
 
 		if (definition instanceof ClassDefinition && cls.getAnnotatedSuperclass() != null && shouldLoadType(cls.getAnnotatedSuperclass().getType())) {
 				compiled.setImplementationInfo(member, new JavaImplementation(true, javaClass));
 			}
 		}
-		
-		definition.typeParameters = typeParameters;
+
 		compiled.setClassInfo(definition, javaClass);
 		
 		StoredType thisType = new StoredType(registry.getForMyDefinition(definition), AutoStorageTag.INSTANCE);
 		}
 		
 		boolean hasConstructor = false;
-		for (java.lang.reflect.Constructor constructor : cls.getConstructors()) {
+		for (java.lang.reflect.Constructor<?> constructor : cls.getConstructors()) {
 			ZenCodeType.Constructor constructorAnnotation = (ZenCodeType.Constructor) constructor.getAnnotation(ZenCodeType.Constructor.class);
 			if (constructorAnnotation != null) {
 				ConstructorMember member = asConstructor(context, definition, constructor);
 			AnnotatedType[] exceptionTypes) {
 		StoredType returnType = javaReturnType == null ? BasicTypeID.VOID.stored : loadStoredType(context, javaReturnType);
 		
+
+		TypeParameter[] typeParameters = new TypeParameter[javaTypeParameters.length];
+		for (int i = 0; i < javaTypeParameters.length; i++) {
+			//Put up here for nested parameters?
+			TypeVariable<Method> typeVariable = javaTypeParameters[i];
+			TypeParameter parameter = new TypeParameter(CodePosition.NATIVE, typeVariable.getName());
+			typeParameters[i] = parameter;
+			context.put(typeVariable, parameter);
+		}
+
+		for (int i = 0; i < javaTypeParameters.length; i++) {
+			TypeVariable<Method> javaTypeParameter = javaTypeParameters[i];
+			
+			for (AnnotatedType bound : javaTypeParameter.getAnnotatedBounds())
+				typeParameters[i].addBound(new ParameterTypeBound(CodePosition.NATIVE, loadType(context, bound).type));
+		}
+
 		FunctionParameter[] parameters = new FunctionParameter[javaParameters.length];
 		for (int i = 0; i < parameters.length; i++) {
 			Parameter parameter = javaParameters[i];
 			parameters[i] = new FunctionParameter(type, parameter.getName(), defaultValue, parameter.isVarArgs());
 		}
 		
-		TypeParameter[] typeParameters = new TypeParameter[javaTypeParameters.length];
-		for (int i = 0; i < javaTypeParameters.length; i++) {
-			TypeVariable<Method> javaTypeParameter = javaTypeParameters[i];
-			typeParameters[i] = new TypeParameter(CodePosition.UNKNOWN, javaTypeParameter.getName());
-			context.put(javaTypeParameter, typeParameters[i]);
-			
-			for (AnnotatedType bound : javaTypeParameter.getAnnotatedBounds())
-				typeParameters[i].addBound(new ParameterTypeBound(CodePosition.NATIVE, loadType(context, bound).type));
-		}
-		
 		if (exceptionTypes.length > 1)
 			throw new IllegalArgumentException("A method can only throw a single exception type!");
 		
 				return typeByClass.get(classType).stored();
 			
 			HighLevelDefinition definition = addClass(classType);
-			return registry.getForDefinition(definition).stored();
+			final List<StoredType> s = new ArrayList<>();
+			for (TypeVariable<? extends Class<?>> typeParameter : classType.getTypeParameters()) {
+				s.add(registry.getGeneric(context.get(typeParameter)).stored());
+			}
+
+			return registry.getForDefinition(definition, s.toArray(StoredType.NONE)).stored();
 		} else if (type instanceof ParameterizedType) {
 			ParameterizedType parameterizedType = (ParameterizedType) type;
-			Class<?> rawType = (Class) parameterizedType.getRawType();
+			Class<?> rawType = (Class<?>) parameterizedType.getRawType();
 			if (rawType.isAnnotationPresent(FunctionalInterface.class))
 				return loadFunctionalInterface(context, rawType, (AnnotatedElement[]) parameterizedType.getActualTypeArguments());
 			
             
             HighLevelDefinition definition = addClass(rawType);
             return registry.getForDefinition(definition, codeParameters).stored();
-		} else if (type instanceof TypeVariable) {
-            TypeVariable variable = (TypeVariable) type;
+		} else if (type instanceof TypeVariable<?>) {
+            TypeVariable<?> variable = (TypeVariable<?>) type;
             return registry.getGeneric(context.get(variable)).stored();
         }else if(type instanceof AnnotatedType){
 		    final StoredType storedType;
                 if(rawType == Map.class) {
                     storedType = registry.getAssociative(codeParameters[0], codeParameters[1]).stored();
                 } else {
-                    HighLevelDefinition definition = addClass((Class<?>) rawType);
-                    storedType = registry.getForDefinition(definition, codeParameters).stored();
+                    storedType = loadType(context, (AnnotatedElement) rawType, unsigned);
                 }
             } else {
-		        storedType = loadType(context, (AnnotatedElement) ((AnnotatedType) type).getType(), unsigned);
+				if (((AnnotatedType) type).getType() instanceof WildcardType) {
+					storedType = BasicTypeID.UNDETERMINED.stored();
+				} else {
+					storedType = loadType(context, (AnnotatedElement) ((AnnotatedType) type).getType(), unsigned);
+				}
             }
             
 		    if(type.isAnnotationPresent(ZenCodeStorageTag.class)) {
 		
 		Map<TypeParameter, StoredType> mapping = new HashMap<>();
 		TypeVariable[] javaParameters = cls.getTypeParameters();
-		for (int i = 0; i < javaParameters.length; i++)
+		for (int i = 0; i < parameters.length; i++)
 			mapping.put(context.get(javaParameters[i]), loadType(loadContext, parameters[i], false, false));
 		
 		JavaMethod method = new JavaMethod(
 		TypeVariableContext context = new TypeVariableContext();
 		TypeVariable<Class<T>>[] javaTypeParameters = cls.getTypeParameters();
 		TypeParameter[] typeParameters = new TypeParameter[cls.getTypeParameters().length];
+
 		for (int i = 0; i < javaTypeParameters.length; i++) {
 			TypeVariable<Class<T>> typeVariable = javaTypeParameters[i];
 			TypeParameter parameter = new TypeParameter(CodePosition.NATIVE, typeVariable.getName());
-			for (AnnotatedType bound : typeVariable.getAnnotatedBounds()) {
-				TypeID type = loadType(context, bound).type;
-				parameter.addBound(new ParameterTypeBound(CodePosition.NATIVE, type));
-			}
 			typeParameters[i] = parameter;
+
+			//Put up here so that Nested Type parameters may work..?
 			context.put(typeVariable, parameter);
 		}
+
+		for (int i = 0; i < javaTypeParameters.length; i++) {
+			for (AnnotatedType bound : javaTypeParameters[i].getAnnotatedBounds()) {
+				TypeID type = loadType(context, bound).type;
+				typeParameters[i].addBound(new ParameterTypeBound(CodePosition.NATIVE, type));
+			}
+		}
 		return context;
 	}
 	

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

 		if (!scope.genericInferenceMap.isEmpty()) {
 			// perform type parameter inference
 			StoredType returnType = statements.getReturnType();
+			if(returnType == null) {
+				throw new NullPointerException();
+			}
+
+			if(returnType.type == null) {
+				throw new NullPointerException();
+			}
+
 			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");

ScriptingExample/scripts/arithmetic.zs

-var j = 0;
-println(j);
-j++;
-println(j);

ScriptingExample/scripts/arrays.zs

-//val a  = new int[](3, 10);
-//
-//for i in a {
-//	println(i);
-//}
-//
-//println(a[1]);
-////
-////
-val multiDim = new int[,,](1,2,3, 130);
-println(multiDim[0,1,2]);
-
-val t = multiDim;
-//
-//
-val b = new int[](3);
-for i in b {
-	println(i);
-}
-
-
-val c = new int[,,](1,2,3);
-println(c[0,1,2]);
-//
-//
-//val d = new string[,,](5,5,5, "HelloWorld");
-//println(d[2,2,2]);
-//
-//
-////val e = new int[](a, value => value);
-//
-//
-//var projection = (value => value) as function(value as string`borrow) as string;
-//val e = new string[](5, "HelloWorld");
-//val f = new string[]<string>(e, projection);
-//var projection = (value => value) as function(value as string`borrow) as string;
-//val a = new string[](5, "HelloWorld");
-//val b = new string[]<string>(a, projection);
-
-val d = new string[,,](3,4,5, "HelloWorld");
-
-val someString = "someString";
-
-var projection = (value => "" + value) as function(value as string`borrow) as string;
-val e = new string[,,]<string>(
-    d, 
-    (value => "137" + value + someString) as function(value as string`borrow) as string
-);
-
-
-val aSomeArray = new string[](5, "HelloWorld");
-val bSomeArray = new string[]<string>(aSomeArray, projection);
-println("HelloWorldProjectedArray");
-println(bSomeArray[1]);
-
-println(e[2,3,4]);
-
-
-val constructorLambdaArray = new string[](5, i => "No" + i);
-println(constructorLambdaArray[1]);
-
-val constructorLambdaArrayMulti = new string[,](5, 5, (i1, i2) => "No" + i1 + i2);
-println(constructorLambdaArrayMulti[1, 2]);
-
-
-val testArray = new string[,](5, 5, "helloWorld");
-
-val indexedProjectionWithLambdaNonInlined = new string[,]<string>(testArray as string[,], (index1, index2, value) => {
-    return value + "" + index1 + index2;
-} as function(index1 as usize, index2 as usize, value as string`borrow) as string);
-
-val indexedProjectionWithLambdaInlined = new string[,]<string>(testArray, ((i as usize, j as usize, s as string`borrow) => (s + "" + i + j) as string) as function(i as usize, j as usize, s as string`borrow) as string);
-
-println(indexedProjectionWithLambdaNonInlined[1, 2]);
-println(indexedProjectionWithLambdaInlined[1, 2]);

ScriptingExample/scripts/classes.zs

-public class myTestClass {
-
-	var nonFinalInt as int = 10;
-	val finalInt as int = 20;
-
-	static var staticNonFinalInt as int = 10;
-
-	public this() {
-
-	}
-
-	public this(nonfinalInt as int) {
-		this.nonFinalInt = nonfinalInt;
-		println(nonfinalInt);
-	}
-
-	public test() as string {
-		return "TEST";
-	}
-}
-
-
-
-val tt = new myTestClass(666);
-println(tt.test());
-
-public interface myTestInterface {
-	test() as string;
-}
-
-
-public enum myTestEnum {
-	ADD(6),
-    SUB(6),
-    MUL(7),
-    DIV(7),
-    MOD(7),
-    CAT(6),
-    OR(4),
-    AND(4),
-    XOR(4),
-    NEG(8),
-    NOT(8),
-    INVERT(8),
-    CONTAINS(5),
-    COMPARE(5),
-    ASSIGN(0),
-    ADDASSIGN(0),
-    SUBASSIGN(0),
-    MULASSIGN(0),
-    DIVASSIGN(0),
-    MODASSIGN(0),
-    CATASSIGN(0),
-    ORASSIGN(0),
-    ANDASSIGN(0),
-    XORASSIGN(0),
-    ANDAND(3),
-    OROR(2),
-    TERNARY(1),
-    COALESCE(2),
-    INCREMENT(8),
-    DECREMENT(8),
-    MEMBER(9),
-    RANGE(9),
-    INDEX(9),
-    CALL(9),
-    CAST(9),
-    PRIMARY(10);
-
-	private val priority as int;
-	private val isCommutative as bool;
-
-	public static val test as int = 10;
-
-	this(i as int) {
-		this(i, false);
-	}
-
-	this(i as int, isCommutative as bool) {
-		this.priority = i;
-		this.isCommutative = isCommutative;
-		}
-}

ScriptingExample/scripts/conditionals.zs

-val ternaryOperation = true ? 100 : 222;
-
-println(ternaryOperation);
-
-
-
-var coalesce_one as string? = null;
-var coalesce_tow as string? = "test";
-
-
-var coalesce = coalesce_one ?? coalesce_tow;
-
-println(coalesce);
-
-
-//if(coalesce == "test123") {
-//	println("true");
-//}
-
-if 1 == 1 {
-	println("intCompareTrue");
-}
-
-//if(1 == "1") {
-//	println("well...");
-//}
-
-
-if "1" == 1 {
-	println("...");
-}
-
-
-//var coco as int? = 10;
-//var coal as int? = 1;
-//
-//println(coal ?? coco);
-
-
-println(".....");
-println(true ? "RR" : "TT");
-
-
-println((false && true && true) ? "true" : "false");
-println((true && true) ? "true" : "false");
-println((true && false) ? "true" : "false");
-println((false && false) ? "true" : "false");
-
-println("---");
-
-println((false || true) ? "true" : "false");
-println((true || true) ? "true" : "false");
-println((true || false) ? "true" : "false");
-println((false || false) ? "true" : "false");
-
-println(":::");
-
-println((1 <= 2) ? "true" : "false");

ScriptingExample/scripts/functionalInterfaces.zs

-//val x = ((a as string) => "hello" + a) as function`auto(a as string) as string`auto;
-//invokeFunctional(x);
-
-val y = (a as int, b as int) => a + b;
-
-
-//invokeFunctionalInt((a, b) => a + b);
-invokeFunctionalInt(y);
-
-
-println(((x as int) => x)(10));
-
-//TODO: Globals can't be "captured"
-//invokeFunctionalInt((a, b) => {
-//	println("a");
-//	return a + b;
-//});

ScriptingExample/scripts/functions.zs

-function test() as void {
-	println("functions.zs; test1");
-}
-
-
-
-function test2() as void {
-	println("functions.zs; test2");
-}
-
-
-test();
-test2();
-println(test3(1, 3));
-
-
-function test3(a as int, b as int) as int{
-	println(a+b);
-	return a + b;
-}

ScriptingExample/scripts/functions2.zs

-val outOfScope = 10;
-
-val fun = (a as int, b as int) as int => a + b * outOfScope;
-println(fun(30, 20));
-
-function apply_fn2(fn as function(value as int, othervalue as int) as int, value as int) as int {
-    return fn(value, value);
-}
-
-//function scale(value as int, scale as int) as int {
-
-//	val fun as function(value as int, othervalue as int) as int = ((v as int) as int => v * scale);
-//    return apply(fun, scale);
-//}
-
-apply_fn2(fun, 10);
-
-//println("Value: " + scale(10, 5));
-

ScriptingExample/scripts/functions3.zs

-function apply2(fn as function(value as int) as int, scale as int) as int {
    return fn(scale);
}

function scale2(value as int, scale as int) as int {
    return apply2(v => v * scale, value);
}

ScriptingExample/scripts/functions_lambdas.zs

-val outOfScope = 10;
-val fun1 = (a as int, b as int) as int => a + b * outOfScope;
-val fun2 = (a as int, c as int) as int => 13;
-
-
-
-function apply(fn as function(value as int) as int, scale as int) as int {
-    return fn(scale);
-}
-
-
-println(fun1(30, 20));
-println(fun2(30, 20));
-
-
-
-
-function scale(value as int, scale as int) as int {
-    return apply(v => v * scale, value);
-}
-
-println("Value: " + scale(10, 5));

ScriptingExample/scripts/helloworld.zs

-println("Hello \© world!");
-println(5);
-println(2 + 5);
-println(1 - 2);
-println(1 + 3 as long);
-
-println(<hello world in bracket parser>);
-
-
-var a = null as string?;
-if (a == null)
-	println("A is null!");

ScriptingExample/scripts/integration.zs

-import example.TestClass;
-import example.TestInterface;
-
-val instance = new TestClass("Instance");
-println("Name: " + instance.name);
-instance.dump();
-instance.withDefaultParameter("Hello");
-instance.withDefaultParameter("Hello", "moon");
-
-var generated = instance.generate();
-println(generated.getValue());
-
-class TestOperators {
-	public (name as string) as void {
-		println("MyTestClass: " + name);
-	}
-	
-	//.(key as string) as string
-	//	=> "key " + key;
-}
-
-/*class TestImplementation {
-	public implements TestInterface {
-		interfaceMethod() => "TestImplementation";
-	}
-}*/
-
-val testInstance = new TestOperators();
-//testInstance("something");
-
-something.dump();
-
-val objects = makeArray(5);
-printMany(objects);
-
-
-println(<test string>);
-println(<test string>.name);
-println(<test string>.interfaceMethod());
-//println(new TestImplementation().interfaceMethod());
-
-var diamond = <item:minecraft:diamond>;
-var dirt = <item:minecraft:dirt>;
-addShapedRecipe("TestRecipe", diamond, [[dirt, dirt, dirt],[dirt, dirt, dirt],[dirt, dirt, dirt]]);
-
-var count = 10;
-floatMethod(5f * count);
-
-invokeFunctional(name => "Hello " + name);
-
-//val x = (a as string) => "hello" + a;
-//invokeFunctional(x);
-
-testOptional(value => value == null ? 0 : value.length as int);

ScriptingExample/scripts/interfaces.zs

-public interface MyInterface {
-	interfaceMethod() as string;
-}
-
-public class MyClass {
-	val name as string;
-	
-	public this(name as string) {
-		this.name = name;
-	}
-
-	public implements MyInterface {
-		interfaceMethod() => "InterfaceMethod " + name;
-	}
-}
-
-println(new MyClass("hello").interfaceMethod());

ScriptingExample/scripts/moreHellos.zs

-println("Hello world!");
-println(1 as string);
-
-
-var test = "test";
-println(test);
-
-
-test = "testMore";
-println(test);
-
-test = 13;
-println(test);
-
-val test2 = 14;
-println(test2);
-
-
-if true 
-    println("ifTest");
-else
-    println("elseTest");
-
-
-if false 
-    println("testIf");
-else
-    println("testElse");
-
-
-if (true) {
-
-    while :testLable true {
-        println("trueee");
-        if true
-            break testLable;
-        else
-            println("nobreak");
-    }
-    
-    
-    do {
-        println("tru"); 
-        if(false){
-        	println("brea");
-            continue;
-        }
-        else{
-            println("");
-            break;
-        }
-    } while true;
-}
-
-var testArray = ["1", "2", "3"];
-
-for item in testArray {
-	println("test");
-	println(item);
-}
-
-println("");
-
-var test3 = [1, 2, 3];
-
-for item in test3 {
-	println(item);
-}
-
-for i, item in ["5", "ttt"] {
-	println(item + i);
-}
-
-for i, item in [1, 5, 7] {
-	println(item + (i as int));
-}
-
-for myI in 10 .. 20 {
-	println(myI);
-}
-
-var lateInit as string;
-lateInit = "initialized later";
-println(lateInit);
-
-
-
-
-
-/*
-catch e as string {
-	println("noLuv");
-}
-*/

ScriptingExample/scripts/scriptparameters.zs

-println("Arguments:");
-for i, arg in args
-	println("- " + i + ": " + arg);

ScriptingExample/scripts/statements.zs

-//while true
-//	println("Hello!");

ScriptingExample/scripts/switch.zs

-val test as int = 10;
-
-
-switch test {
-	case 1 : println("yay"); break;
-	case 10 : println("yo");
-	case 100 : println("y");
-	default: println("yup");
-}
-
-
-val test2 as string = "hello";
-
-switch test2 {
-	case "bye" : println("hello");
-	case "hello" : println("goodbye");
-	default: println("hellogoodbye");
-}

ScriptingExample/scripts/variants.zs

-public variant Result<T, E> {
-    Ok(T),
-    Error(E),
-    Other(T, E);
-    
-    /*public then<R>(fn as function(result as T) as Result<R, E>) as Result<R, E> {
-        return match this {
-            Ok(result) => fn(result),
-            Error(error) => Error(error),
-			Other(result, error) => fn(result)
-        };
-    }*/
-    
-    //public handle<X>(handler as function(error as E) as Result<T, X>) as Result<T, X> {
-    //    return match this {
-    //        Ok(result) => Ok(result),
-    //        Error(error) => handler(error)
-    //    };
-    //}
-    
-    public expect() as T {
-        return match this {
-            Ok(result) => result,
-            Error(error) => panic "expect() called on an error value",
-			Other(result, error) => result
-        };
-    }
-    
-    public orElse(other as T) as T {
-        return match this {
-            Ok(result) => result,
-            Error(error) => other,
-			Other(result, error) => result
-        };
-    }
-    
-    public orElse(other as function(error as E) as T) as T {
-        return match this {
-            Ok(result) => result,
-            Error(error) => other(error),
-			Other(result, error) => result
-        };
-    }
-}
-
-
-
-function makeResult() as Result<string, string>
-    => Ok("10");
-
-
-function makeErrResult() as Result<string, string>
-    => Error("10");
-
-
-println(makeResult().orElse("Ten"));
-println(makeResult().expect());
-println(makeErrResult().orElse("Ten"));
-
-
-//CompileException [TYPE_ARGUMENTS_NOT_INFERRABLE] Could not infer generic type parameters [ParsedExpressionFunction.compile, line 75]
-//println(makeResult().then(tValue => Result<string, string>.Ok(tValue)).expect());
-
-//IllegalArgumentException: Cannot retrieve members of undetermined type [TypeMembers.<init>, line 71]
-//println(makeResult().then(a => Ok(a)).expect());
-//println(makeResult().then(a as string => Ok(a)).expect());
-
-//CompileException [UNEXPECTED_TOKEN] ) expected [LLparserTokenStream.required, line 97]
-//Wants to compile a call to function() instead of creating a lambda
-//println(makeResult().then((function (t as string) as Result<string, string>)(t => Ok(t))).expect());