Fixed more bugs in the new type system; fixed bugs in function calls; fixed normalization bugs.

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

 		for (IDefinitionMember member : members) {
 			if (member instanceof DestructorMember)
 				isDestructible = true;
-			if ((member instanceof FieldMember) && ((FieldMember)member).type.isDestructible())
-				isDestructible = true;
+			if (member instanceof FieldMember) {
+				FieldMember field = (FieldMember)member;
+				if (!field.type.isDefinition(this) && field.type.isDestructible())
+					isDestructible = true;
+			}
 			if ((member instanceof ImplementationMember) && ((ImplementationMember)member).type.isDestructible())
 				isDestructible = true;
 		}

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

 	}
 	
 	public ScriptBlock normalize(TypeScope scope) {
-		List<Statement> result = new ArrayList<>();
+		List<Statement> normalized = new ArrayList<>();
 		for (Statement statement : statements) {
-			result.add(statement.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class)));
+			normalized.add(statement.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class)));
 		}
-		return new ScriptBlock(pkg, result);
+		ScriptBlock result = new ScriptBlock(pkg, normalized);
+		result.addAllTagsFrom(this);
+		return result;
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/ConditionalExpression.java

 			StoredType type) {
 		super(position, type, binaryThrow(position, condition.thrownType, binaryThrow(position, ifThen.thrownType, ifElse.thrownType)));
 		
-		if (ifThen.type != ifElse.type)
+		if (!ifThen.type.equals(ifElse.type))
 			throw new AssertionError();
 		
 		this.condition = condition;

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

 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.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
+import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.expression.LambdaClosure;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 		if (outer == null) {
 			if (name.hasNoArguments()) {
 				for (FunctionParameter parameter : header.parameters) {
-					if (parameter.name.equals(name.name))
+					if (parameter.name.equals(name.name)) {
+						if (parameter.type.isBasic(BasicTypeID.UNDETERMINED))
+							throw new CompileException(position, CompileExceptionCode.CALL_NO_VALID_METHOD, "parameter with undetermined type");
+						
 						return new GetFunctionParameterExpression(position, parameter);
+					}
 				}
 			}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/VariableID.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.statement;
+
+import org.openzen.zencode.shared.Taggable;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class VariableID extends Taggable {
+	
+}

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

 	public boolean isDestructible() {
 		return false; // TODO: actually depends on the type..?
 	}
+	
+	@Override
+	public boolean isGeneric() {
+		return true;
+	}
 
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {

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

 import java.util.Map;
 import java.util.Objects;
 import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
-import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
 		return this.type == type;
 	}
 	
+	public boolean isGeneric() {
+		return type.isGeneric();
+	}
+	
 	public StoredType withoutOptional() {
 		return new StoredType(type.withoutOptional(), storage);
 	}
 		return type.isEnum();
 	}
 	
+	public boolean isDefinition(HighLevelDefinition definition) {
+		return type.isDefinition(definition);
+	}
+	
 	public DefinitionTypeID asDefinition() {
 		return (DefinitionTypeID)type;
 	}

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

 import java.util.List;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 		return false;
 	}
 	
+	default boolean isGeneric() {
+		return false;
+	}
+	
 	default TypeID withoutOptional() {
 		throw new UnsupportedOperationException("Not an optional type");
 	}
 		return false;
 	}
 	
+	default boolean isDefinition(HighLevelDefinition definition) {
+		return false;
+	}
+	
 	default String toString(StorageTag storage) {
 		if (storage == ValueStorageTag.INSTANCE)
 			return toString();

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

 	INT_INC,
 	INT_DEC,
 	INT_ADD_INT,
+	INT_ADD_USIZE,
 	INT_SUB_INT,
 	INT_MUL_INT,
 	INT_DIV_INT,

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

 		dec(builtin, INT_INC, INT);
 
 		add(builtin, INT_ADD_INT, INT, INT);
-		add(builtin, LONG_ADD_LONG, USIZE, LONG, INT_TO_LONG);
 		add(builtin, LONG_ADD_LONG, LONG, LONG, INT_TO_LONG);
 		add(builtin, FLOAT_ADD_FLOAT, FLOAT, FLOAT, INT_TO_FLOAT);
 		add(builtin, DOUBLE_ADD_DOUBLE, DOUBLE, DOUBLE, INT_TO_DOUBLE);

Constructor/src/main/java/org/openzen/zenscript/constructor/module/DirectoryModuleReference.java

 import org.openzen.zenscript.constructor.ModuleLoader;
 import org.openzen.zenscript.codemodel.type.TypeSymbol;
 import org.openzen.zenscript.codemodel.type.storage.StorageType;
+import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.ParsedFile;
 
 /**
 			return result;
 		} catch (IOException ex) {
 			throw new ConstructorException("Loading module files failed: " + ex.getMessage(), ex);
+		} catch (ParseException ex) {
+			throw new ConstructorException("Loading module files failed: " + ex.getMessage(), ex);
 		}
 	}
 	

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

 
 			if (!checkAndExecuteMethodInfo(expression.member, expression.type))
 				throw new IllegalStateException("Call target has no method info!");
-			//if (expression.member.getHeader().returnType != expression.type)
-
-			//TODO see if the types differ (e.g. if a generic method was invoked) and only cast then
-			if(expression.type.type != BasicTypeID.VOID)
+			
+			if (expression.member.getTarget().header.getReturnType().isGeneric())
 				javaWriter.checkCast(context.getInternalName(expression.type));
+			
 			return null;
 		}
 
 						JavaMethod.getNativeVirtual(
 								JavaClass.fromInternalName(context.getInternalName(expression.target.type), JavaClass.Kind.INTERFACE),
 								"accept",
-								context.getMethodSignature(expression.instancedHeader)));
+								context.getMethodDescriptor(expression.instancedHeader)));
 				break;
 			case AUTOOP_NOTEQUALS:
 				throw new UnsupportedOperationException("Not yet supported!");
 				javaWriter.invokeStatic(INTEGER_TO_STRING);
 				break;
 			case INT_TO_BYTE:
+			case USIZE_TO_BYTE:
 				break;
 			case INT_TO_SBYTE:
+			case USIZE_TO_SBYTE:
 				javaWriter.i2b();
 				break;
 			case INT_TO_SHORT:
+			case USIZE_TO_SHORT:
 				javaWriter.i2s();
 				break;
 			case INT_TO_USHORT:
+			case USIZE_TO_USHORT:
 				break;
 			case INT_TO_UINT:
+			case USIZE_TO_INT:
+			case USIZE_TO_UINT:
 			case INT_TO_USIZE:
 				break;
 			case INT_TO_LONG:
 			case INT_TO_ULONG:
+			case USIZE_TO_LONG:
+			case USIZE_TO_ULONG:
 				javaWriter.i2l();
 				break;
 			case INT_TO_FLOAT:
+			case USIZE_TO_FLOAT:
 				javaWriter.i2f();
 				break;
 			case INT_TO_DOUBLE:
+			case USIZE_TO_DOUBLE:
 				javaWriter.i2d();
 				break;
 			case INT_TO_CHAR:
+			case USIZE_TO_CHAR:
 				javaWriter.i2s();
 				break;
 			case INT_TO_STRING:
+			case USIZE_TO_STRING:
 				javaWriter.invokeStatic(INTEGER_TO_STRING);
 				break;
 			case UINT_TO_BYTE:
             ((ReturnStatement) expression.body).value.accept(this);
             return null;
         }
+		
+		final String descriptor = context.getMethodDescriptor(expression.header);
         final String signature = context.getMethodSignature(expression.header);
 		final String name = context.getLambdaCounter();
 
-		final JavaMethod methodInfo = JavaMethod.getNativeVirtual(javaWriter.method.cls, "accept", signature);
+		final JavaMethod methodInfo = JavaMethod.getNativeVirtual(javaWriter.method.cls, "accept", descriptor);
 		final ClassWriter lambdaCW = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 		lambdaCW.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, name, null, "java/lang/Object", new String[]{context.getInternalName(new FunctionTypeID(null, expression.header).stored(UniqueStorageTag.INSTANCE))});
 		final JavaWriter functionWriter = new JavaWriter(lambdaCW, methodInfo, null, signature, null, "java/lang/Override");
 
 	@Override
 	public Void visitNull(NullExpression expression) {
-		if (expression.type.type.withoutOptional() == BasicTypeID.USIZE)
+		if (!expression.type.isBasic(BasicTypeID.NULL) && expression.type.type.withoutOptional() == BasicTypeID.USIZE)
 			javaWriter.constant(-1); // special case: usize? null = -1
 		else
 			javaWriter.aConstNull();

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

         if (debug)
             System.out.println("--end--");
 
-        visitor.visitMaxs(0, 0);
+		try {
+	        visitor.visitMaxs(0, 0);
+		} catch (ArrayIndexOutOfBoundsException ex) {
+			throw ex;
+		}
+		
         if (nameVariables) {
             for (JavaLocalVariableInfo info : localVariableInfos) {
                 nameVariable(info.local, info.name, info.start, info.end, info.type);
 
     public void aConstNull() {
         if (debug)
-            System.out.println("null");
+            System.out.println("aConstNull");
 
         visitor.visitInsn(ACONST_NULL);
     }
             keys[i] = switchLabels[i].key;
             labels[i] = switchLabels[i].label;
         }
+		
+		if (debug) {
+			System.out.println("lookupSwitch");
+			for (int i = 0; i < switchLabels.length; i++) {
+				System.out.println("  " + keys[i] + " -> " + getLabelName(labels[i]));
+			}
+			System.out.println("  default -> " + getLabelName(defaultLabel));
+		}
 
         visitor.visitLookupSwitchInsn(defaultLabel, keys, labels);
     }

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

 		String id = typeInfo.primitive ? type.accept(null, new JavaSyntheticTypeSignatureConverter()) : "T";
 		JavaSynthesizedRange range;
 		if (!ranges.containsKey(id)) {
-			JavaClass cls = new JavaClass("zsynthetic", id + "Range", JavaClass.Kind.CLASS);
+			JavaClass cls = new JavaClass("zsynthetic", id, JavaClass.Kind.CLASS);
 			if (typeInfo.primitive) {
 				range = new JavaSynthesizedRange(cls, TypeParameter.NONE, type.baseType);
 			} else {

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

 	public final boolean genericResult;
 	
 	public JavaMethod(JavaClass cls, Kind kind, String name, boolean compile, String descriptor, int modifiers, boolean genericResult) {
+		if (descriptor.contains("<")) // fix signature bug
+			throw new IllegalArgumentException("Invalid descriptor!");
+		
 		this.cls = cls;
 		this.kind = kind;
 		this.name = name;

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

  */
 package org.openzen.zenscript.javasource;
 
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.StringExpansion;
 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
+import org.openzen.zenscript.codemodel.statement.VariableID;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 	
 	@Override
 	public ExpressionString visitCast(CastExpression expression) {
-		if (expression.member.member.builtin != null)
-			return visitBuiltinCast(expression);
+		if (expression.member.member.builtin != null) {
+			try {
+				return visitBuiltinCast(expression);
+			} catch (CompileException ex) {
+				throw new RuntimeException(ex);
+			}
+		}
 		
 		JavaMethod method = expression.member.getTag(JavaMethod.class);
 		if (method == null)
 
 	@Override
 	public ExpressionString visitNew(NewExpression expression) {
-		if (expression.constructor.getBuiltin() != null)
-			return visitBuiltinConstructor(expression);
+		if (expression.constructor.getBuiltin() != null) {
+			try {
+				return visitBuiltinConstructor(expression);
+			} catch (CompileException ex) {
+				throw new RuntimeException(ex.toString());
+			}
+		}
 		
 		JavaMethod method = expression.constructor.getTag(JavaMethod.class);
 		switch (method.kind) {
 	}
 	
 	private Expression hoist(Expression value) {
-		VarStatement temp = new VarStatement(value.position, scope.createTempVariable(), value.type, value, true);
+		VarStatement temp = new VarStatement(value.position, new VariableID(), scope.createTempVariable(), value.type, value, true);
 		new JavaSourceStatementFormatter(scope).formatVar(target, temp);
 		return new GetLocalVariableExpression(value.position, temp);
 	}
 		throw new UnsupportedOperationException("Unknown builtin static getter: " + builtin);
 	}
 	
-	private ExpressionString visitBuiltinCast(CastExpression cast) {
+	private ExpressionString visitBuiltinCast(CastExpression cast) throws CompileException {
 		switch (cast.member.member.builtin) {
 			case BOOL_TO_STRING: return callStatic("Boolean.toString", cast.target);
 			case BYTE_TO_SBYTE: return cast(cast, "byte");
 		throw new UnsupportedOperationException("Unknown builtin cast: " + cast.member.member.builtin);
 	}
 	
-	private ExpressionString visitBuiltinConstructor(NewExpression expression) {
+	private ExpressionString visitBuiltinConstructor(NewExpression expression) throws CompileException {
 		switch (expression.constructor.getBuiltin()) {
 			case STRING_CONSTRUCTOR_CHARACTERS:
 				return callStatic("new String", expression.arguments.arguments[0]);
 							.append(newArray(type.elementType, originalString.unaryPostfix(JavaOperator.MEMBER, ".length")))
 							.append(";")
 							.toString());
-					VarStatement tempI = new VarStatement(expression.position, scope.createTempVariable(), BasicTypeID.INT.stored, null, true);
+					VarStatement tempI = new VarStatement(expression.position, new VariableID(), scope.createTempVariable(), BasicTypeID.INT.stored, null, true);
 					target.writeLine(new StringBuilder()
 							.append("for (int ")
 							.append(tempI.name)
 							.append(newArray(type.elementType, originalString.unaryPostfix(JavaOperator.MEMBER, ".length")))
 							.append(";")
 							.toString());
-					VarStatement tempI = new VarStatement(expression.position, scope.createTempVariable(), BasicTypeID.INT.stored, null, true);
+					VarStatement tempI = new VarStatement(expression.position, new VariableID(), scope.createTempVariable(), BasicTypeID.INT.stored, null, true);
 					target.writeLine(new StringBuilder()
 							.append("for (int ")
 							.append(tempI.name)

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

 		StatementScope innerScope = new LambdaScope(scope, closure, header);
 		Statement statements = body.compile(innerScope, header);
 		
-		if (header.getReturnType().isBasic(BasicTypeID.UNDETERMINED))
+		if (header.getReturnType().isBasic(BasicTypeID.UNDETERMINED)) {
+			StoredType returnType = statements.getReturnType();
+			if (returnType == null)
+				throw new CompileException(position, CompileExceptionCode.CANNOT_INFER_RETURN_TYPE, "Could not infer return type");
+			
 			header.setReturnType(statements.getReturnType());
+		}
 		
 		if (!scope.genericInferenceMap.isEmpty()) {
 			// perform type parameter inference

Validator/src/main/java/org/openzen/zenscript/validator/visitors/ExpressionValidator.java

 		expression.left.accept(this);
 		expression.right.accept(this);
 		
-		if (!expression.left.type.type.isBasic(BasicTypeID.BOOL)) {
+		if (!expression.left.type.isBasic(BasicTypeID.BOOL)) {
 			validator.logError(
 					ValidationLogEntry.Code.INVALID_OPERAND_TYPE,
 					expression.position,
 					"left hand side operand of && must be a bool");
 		}
-		if (!expression.right.type.type.isBasic(BasicTypeID.BOOL)) {
+		if (!expression.right.type.isBasic(BasicTypeID.BOOL)) {
 			validator.logError(
 					ValidationLogEntry.Code.INVALID_OPERAND_TYPE,
 					expression.position,
 		expression.condition.accept(this);
 		expression.ifThen.accept(this);
 		expression.ifElse.accept(this);
-		if (!expression.condition.type.type.isBasic(BasicTypeID.BOOL)) {
+		if (!expression.condition.type.isBasic(BasicTypeID.BOOL)) {
 			validator.logError(ValidationLogEntry.Code.INVALID_OPERAND_TYPE, expression.position, "conditional expression condition must be a bool");
 		}
 		return null;