WIP on storage tags and improved error handling

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/DefinitionFormatter.java

 				for (int i = 0; i < option.types.length; i++) {
 					if (i > 0)
 						output.append(", ");
-					output.append(option.types[i].accept(typeFormatter));
+					output.append(typeFormatter.format(option.types[i]));
 				}
 			}
 		}

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/ExpressionFormatter.java

 		result.append(expression.target.accept(this).value);
 		if (!expression.isImplicit) {
 			result.append(" as ");
-			result.append(expression.member.toType.accept(typeFormatter));
+			result.append(typeFormatter.format(expression.member.toType));
 		}
 		return new ExpressionString(result.toString(), ZenScriptOperator.PRIMARY);
 	}
 	@Override
 	public ExpressionString visitConst(ConstExpression expression) {
 		StringBuilder result = new StringBuilder();
-		result.append(expression.type.accept(typeFormatter));
+		result.append(typeFormatter.format(expression.type));
 		result.append('.');
 		result.append(expression.constant.member.name);
 		return new ExpressionString(result.toString(), ZenScriptOperator.MEMBER);
 
 	@Override
 	public ExpressionString visitEnumConstant(EnumConstantExpression expression) {
-		return new ExpressionString(expression.type.accept(typeFormatter) + "." + expression.value.name, ZenScriptOperator.MEMBER);
+		return new ExpressionString(typeFormatter.format(expression.type) + "." + expression.value.name, ZenScriptOperator.MEMBER);
 	}
 
 	@Override
 	@Override
 	public ExpressionString visitGetStaticField(GetStaticFieldExpression expression) {
 		StringBuilder result = new StringBuilder();
-		result.append(expression.type.accept(typeFormatter));
+		result.append(typeFormatter.format(expression.type));
 		result.append('.');
 		result.append(expression.field.member.name);
 		return new ExpressionString(result.toString(), ZenScriptOperator.MEMBER);
 		StringBuilder result = new StringBuilder();
 		result.append(expression.value.accept(this).value);
 		result.append(" as ");
-		result.append(expression.type.accept(typeFormatter));
+		result.append(typeFormatter.format(expression.type));
 		return new ExpressionString(result.toString(), ZenScriptOperator.CAST);
 	}
 
 		StringBuilder result = new StringBuilder();
 		result.append(expression.value.accept(this).value);
 		result.append(" is ");
-		result.append(expression.type.accept(typeFormatter));
+		result.append(typeFormatter.format(expression.type));
 		return new ExpressionString(result.toString(), ZenScriptOperator.IS);
 	}
 
 	public ExpressionString visitNew(NewExpression expression) {
 		StringBuilder result = new StringBuilder();
 		result.append("new ");
-		result.append(expression.type.accept(typeFormatter));
+		result.append(typeFormatter.format(expression.type));
 		FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
 		return new ExpressionString(result.toString(), ZenScriptOperator.PRIMARY);
 	}
 	@Override
 	public ExpressionString visitSetStaticField(SetStaticFieldExpression expression) {
 		return new ExpressionString(
-				expression.type.accept(typeFormatter) + "." + expression.field.member.name + " = " + expression.value.accept(this).value,
+				typeFormatter.format(expression.type) + "." + expression.field.member.name + " = " + expression.value.accept(this).value,
 				ZenScriptOperator.ASSIGN);
 	}
 
 	@Override
 	public ExpressionString visitStaticGetter(StaticGetterExpression expression) {
 		return new ExpressionString(
-				expression.type.accept(typeFormatter) + "." + expression.getter.member.name, 
+				typeFormatter.format(expression.type) + "." + expression.getter.member.name, 
 				ZenScriptOperator.MEMBER);
 	}
 
 	@Override
 	public ExpressionString visitStaticSetter(StaticSetterExpression expression) {
 		return new ExpressionString(
-				expression.type.accept(typeFormatter) + "." + expression.setter.member.name + " = " + expression.setter.member.name,
+				typeFormatter.format(expression.type) + "." + expression.setter.member.name + " = " + expression.setter.member.name,
 				ZenScriptOperator.ASSIGN);
 	}
 	

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/FormattingUtils.java

 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.statement.WhileStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 			if (parameter.variadic)
 				result.append("...");
 			
-			if (!settings.showAnyInFunctionHeaders || parameter.type != BasicTypeID.UNDETERMINED) {
+			if (!settings.showAnyInFunctionHeaders || !parameter.type.isBasic(BasicTypeID.UNDETERMINED)) {
 				result.append(" as ");
-				result.append(header.getReturnType().accept(typeFormatter));
+				result.append(typeFormatter.format(header.getReturnType()));
 			}
 			
 			parameterIndex++;
 		}
 		result.append(")");
-		if (!settings.showAnyInFunctionHeaders || header.getReturnType() != BasicTypeID.UNDETERMINED) {
+		if (!settings.showAnyInFunctionHeaders || !header.getReturnType().isBasic(BasicTypeID.UNDETERMINED)) {
 			result.append(" as ");
-			result.append(header.getReturnType().accept(typeFormatter));
+			result.append(typeFormatter.format(header.getReturnType()));
 		}
 	}
 	
 			result.append("<");
 			
 			int index = 0;
-			for (ITypeID typeArgument : arguments.typeArguments) {
+			for (TypeID typeArgument : arguments.typeArguments) {
 				if (index > 0)
 					result.append(", ");
 				result.append(typeArgument.accept(typeFormatter));

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/MemberFormatter.java

 		output.append("const")
 				.append(member.name)
 				.append(" as ")
-				.append(member.type.accept(typeFormatter))
+				.append(typeFormatter.format(member.type))
 				.append(" = ")
 				.append(member.value.accept(new ExpressionFormatter(settings, typeFormatter, indent)))
 				.append(";\n");
 		output.append(member.isFinal() ? "val " : "var ")
 				.append(member.name)
 				.append(" as ")
-				.append(member.type.accept(typeFormatter));
+				.append(typeFormatter.format(member.type));
 		
 		if (member.initializer != null) {
 			output.append(" = ")
 		output.append("get ");
 		output.append(member.name);
 		output.append(" as ");
-		output.append(member.type.accept(typeFormatter));
+		output.append(typeFormatter.format(member.type));
 		formatBody(member.body);
 		return null;
 	}
 		output.append("set ");
 		output.append(member.name);
 		output.append(" as ");
-		output.append(member.type.accept(typeFormatter));
+		output.append(typeFormatter.format(member.type));
 		formatBody(member.body);
 		return null;
 	}
 		visit(false);
 		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
 		output.append(" as ");
-		output.append(member.toType.accept(typeFormatter));
+		output.append(typeFormatter.format(member.toType));
 		formatBody(member.body);
 		return null;
 	}

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/StatementFormatter.java

 		for (CatchClause catchClause : statement.catchClauses) {
 			output.append(indent).append("catch ");
 			if (catchClause.exceptionVariable != null)
-				output.append(catchClause.exceptionVariable.name).append(" as ").append(catchClause.exceptionVariable.type.accept(expressionFormatter.typeFormatter));
+				output.append(catchClause.exceptionVariable.name).append(" as ").append(expressionFormatter.typeFormatter.format(catchClause.exceptionVariable.type));
 			
 			format(ParentStatementType.CATCH, catchClause.content);
 		}
 		
 		if (statement.initializer == null || statement.initializer.type != statement.type) {
 			output.append(" as ");
-			output.append(statement.type.accept(expressionFormatter.typeFormatter));
+			output.append(expressionFormatter.typeFormatter.format(statement.type));
 		}
 		if (statement.initializer != null) {
 			output.append(" = ");

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/TypeFormatter.java

 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
+import org.openzen.zenscript.codemodel.type.TypeID;
 import stdlib.Chars;
 import org.openzen.zenscript.codemodel.type.TypeVisitor;
 
 		this.settings = settings;
 		this.importer = importer;
 	}
+	
+	public String format(TypeID type) {
+		return type.accept(this);
+	}
+	
+	public String format(StoredType type) {
+		return type.type.accept(this) + "`" + type.storage.toString();
+	}
 
 	@Override
 	public String visitBasic(BasicTypeID basic) {
 	
 	@Override
 	public String visitString(StringTypeID string) {
-		if (string.storage == null)
-			return "string";
-		else
-			return "string`" + string.storage.toString();
+		return "string";
 	}
 
 	@Override
 	public String visitArray(ArrayTypeID array) {
-		String element = array.elementType.accept(this);
+		String element = format(array.elementType);
 		String result;
 		if (array.dimension == 1) {
 			result = element + "[]";
 		} else {
 			result = element + "[" + Chars.times(',', array.dimension - 1) + "]";
 		}
-		if (array.storage == null)
-			return result;
-		
-		return result + '`' + array.storage.toString();
+		return result;
 	}
 
 	@Override
 	public String visitAssoc(AssocTypeID assoc) {
-		String result = assoc.valueType.accept(this) + "[" + assoc.keyType.accept(this) + "]";
-		if (assoc.storage == null)
-			return result;
-		
-		return result + '`' + assoc.storage.toString();
+		return format(assoc.valueType) + "[" + format(assoc.keyType) + "]";
 	}
 
 	@Override
 		StringBuilder result = new StringBuilder();
 		result.append("function");
 		FormattingUtils.formatHeader(result, settings, function.header, this);
-		
-		if (function.storage != null) {
-			result.append('`');
-			result.append(function.storage.toString());
-		}
-		
 		return result.toString();
 	}
 
 		result.append(importedName);
 		result.append("<");
 		int index = 0;
-		for (ITypeID typeParameter : definition.typeArguments) {
+		for (TypeID typeParameter : definition.typeArguments) {
 			if (index > 0)
 				result.append(", ");
 			
 			result.append(typeParameter.accept(this));
 		}
 		result.append(">");
-		
-		if (definition.storage != null) {
-			result.append('`');
-			result.append(definition.storage.toString());
-		}
-		
 		return result.toString();
 	}
 
 	@Override
 	public String visitGeneric(GenericTypeID generic) {
-		if (generic.storage == null)
-			return generic.parameter.name;
-		
-		return generic.parameter.name + '`' + generic.storage.toString();
+		return generic.parameter.name;
 	}
 
 	@Override
 	public String visitRange(RangeTypeID range) {
-		return range.baseType.accept(this) + " .. " + range.baseType.accept(this);
+		return format(range.baseType) + " .. " + format(range.baseType);
 	}
 
 	@Override
 	@Override
 	public String visitGenericMap(GenericMapTypeID map) {
 		StringBuilder result = new StringBuilder();
-		result.append(map.value.accept(this));
+		result.append(format(map.value));
 		result.append("[<");
 		FormattingUtils.formatTypeParameters(result, new TypeParameter[] { map.key }, this);
 		result.append("]>");
-		
-		if (map.storage != null) {
-			result.append('`');
-			result.append(map.storage.toString());
-		}
-		
 		return result.toString();
 	}
 }

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

 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  */
 public class FunctionHeader {
 	public final TypeParameter[] typeParameters;
-	private ITypeID returnType;
+	private StoredType returnType;
 	public final FunctionParameter[] parameters;
-	public final ITypeID thrownType;
+	public final StoredType thrownType;
 	
 	public final int minParameters;
 	public final int maxParameters;
 	public final boolean hasUnknowns;
 	
-	public FunctionHeader(ITypeID returnType) {
+	public FunctionHeader(StoredType returnType) {
 		if (returnType == null)
 			throw new NullPointerException();
 		
 		
 		minParameters = 0;
 		maxParameters = 0;
-		hasUnknowns = returnType == BasicTypeID.UNDETERMINED;
+		hasUnknowns = returnType == BasicTypeID.UNDETERMINED.stored;
 	}
 	
-	public FunctionHeader(ITypeID returnType, ITypeID... parameterTypes) {
+	public FunctionHeader(BasicTypeID returnType) {
+		this(returnType.stored);
+	}
+	
+	public FunctionHeader(StoredType returnType, StoredType... parameterTypes) {
 		if (returnType == null)
 			throw new NullPointerException();
 		
 		hasUnknowns = hasUnknowns(parameterTypes, returnType);
 	}
 	
-	public FunctionHeader(ITypeID returnType, FunctionParameter... parameters) {
+	public FunctionHeader(BasicTypeID returnType, StoredType... parameterTypes) {
+		this(returnType.stored, parameterTypes);
+	}
+	
+	public FunctionHeader(StoredType returnType, FunctionParameter... parameters) {
 		if (returnType == null)
 			throw new NullPointerException();
 		
 		hasUnknowns = hasUnknowns(parameters, returnType);
 	}
 	
-	public FunctionHeader(TypeParameter[] typeParameters, ITypeID returnType, ITypeID thrownType, FunctionParameter... parameters) {
+	public FunctionHeader(BasicTypeID returnType, FunctionParameter... parameters) {
+		this(returnType.stored, parameters);
+	}
+	
+	public FunctionHeader(TypeParameter[] typeParameters, StoredType returnType, StoredType thrownType, FunctionParameter... parameters) {
 		if (returnType == null)
 			throw new NullPointerException();
 		if (typeParameters == null)
 		hasUnknowns = hasUnknowns(parameters, returnType);
 	}
 	
-	public ITypeID getReturnType() {
+	public StoredType getReturnType() {
 		return returnType;
 	}
 	
-	public void setReturnType(ITypeID returnType) {
+	public void setReturnType(StoredType returnType) {
 		if (returnType == null)
 			throw new NullPointerException();
 		
 		return false;
 	}
 	
-	public FunctionHeader withReturnType(ITypeID returnType) {
+	public FunctionHeader withReturnType(StoredType returnType) {
 		return new FunctionHeader(typeParameters, returnType, thrownType, parameters);
 	}
 	
 	public FunctionHeader inferFromOverride(GlobalTypeRegistry registry, FunctionHeader overridden) {
 		TypeParameter[] resultTypeParameters = typeParameters;
-		ITypeID resultReturnType = this.returnType;
-		if (resultReturnType == BasicTypeID.UNDETERMINED)
+		StoredType resultReturnType = this.returnType;
+		if (resultReturnType.type == BasicTypeID.UNDETERMINED)
 			resultReturnType = overridden.returnType;
 		
-		ITypeID resultThrownType = this.thrownType;
+		StoredType resultThrownType = this.thrownType;
 		if (resultThrownType == null && overridden.thrownType != null)
 			resultThrownType = overridden.thrownType;
 		
 		FunctionParameter[] resultParameters = Arrays.copyOf(parameters, parameters.length);
 		for (int i = 0; i < resultParameters.length; i++) {
-			if (resultParameters[i].type == BasicTypeID.UNDETERMINED) {
+			if (resultParameters[i].type.type == BasicTypeID.UNDETERMINED) {
 				FunctionParameter parameter = resultParameters[i];
 				FunctionParameter original = overridden.parameters[i];
 				resultParameters[i] = new FunctionParameter(original.type, parameter.name, parameter.defaultValue, original.variadic);
 		return result.toString();
 	}
 	
-	public ITypeID[] inferTypes(LocalMemberCache cache, CallArguments arguments, List<ITypeID> resultHint) {
+	public TypeID[] inferTypes(LocalMemberCache cache, CallArguments arguments, List<StoredType> resultHint) {
 		if (arguments.arguments.length != this.parameters.length)
 			return null;
 		
-		Map<TypeParameter, ITypeID> mapping = new HashMap<>();
+		Map<TypeParameter, TypeID> mapping = new HashMap<>();
 		if (!resultHint.isEmpty()) {
-			Map<TypeParameter, ITypeID> temp = new HashMap<>();
-			for (ITypeID hint : resultHint) {
-				if (returnType.inferTypeParameters(cache, hint, temp)) {
+			for (StoredType hint : resultHint) {
+				Map<TypeParameter, TypeID> temp = returnType.inferTypeParameters(cache, hint);
+				if (temp != null) {
 					mapping = temp;
 					break;
 				}
 		}
 		
 		// TODO: lambda header inference
-		for (int i = 0; i < parameters.length; i++)
-			if (!parameters[i].type.inferTypeParameters(cache, arguments.arguments[i].type, mapping))
+		for (int i = 0; i < parameters.length; i++) {
+			Map<TypeParameter, TypeID> forParameter = parameters[i].type.inferTypeParameters(cache, arguments.arguments[i].type);
+			if (forParameter == null)
 				return null;
+			
+			mapping.putAll(forParameter);
+		}
 		
 		if (mapping.size() > typeParameters.length)
 			return null;
 		
-		ITypeID[] result = new ITypeID[typeParameters.length];
+		TypeID[] result = new TypeID[typeParameters.length];
 		for (int i = 0; i < typeParameters.length; i++) {
 			TypeParameter typeParameter = typeParameters[i];
 			if (!mapping.containsKey(typeParameter)) {
 			throw new NullPointerException();
 		if (parameters.length != other.parameters.length)
 			return false;
-		if (returnType != BasicTypeID.UNDETERMINED && !scope.getTypeMembers(returnType).canCastImplicit(other.returnType))
+		if (returnType.type != BasicTypeID.UNDETERMINED && !scope.getTypeMembers(returnType).canCastImplicit(other.returnType))
 			return false;
 		
 		for (int i = 0; i < parameters.length; i++) {
-			if (parameters[i].type == BasicTypeID.UNDETERMINED)
+			if (parameters[i].type.type == BasicTypeID.UNDETERMINED)
 				continue;
 			
 			if (parameters[i].variadic != other.parameters[i].variadic)
 	
 	public FunctionHeader instanceForCall(GlobalTypeRegistry registry, CallArguments arguments) {
 		if (arguments.getNumberOfTypeArguments() > 0) {
-			Map<TypeParameter, ITypeID> typeParameters = new HashMap<>();
+			Map<TypeParameter, TypeID> typeParameters = new HashMap<>();
 			for (int i = 0; i < this.typeParameters.length; i++) {
 				typeParameters.put(this.typeParameters[i], arguments.typeArguments[i]);
 			}
 	
 	public FunctionHeader withGenericArguments(GlobalTypeRegistry registry, GenericMapper mapper) {
 		if (typeParameters.length > 0) {
-			Map<TypeParameter, ITypeID> innerMap = new HashMap<>();
+			Map<TypeParameter, TypeID> innerMap = new HashMap<>();
 			for (TypeParameter parameter : typeParameters)
-				innerMap.put(parameter, mapper.registry.getGeneric(parameter, null));
+				innerMap.put(parameter, mapper.registry.getGeneric(parameter));
 			
 			mapper = mapper.getInner(registry, innerMap);
 		}
 		
-		ITypeID returnType = this.returnType.instance(mapper);
+		StoredType returnType = this.returnType.instance(mapper);
 		FunctionParameter[] parameters = new FunctionParameter[this.parameters.length];
 		for (int i = 0; i < parameters.length; i++) {
 			parameters[i] = this.parameters[i].withGenericArguments(mapper);
 		return new FunctionHeader(typeParameters, returnType, thrownType == null ? null : thrownType.instance(mapper), parameters);
 	}
 	
-	public FunctionHeader fillGenericArguments(GlobalTypeRegistry registry, ITypeID[] arguments, GenericMapper typeParameterMapping) {
+	public FunctionHeader fillGenericArguments(GlobalTypeRegistry registry, TypeID[] arguments, GenericMapper typeParameterMapping) {
 		if (arguments == null || arguments.length == 0)
 			return this;
 		
-		Map<TypeParameter, ITypeID> typeArguments = new HashMap<>();
+		Map<TypeParameter, TypeID> typeArguments = new HashMap<>();
 		for (int i = 0; i < typeParameters.length; i++)
 			typeArguments.put(typeParameters[i], arguments[i]);
 		GenericMapper mapper = typeParameterMapping.getInner(registry, typeArguments);
 		
-		ITypeID returnType = this.returnType.instance(mapper);
+		StoredType returnType = this.returnType.instance(mapper);
 		FunctionParameter[] parameters = new FunctionParameter[this.parameters.length];
 		for (int i = 0; i < parameters.length; i++) {
 			parameters[i] = this.parameters[i].withGenericArguments(mapper);
 	}
 	
 	public FunctionHeader forTypeParameterInference() {
-		return new FunctionHeader(BasicTypeID.UNDETERMINED, parameters);
+		return new FunctionHeader(BasicTypeID.UNDETERMINED.stored, parameters);
 	}
 	
 	public FunctionHeader forLambda(FunctionHeader lambdaHeader) {
 		return parameters[parameters.length - 1].variadic ? Integer.MAX_VALUE : parameters.length;
 	}
 	
-	private static boolean hasUnknowns(ITypeID[] types, ITypeID returnType) {
-		if (returnType == BasicTypeID.UNDETERMINED)
+	private static boolean hasUnknowns(StoredType[] types, StoredType returnType) {
+		if (returnType.type == BasicTypeID.UNDETERMINED)
 			return true;
 		
-		for (ITypeID type : types)
-			if (type == BasicTypeID.UNDETERMINED)
+		for (StoredType type : types)
+			if (type.type == BasicTypeID.UNDETERMINED)
 				return true;
 		
 		return false;
 	}
 	
-	private static boolean hasUnknowns(FunctionParameter[] parameters, ITypeID returnType) {
-		if (returnType == BasicTypeID.UNDETERMINED)
+	private static boolean hasUnknowns(FunctionParameter[] parameters, StoredType returnType) {
+		if (returnType.type == BasicTypeID.UNDETERMINED)
 			return true;
 		
 		for (FunctionParameter parameter : parameters)
-			if (parameter.type == BasicTypeID.UNDETERMINED)
+			if (parameter.type.type == BasicTypeID.UNDETERMINED)
 				return true;
 		
 		return false;

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

  */
 package org.openzen.zenscript.codemodel;
 
-import org.openzen.zenscript.codemodel.annotations.Annotation;
 import java.util.Objects;
 import org.openzen.zencode.shared.Taggable;
 import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.annotations.ParameterAnnotation;
 
 /**
  *
 public class FunctionParameter extends Taggable {
 	public static final FunctionParameter[] NONE = new FunctionParameter[0];
 	
-	public Annotation[] annotations;
-	public final ITypeID type;
+	public ParameterAnnotation[] annotations;
+	public final StoredType type;
 	public final String name;
 	public Expression defaultValue;
 	public final boolean variadic;
 	
-	public FunctionParameter(ITypeID type) {
-		this.annotations = Annotation.NONE;
+	public FunctionParameter(StoredType type) {
+		this.annotations = ParameterAnnotation.NONE;
 		this.type = type;
 		this.name = "";
 		this.defaultValue = null;
 		this.variadic = false;
 	}
 	
-	public FunctionParameter(ITypeID type, String name) {
-		this.annotations = Annotation.NONE;
+	public FunctionParameter(BasicTypeID type) {
+		this(type.stored);
+	}
+	
+	public FunctionParameter(StoredType type, String name) {
+		this.annotations = ParameterAnnotation.NONE;
 		this.type = type;
 		this.name = name;
 		this.defaultValue = null;
 		this.variadic = false;
 	}
 	
-	public FunctionParameter(ITypeID type, String name, Expression defaultValue, boolean variadic) {
-		this.annotations = Annotation.NONE;
+	public FunctionParameter(StoredType type, String name, Expression defaultValue, boolean variadic) {
+		this.annotations = ParameterAnnotation.NONE;
 		this.type = type;
 		this.name = name;
 		this.defaultValue = defaultValue;
 	}
 	
 	public FunctionParameter withGenericArguments(GenericMapper mapper) {
-		ITypeID instanced = type.instance(mapper);
+		StoredType instanced = type.instance(mapper);
 		if (instanced == type)
 			return this;
 		
 			return false;
 		}
 		final FunctionParameter other = (FunctionParameter) obj;
-		if (this.variadic != other.variadic) {
-			return false;
-		}
-		if (!Objects.equals(this.type, other.type)) {
-			return false;
-		}
-		return true;
+		return this.variadic == other.variadic && this.type.equals(other.type);
 	}
 }

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

 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 	public static final GenericMapper EMPTY = new GenericMapper(null, Collections.emptyMap());
 	
 	public final GlobalTypeRegistry registry;
-	private final Map<TypeParameter, ITypeID> mapping;
+	private final Map<TypeParameter, TypeID> mapping;
 	
-	public GenericMapper(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
+	public GenericMapper(GlobalTypeRegistry registry, Map<TypeParameter, TypeID> mapping) {
 		this.registry = registry;
 		this.mapping = mapping;
 	}
 	
-	public Map<TypeParameter, ITypeID> getMapping() {
+	public Map<TypeParameter, TypeID> getMapping() {
 		return mapping;
 	}
 	
-	public ITypeID map(ITypeID original) {
-		return mapping.isEmpty() ? original : original.instance(this);
+	public TypeID map(TypeID original) {
+		return mapping.isEmpty() ? original : original.instanceUnstored(this);
 	}
 	
-	public ITypeID[] map(ITypeID[] original) {
-		if (mapping.isEmpty())
+	public StoredType[] map(StoredType[] original) {
+		if (mapping.isEmpty() || original.length == 0)
 			return original;
 		
-		ITypeID[] mapped = new ITypeID[original.length];
+		StoredType[] mapped = new StoredType[original.length];
 		for (int i = 0; i < original.length; i++)
 			mapped[i] = original[i].instance(this);
 		return mapped;
 	}
 	
-	public ITypeID map(GenericTypeID type) {
+	public TypeID map(GenericTypeID type) {
 		if (!mapping.containsKey(type.parameter))
 			throw new IllegalStateException("No mapping found for type " + type);
 		
-		return mapping.containsKey(type.parameter) ? mapping.get(type.parameter).withStorage(registry, type.storage) : type;
+		return mapping.containsKey(type.parameter) ? mapping.get(type.parameter) : type;
 	}
 	
 	public FunctionHeader map(FunctionHeader original) {
 		return mapping.isEmpty() ? original : original.withGenericArguments(registry, this);
 	}
 	
-	public GenericMapper getInner(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		Map<TypeParameter, ITypeID> resultMap = new HashMap<>(this.mapping);
+	public GenericMapper getInner(GlobalTypeRegistry registry, Map<TypeParameter, TypeID> mapping) {
+		Map<TypeParameter, TypeID> resultMap = new HashMap<>(this.mapping);
 		resultMap.putAll(mapping);
 		return new GenericMapper(registry, resultMap);
 	}
 	
 	public GenericMapper getInner(GlobalTypeRegistry registry, TypeParameter[] parameters) {
-		Map<TypeParameter, ITypeID> resultMap = new HashMap<>(this.mapping);
+		Map<TypeParameter, TypeID> resultMap = new HashMap<>(this.mapping);
 		for (TypeParameter parameter : parameters)
-			resultMap.put(parameter, registry.getGeneric(parameter, null));
+			resultMap.put(parameter, registry.getGeneric(parameter));
 		return new GenericMapper(registry, resultMap);
 	}
 	
 		StringBuilder result = new StringBuilder();
 		result.append('{');
 		boolean first = true;
-		for (Map.Entry<TypeParameter, ITypeID> entry : mapping.entrySet()) {
+		for (Map.Entry<TypeParameter, TypeID> entry : mapping.entrySet()) {
 			if (first) {
 				first = false;
 			} else {

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

 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.member.InnerDefinitionMember;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 	public DefinitionAnnotation[] annotations = DefinitionAnnotation.NONE;
 	
 	public HighLevelDefinition outerDefinition;
-	private ITypeID superType;
+	private TypeID superType;
 	
 	private boolean isDestructible = false;
 	
 		return pkg.fullName + '.' + name;
 	}
 	
-	public ITypeID getSuperType() {
+	public TypeID getSuperType() {
 		return superType;
 	}
 	
-	public void setSuperType(ITypeID superType) {
+	public void setSuperType(TypeID superType) {
 		this.superType = superType;
 		if (outerDefinition != null)
 			isDestructible |= outerDefinition.isDestructible;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/AnnotationDefinition.java

 	
 	public StatementAnnotation createForStatement(CodePosition position, CallArguments arguments);
 	
-	public Annotation createForParameter(CodePosition position, CallArguments arguments);
+	public ParameterAnnotation createForParameter(CodePosition position, CallArguments arguments);
 	
 	public MemberAnnotation deserializeForMember(CodeSerializationInput input, TypeContext context, IDefinitionMember member);
 	
 	
 	public StatementAnnotation deserializeForStatement(CodeSerializationInput input, StatementContext context);
 	
-	public Annotation deserializeForParameter(CodeSerializationInput input, TypeContext context);
+	public ParameterAnnotation deserializeForParameter(CodeSerializationInput input, TypeContext context);
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/InvalidAnnotationDefinition.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.annotations;
+
+import java.util.Collections;
+import java.util.List;
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.StatementContext;
+import org.openzen.zenscript.codemodel.context.TypeContext;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.serialization.CodeSerializationInput;
+import org.openzen.zenscript.codemodel.statement.Statement;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class InvalidAnnotationDefinition implements AnnotationDefinition {
+	public static final InvalidAnnotationDefinition INSTANCE = new InvalidAnnotationDefinition();
+	
+	private InvalidAnnotationDefinition() {}
+
+	@Override
+	public String getAnnotationName() {
+		return "Invalid";
+	}
+
+	@Override
+	public List<FunctionHeader> getInitializers(BaseScope scope) {
+		return Collections.emptyList();
+	}
+
+	@Override
+	public ExpressionScope getScopeForMember(IDefinitionMember member, BaseScope scope) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public ExpressionScope getScopeForType(HighLevelDefinition definition, BaseScope scope) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public ExpressionScope getScopeForStatement(Statement statement, StatementScope scope) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public ExpressionScope getScopeForParameter(FunctionHeader header, FunctionParameter parameter, BaseScope scope) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public MemberAnnotation createForMember(CodePosition position, CallArguments arguments) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public DefinitionAnnotation createForDefinition(CodePosition position, CallArguments arguments) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public StatementAnnotation createForStatement(CodePosition position, CallArguments arguments) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public ParameterAnnotation createForParameter(CodePosition position, CallArguments arguments) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public MemberAnnotation deserializeForMember(CodeSerializationInput input, TypeContext context, IDefinitionMember member) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public DefinitionAnnotation deserializeForDefinition(CodeSerializationInput input, TypeContext context) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public StatementAnnotation deserializeForStatement(CodeSerializationInput input, StatementContext context) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public ParameterAnnotation deserializeForParameter(CodeSerializationInput input, TypeContext context) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/InvalidDefinitionAnnotation.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.annotations;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.TypeContext;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.serialization.CodeSerializationOutput;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class InvalidDefinitionAnnotation implements DefinitionAnnotation {
+	public final CodePosition position;
+	public final CompileExceptionCode code;
+	public final String message;
+	
+	public InvalidDefinitionAnnotation(CodePosition position, CompileExceptionCode code, String message) {
+		this.position = position;
+		this.code = code;
+		this.message = message;
+	}
+	
+	public InvalidDefinitionAnnotation(CompileException ex) {
+		this.position = ex.position;
+		this.code = ex.code;
+		this.message = ex.getMessage();
+	}
+
+	@Override
+	public AnnotationDefinition getDefinition() {
+		return InvalidAnnotationDefinition.INSTANCE;
+	}
+
+	@Override
+	public void apply(HighLevelDefinition definition, BaseScope scope) {
+		
+	}
+
+	@Override
+	public void applyOnSubtype(HighLevelDefinition definition, BaseScope scope) {
+		
+	}
+
+	@Override
+	public void serialize(CodeSerializationOutput output, HighLevelDefinition definition, TypeContext context) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/InvalidMemberAnnotation.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.annotations;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.TypeContext;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.GetterMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.SetterMember;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.serialization.CodeSerializationOutput;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class InvalidMemberAnnotation implements MemberAnnotation {
+	public final CodePosition position;
+	public final CompileExceptionCode code;
+	public final String message;
+	
+	public InvalidMemberAnnotation(CodePosition position, CompileExceptionCode code, String message) {
+		this.position = position;
+		this.code = code;
+		this.message = message;
+	}
+	
+	public InvalidMemberAnnotation(CompileException ex) {
+		this.position = ex.position;
+		this.code = ex.code;
+		this.message = ex.getMessage();
+	}
+
+	@Override
+	public AnnotationDefinition getDefinition() {
+		return InvalidAnnotationDefinition.INSTANCE;
+	}
+
+	@Override
+	public void apply(IDefinitionMember member, BaseScope scope) {
+		
+	}
+
+	@Override
+	public void applyOnOverridingMethod(FunctionalMember member, BaseScope scope) {
+		
+	}
+
+	@Override
+	public void applyOnOverridingGetter(GetterMember member, BaseScope scope) {
+		
+	}
+
+	@Override
+	public void applyOnOverridingSetter(SetterMember member, BaseScope scope) {
+		
+	}
+
+	@Override
+	public void serialize(CodeSerializationOutput output, IDefinitionMember member, TypeContext context) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/InvalidParameterAnnotation.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.annotations;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class InvalidParameterAnnotation implements ParameterAnnotation {
+	public final CodePosition position;
+	public final CompileExceptionCode code;
+	public final String message;
+	
+	public InvalidParameterAnnotation(CodePosition position, CompileExceptionCode code, String message) {
+		this.position = position;
+		this.code = code;
+		this.message = message;
+	}
+	
+	public InvalidParameterAnnotation(CompileException ex) {
+		this.position = ex.position;
+		this.code = ex.code;
+		this.message = ex.getMessage();
+	}
+
+	@Override
+	public AnnotationDefinition getDefinition() {
+		return InvalidAnnotationDefinition.INSTANCE;
+	}
+
+	@Override
+	public void apply() {
+		
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/InvalidStatementAnnotation.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.annotations;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.statement.Statement;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class InvalidStatementAnnotation implements StatementAnnotation {
+	public final CodePosition position;
+	public final CompileExceptionCode code;
+	public final String message;
+	
+	public InvalidStatementAnnotation(CodePosition position, CompileExceptionCode code, String message) {
+		this.position = position;
+		this.code = code;
+		this.message = message;
+	}
+	
+	public InvalidStatementAnnotation(CompileException ex) {
+		this.position = ex.position;
+		this.code = ex.code;
+		this.message = ex.getMessage();
+	}
+
+	@Override
+	public AnnotationDefinition getDefinition() {
+		return InvalidAnnotationDefinition.INSTANCE;
+	}
+
+	@Override
+	public Statement apply(Statement statement, StatementScope scope) {
+		return statement;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/NativeAnnotationDefinition.java

 	}
 
 	@Override
-	public Annotation createForParameter(CodePosition position, CallArguments arguments) {
+	public ParameterAnnotation createForParameter(CodePosition position, CallArguments arguments) {
 		throw new UnsupportedOperationException("Not supported");
 	}
 
 	}
 
 	@Override
-	public Annotation deserializeForParameter(CodeSerializationInput input, TypeContext context) {
+	public ParameterAnnotation deserializeForParameter(CodeSerializationInput input, TypeContext context) {
 		throw new UnsupportedOperationException("Not supported");
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/Annotation.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/ParameterAnnotation.java

  *
  * @author Hoofdgebruiker
  */
-public interface Annotation {
-	public static final Annotation[] NONE = new Annotation[0];
+public interface ParameterAnnotation {
+	public static final ParameterAnnotation[] NONE = new ParameterAnnotation[0];
 	
 	public AnnotationDefinition getDefinition();
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/PreconditionAnnotationDefinition.java

 	@Override
 	public List<FunctionHeader> getInitializers(BaseScope scope) {
 		return Collections.singletonList(new FunctionHeader(
-				BasicTypeID.VOID,
-				scope.getType(CodePosition.BUILTIN, enforcementLevelName, StaticStorageTag.INSTANCE),
-				BasicTypeID.BOOL,
+				BasicTypeID.VOID.stored,
+				scope.getType(CodePosition.BUILTIN, enforcementLevelName).stored(StaticStorageTag.INSTANCE),
+				BasicTypeID.BOOL.stored,
 				StringTypeID.UNIQUE));
 	}
 
 	}
 
 	@Override
-	public Annotation createForParameter(CodePosition position, CallArguments arguments) {
+	public ParameterAnnotation createForParameter(CodePosition position, CallArguments arguments) {
 		throw new UnsupportedOperationException("Not supported");
 	}
 
 	}
 
 	@Override
-	public Annotation deserializeForParameter(CodeSerializationInput input, TypeContext context) {
+	public ParameterAnnotation deserializeForParameter(CodeSerializationInput input, TypeContext context) {
 		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/PreconditionForMethod.java

 		if (body == null)
 			return body;
 		
-		ExpressionScope expressionScope = new ExpressionScope(scope, BasicTypeID.BOOL);
+		ExpressionScope expressionScope = new ExpressionScope(scope, BasicTypeID.BOOL.stored);
 		List<Statement> statements = new ArrayList<>();
 		ExpressionBuilder expressionBuilder = new ExpressionBuilder(position, expressionScope);
 		Expression inverseCondition = expressionBuilder.not(condition);
-		Statement throwStatement = new ExpressionStatement(position, new PanicExpression(position, BasicTypeID.VOID, message));
+		Statement throwStatement = new ExpressionStatement(position, new PanicExpression(position, BasicTypeID.VOID.stored, message));
 		statements.add(new IfStatement(position, inverseCondition, throwStatement, null));
 		
 		if (body instanceof BlockStatement) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/CompilingPackage.java

 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 		return getImportType(context, type.getInner(name.get(index)), name, index + 1);
 	}
 	
-	public ITypeID getType(TypeResolutionContext context, List<GenericName> name) {
+	public TypeID getType(TypeResolutionContext context, List<GenericName> name) {
 		return getType(context, name, 0);
 	}
 	
-	private ITypeID getType(TypeResolutionContext context, List<GenericName> name, int index) {
+	private TypeID getType(TypeResolutionContext context, List<GenericName> name, int index) {
 		if (index == name.size())
 			return null;
 		
 		
 		if (types.containsKey(name.get(index).name)) {
 			CompilingType type = types.get(name.get(index).name);
-			DefinitionTypeID result = context.getTypeRegistry().getForDefinition(type.load(), null, name.get(index).arguments);
+			DefinitionTypeID result = context.getTypeRegistry().getForDefinition(type.load(), name.get(index).arguments);
 			return getInner(context, name, index + 1, type, result);
 		}
 		
 		return null;
 	}
 	
-	private ITypeID getInner(TypeResolutionContext context, List<GenericName> name, int index, CompilingType type, DefinitionTypeID result) {
+	private TypeID getInner(TypeResolutionContext context, List<GenericName> name, int index, CompilingType type, DefinitionTypeID result) {
 		if (index == name.size())
 			return result;
 		
 		if (innerType == null)
 			return null;
 		
-		DefinitionTypeID innerResult = context.getTypeRegistry().getForDefinition(innerType.load(), name.get(index).arguments, result, null);
+		DefinitionTypeID innerResult = context.getTypeRegistry().getForDefinition(innerType.load(), name.get(index).arguments, result);
 		return getInner(context, name, index + 1, innerType, innerResult);
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/CompilingType.java

 	HighLevelDefinition load();
 	
 	default DefinitionTypeID getInnerType(GlobalTypeRegistry registry, List<GenericName> name, int index, DefinitionTypeID outer) {
-		DefinitionTypeID type = registry.getForDefinition(load(), name.get(index).arguments, outer, null);
+		DefinitionTypeID type = registry.getForDefinition(load(), name.get(index).arguments, outer);
 		index++;
 		if (index == name.size())
 			return type;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/FileResolutionContext.java

 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
+	public TypeID getType(CodePosition position, List<GenericName> name) {
 		if (imports.containsKey(name.get(0).name)) {
 			return GenericName.getInnerType(
 					getTypeRegistry(),
-					getTypeRegistry().getForDefinition(imports.get(name.get(0).name), null, name.get(0).arguments),
+					getTypeRegistry().getForDefinition(imports.get(name.get(0).name), name.get(0).arguments),
 					name,
-					1,
-					storage);
+					1);
 		}
 		
-		ITypeID moduleType = modulePackage.getType(this, name);
+		TypeID moduleType = modulePackage.getType(this, name);
 		if (moduleType != null)
 			return moduleType;
 		
-		return module.getType(position, name, storage);
+		return module.getType(position, name);
 	}
 	
 	@Override
 	}
 
 	@Override
-	public ITypeID getThisType() {
+	public StoredType getThisType() {
 		return null;
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/LocalTypeResolutionContext.java

 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
+	public TypeID getType(CodePosition position, List<GenericName> name) {
 		if (type != null) {
 			CompilingType compiling = type.getInner(name.get(0).name);
 			if (compiling != null) {
 		if (name.size() == 1 && name.get(0).hasNoArguments()) {
 			for (TypeParameter parameter : parameters)
 				if (parameter.name.equals(name.get(0).name))
-					return getTypeRegistry().getGeneric(parameter, storage);
+					return getTypeRegistry().getGeneric(parameter);
 		}
 		
-		return outer.getType(position, name, storage);
+		return outer.getType(position, name);
 	}
 
 	@Override
 	}
 	
 	@Override
-	public ITypeID getThisType() {
-		return type == null ? null : getTypeRegistry().getForMyDefinition(type.load());
+	public StoredType getThisType() {
+		return type == null ? null : getTypeRegistry().getForMyDefinition(type.load()).stored(BorrowStorageTag.THIS);
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/ModuleTypeResolutionContext.java

 import java.util.List;
 import java.util.Map;
 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.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ISymbol;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.codemodel.type.storage.InvalidStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageType;
 
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
+	public TypeID getType(CodePosition position, List<GenericName> name) {
 		if (rootCompiling != null) {
-			ITypeID compiling = rootCompiling.getType(this, name);
+			TypeID compiling = rootCompiling.getType(this, name);
 			if (compiling != null)
 				return compiling;
 		}
 		
 		if (name.size() == 1 && globals.containsKey(name.get(0).name))
-			return globals.get(name.get(0).name).getType(position, this, name.get(0).arguments, storage);
+			return globals.get(name.get(0).name).getType(position, this, name.get(0).arguments);
 		
-		return rootPackage.getType(position, this, name, storage);
+		return rootPackage.getType(position, this, name);
 	}
 	
 	@Override
 	public StorageTag getStorageTag(CodePosition position, String name, String[] arguments) {
 		if (!storageTypes.containsKey(name))
-			throw new CompileException(position, CompileExceptionCode.NO_SUCH_STORAGE_TYPE, "No such storage type: " + name);
+			return new InvalidStorageTag(position, CompileExceptionCode.NO_SUCH_STORAGE_TYPE, "No such storage type: " + name);
 		
 		return storageTypes.get(name).instance(position, arguments);
 	}
 	
 	@Override
-	public ITypeID getThisType() {
+	public StoredType getThisType() {
 		return null;
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/StatementContext.java

 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 	
 	public VariantOptionSwitchValue variantOptionSwitchValue;
 	
-	public StatementContext(ModuleContext module, ITypeID thisType) {
+	public StatementContext(ModuleContext module, StoredType thisType) {
 		super(module, TypeParameter.NONE, thisType);
 		
 		loops = LoopStatement.NONE;
 		lambdaOuter = null;
 	}
 	
-	public StatementContext(ModuleContext module, ITypeID thisType, FunctionHeader header) {
+	public StatementContext(ModuleContext module, StoredType thisType, FunctionHeader header) {
 		super(module, header.typeParameters, thisType);
 		
 		loops = LoopStatement.NONE;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/TypeContext.java

 import java.util.Map;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  */
 public class TypeContext {
 	protected final TypeParameter[] typeParameters;
-	public final ITypeID thisType;
+	public final StoredType thisType;
 	private final LocalMemberCache memberCache;
 	public final ModuleContext moduleContext;
 	
-	public TypeContext(ModuleContext context, TypeParameter[] parameters, ITypeID thisType) {
+	public TypeContext(ModuleContext context, TypeParameter[] parameters, StoredType thisType) {
 		this.typeParameters = parameters;
 		this.thisType = thisType;
 		memberCache = new LocalMemberCache(context.registry, context.expansions);
 		moduleContext = context;
 	}
 	
-	public TypeContext(TypeContext outer, ITypeID thisType, TypeParameter... inner) {
+	public TypeContext(TypeContext outer, StoredType thisType, TypeParameter... inner) {
 		typeParameters = concat(outer.typeParameters, inner);
 		this.thisType = thisType;
 		moduleContext = outer.moduleContext;
 		memberCache = new LocalMemberCache(moduleContext.registry, moduleContext.expansions);
 	}
 	
-	public TypeContext(TypeContext outer, ITypeID thisType, List<TypeParameter> inner) {
+	public TypeContext(TypeContext outer, StoredType thisType, List<TypeParameter> inner) {
 		this(outer, thisType, inner.toArray(new TypeParameter[inner.size()]));
 	}
 	
 		return typeParameters[index];
 	}
 	
-	public TypeMembers getTypeMembers(ITypeID type) {
+	public TypeMembers getTypeMembers(StoredType type) {
 		return memberCache.get(type);
 	}
 	
 	public GenericMapper getMapper() {
-		Map<TypeParameter, ITypeID> mapper = new HashMap<>();
+		Map<TypeParameter, TypeID> mapper = new HashMap<>();
 		for (TypeParameter parameter : typeParameters)
-			mapper.put(parameter, moduleContext.registry.getGeneric(parameter, null));
+			mapper.put(parameter, moduleContext.registry.getGeneric(parameter));
 		return new GenericMapper(moduleContext.registry, mapper);
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/TypeResolutionContext.java

 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
 	
 	AnnotationDefinition getAnnotation(String name);
 	
-	ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage);
+	TypeID getType(CodePosition position, List<GenericName> name);
 	
 	StorageTag getStorageTag(CodePosition position, String name, String[] parameters);
 	
-	ITypeID getThisType();
+	StoredType getThisType();
 }

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class AliasDefinition extends HighLevelDefinition {
-	public ITypeID type;
+	public TypeID type;
 	
 	public AliasDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
 		super(position, module, pkg, name, modifiers, outerDefinition);
 	}
 	
-	public void setType(ITypeID type) {
+	public void setType(TypeID type) {
 		if (type == null)
 			throw new NullPointerException("type cannot be null!");
 		

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Module;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ExpansionDefinition extends HighLevelDefinition {
-	public ITypeID target;
+	public TypeID target;
 	
 	public ExpansionDefinition(CodePosition position, Module module, ZSPackage pkg, int modifiers, HighLevelDefinition outerDefinition) {
 		super(position, module, pkg, null, modifiers, outerDefinition);

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

 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberGroup;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
+import org.openzen.zenscript.codemodel.type.storage.StaticStorageTag;
 
 /**
  *
 	public FunctionHeader header;
 	public Statement statement;
 	public CallerMember caller;
-	public final DefinitionMemberGroup callerGroup;
+	public final TypeMemberGroup callerGroup;
 	
 	public FunctionDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
 		super(position, module, pkg, name, modifiers, outerDefinition);
-		callerGroup = new DefinitionMemberGroup(true, name);
+		callerGroup = new TypeMemberGroup(true, name);
 	}
 	
 	public FunctionDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, FunctionHeader header, GlobalTypeRegistry registry) {
 	public void setHeader(GlobalTypeRegistry registry, FunctionHeader header) {
 		this.header = header;
 		addMember(caller = new CallerMember(position, this, modifiers | Modifiers.STATIC, header, null));
-		callerGroup.addMethod(new FunctionalMemberRef(caller, registry.getFunction(header, null), GenericMapper.EMPTY), TypeMemberPriority.SPECIFIED);
+		callerGroup.addMethod(new FunctionalMemberRef(caller, registry.getFunction(header).stored(StaticStorageTag.INSTANCE), GenericMapper.EMPTY), TypeMemberPriority.SPECIFIED);
 	}
 	
 	public void setCode(Statement statement) {

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Module;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class InterfaceDefinition extends HighLevelDefinition {
-	public final List<ITypeID> baseInterfaces = new ArrayList<>();
+	public final List<TypeID> baseInterfaces = new ArrayList<>();
 	
 	public InterfaceDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
 		super(position, module, pkg, name, modifiers, outerDefinition);
 	}
 	
-	public void addBaseInterface(ITypeID baseInterface) {
+	public void addBaseInterface(TypeID baseInterface) {
 		baseInterfaces.add(baseInterface);
 	}
 	
 	@Override
 	public boolean isDestructible() {
-		for (ITypeID baseInterface : baseInterfaces)
+		for (TypeID baseInterface : baseInterfaces)
 			if (baseInterface.isDestructible())
 				return true;
 		

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 		public final VariantDefinition variant;
 		public final String name;
 		public final int ordinal;
-		public final ITypeID[] types;
+		public final StoredType[] types;
 		
-		public Option(VariantDefinition variant, String name, int ordinal, ITypeID[] types) {
+		public Option(VariantDefinition variant, String name, int ordinal, StoredType[] types) {
 			this.variant = variant;
 			this.name = name;
 			this.ordinal = ordinal;
 			this.types = types;
 		}
 		
-		public VariantOptionRef instance(ITypeID variantType, GenericMapper mapper) {
+		public VariantOptionRef instance(StoredType variantType, GenericMapper mapper) {
 			return new VariantOptionRef(this, variantType, mapper.map(types));
 		}
 	}

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

 import java.util.List;
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
+import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialPackageExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 		
 		if (types.containsKey(name.name)) {
 			if (types.get(name.name).typeParameters.length != name.getNumberOfArguments())
-				throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_INVALID_NUMBER, "Invalid number of type arguments");
+				return new InvalidExpression(position, CompileExceptionCode.TYPE_ARGUMENTS_INVALID_NUMBER, "Invalid number of type arguments");
 			
-			return new PartialTypeExpression(position, registry.getForDefinition(types.get(name.name), null, name.arguments), name.arguments);
+			return new PartialTypeExpression(position, registry.getForDefinition(types.get(name.name), name.arguments), name.arguments);
 		}
 		
 		return null;
 		return null;
 	}
 	
-	public ITypeID getType(CodePosition position, TypeResolutionContext context, List<GenericName> nameParts, StorageTag storage) {
-		return getType(position, context, nameParts, 0, storage);
+	public TypeID getType(CodePosition position, TypeResolutionContext context, List<GenericName> nameParts) {
+		return getType(position, context, nameParts, 0);
 	}
 	
-	public ITypeID getType(CodePosition position, TypeResolutionContext context, GenericName name, StorageTag storage) {
+	public TypeID getType(CodePosition position, TypeResolutionContext context, GenericName name) {
 		if (types.containsKey(name.name)) {
-			return context.getTypeRegistry().getForDefinition(types.get(name.name), storage, name.arguments);
+			return context.getTypeRegistry().getForDefinition(types.get(name.name), name.arguments);
 		}
 		
 		return null;
 	}
 	
-	private ITypeID getType(CodePosition position, TypeResolutionContext context, List<GenericName> nameParts, int depth, StorageTag storage) {
+	private TypeID getType(CodePosition position, TypeResolutionContext context, List<GenericName> nameParts, int depth) {
 		if (depth >= nameParts.size())
 			return null;
 		
 		GenericName name = nameParts.get(depth);
 		if (subPackages.containsKey(name.name) && name.hasNoArguments())
-			return subPackages.get(name.name).getType(position, context, nameParts, depth + 1, storage);
+			return subPackages.get(name.name).getType(position, context, nameParts, depth + 1);
 		
 		if (types.containsKey(name.name)) {
-			DefinitionTypeID type = context.getTypeRegistry().getForDefinition(types.get(name.name), null, name.arguments);
-			return GenericName.getInnerType(context.getTypeRegistry(), type, nameParts, depth + 1, storage);
+			DefinitionTypeID type = context.getTypeRegistry().getForDefinition(types.get(name.name), name.arguments);
+			return GenericName.getInnerType(context.getTypeRegistry(), type, nameParts, depth + 1);
 		}
 		
 		return null;

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

 	public final Expression right;
 	
 	public AndAndExpression(CodePosition position, Expression left, Expression right) {
-		super(position, BasicTypeID.BOOL, binaryThrow(position, left.thrownType, right.thrownType));
+		super(position, BasicTypeID.BOOL.stored, binaryThrow(position, left.thrownType, right.thrownType));
 		
 		this.left = left;
 		this.right = right;

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 	public final Expression[] expressions;
 	public final ArrayTypeID arrayType;
 	
-	public ArrayExpression(CodePosition position, Expression[] expressions, ArrayTypeID type) {
+	public ArrayExpression(CodePosition position, Expression[] expressions, StoredType type) {
 		super(position, type, multiThrow(position, expressions));
 		
 		this.expressions = expressions;
-		this.arrayType = type;
+		this.arrayType = (ArrayTypeID)type.type;
 	}
 
 	@Override
 	@Override
 	public Expression transform(ExpressionTransformer transformer) {
 		Expression[] tExpressions = Expression.transform(expressions, transformer);
-		return tExpressions == expressions ? this : new ArrayExpression(position, tExpressions, (ArrayTypeID)type);
+		return tExpressions == expressions ? this : new ArrayExpression(position, tExpressions, type);
 	}
 
 	@Override
 		Expression[] normalized = new Expression[expressions.length];
 		for (int i = 0; i < normalized.length; i++)
 			normalized[i] = expressions[i].normalize(scope);
-		return new ArrayExpression(position, normalized, arrayType.getNormalized());
+		return new ArrayExpression(position, normalized, type.getNormalized());
 	}
 }

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

 
 import java.util.Arrays;
 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.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 public class CallArguments {
 	public static final CallArguments EMPTY = new CallArguments(new Expression[0]);
 	
-	public final ITypeID[] typeArguments;
+	public final TypeID[] typeArguments;
 	public final Expression[] arguments;
 	
 	public CallArguments(Expression... arguments) {
-		this.typeArguments = ITypeID.NONE;
+		this.typeArguments = TypeID.NONE;
 		this.arguments = arguments;
 	}
 	
-	public CallArguments(ITypeID[] typeArguments, Expression[] arguments) {
+	public CallArguments(TypeID[] typeArguments, Expression[] arguments) {
 		if (typeArguments == null)
-			typeArguments = ITypeID.NONE;
+			typeArguments = TypeID.NONE;
 		if (arguments == null)
 			throw new IllegalArgumentException("Arguments cannot be null!");
 		
 		this.arguments = arguments;
 	}
 	
-	public CallArguments(ITypeID... dummy) {
-		this.typeArguments = ITypeID.NONE;
+	public CallArguments(TypeID... dummy) {
+		this.typeArguments = TypeID.NONE;
 		this.arguments = new Expression[dummy.length];
 		for (int i = 0; i < dummy.length; i++)
-			arguments[i] = new DummyExpression(dummy[i]);
+			arguments[i] = new DummyExpression(dummy[i].stored(UniqueStorageTag.INSTANCE));
 	}
 	
 	public int getNumberOfTypeArguments() {
 			Expression[] newArguments = Arrays.copyOf(arguments, header.parameters.length);
 			for (int i = arguments.length; i < header.parameters.length; i++) {
 				if (header.parameters[i].defaultValue == null)
-					throw new CompileException(position, CompileExceptionCode.MISSING_PARAMETER, "Parameter missing and no default value specified");
-				newArguments[i] = header.parameters[i].defaultValue;
+					newArguments[i] = new InvalidExpression(position, header.parameters[i].type, CompileExceptionCode.MISSING_PARAMETER, "Parameter missing and no default value specified");
+				else
+					newArguments[i] = header.parameters[i].defaultValue;
 			}
 			result = new CallArguments(typeArguments, newArguments);
 		}

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  */
 public class CallStaticExpression extends Expression {
 	public final FunctionalMemberRef member;
-	public final ITypeID target;
+	public final TypeID target;
 	public final CallArguments arguments;
 	public final FunctionHeader instancedHeader;
 	
-	public CallStaticExpression(CodePosition position, ITypeID target, FunctionalMemberRef member, FunctionHeader instancedHeader, CallArguments arguments) {
+	public CallStaticExpression(CodePosition position, TypeID target, FunctionalMemberRef member, FunctionHeader instancedHeader, CallArguments arguments) {
 		super(position, instancedHeader.getReturnType(), multiThrow(position, arguments.arguments));
 		
 		this.member = member;
 	public Expression normalize(TypeScope scope) {
 		return new CallStaticExpression(
 				position,
-				target.getNormalized(),
+				target.getNormalizedUnstored(),
 				member,
 				instancedHeader.normalize(scope.getTypeRegistry()),
 				arguments.normalize(position, scope, instancedHeader));

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 public abstract class CapturedExpression extends Expression {
 	public final LambdaClosure closure;
 	
-	public CapturedExpression(CodePosition position, ITypeID type, LambdaClosure closure) {
+	public CapturedExpression(CodePosition position, StoredType type, LambdaClosure closure) {
 		super(position, type, null);
 		
 		this.closure = closure;

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class CapturedThisExpression extends CapturedExpression {
-	public CapturedThisExpression(CodePosition position, ITypeID type, LambdaClosure closure) {
+	public CapturedThisExpression(CodePosition position, StoredType type, LambdaClosure closure) {
 		super(position, type, closure);
 	}
 

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

 	public final CompareType comparison;
 	
 	public CompareExpression(CodePosition position, Expression left, Expression right, FunctionalMemberRef operator, CompareType comparison) {
-		super(position, BasicTypeID.BOOL, binaryThrow(position, left.thrownType, right.thrownType));
+		super(position, BasicTypeID.BOOL.stored, binaryThrow(position, left.thrownType, right.thrownType));
 		
 		this.left = left;
 		this.right = right;

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 			Expression condition,
 			Expression ifThen,
 			Expression ifElse,
-			ITypeID type) {
-		super(position, ifThen.type, binaryThrow(position, condition.thrownType, binaryThrow(position, ifThen.thrownType, ifElse.thrownType)));
+			StoredType type) {
+		super(position, type, binaryThrow(position, condition.thrownType, binaryThrow(position, ifThen.thrownType, ifElse.thrownType)));
 		
 		if (ifThen.type != ifElse.type)
 			throw new AssertionError();

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

 	public final boolean value;
 	
 	public ConstantBoolExpression(CodePosition position, boolean value) {
-		super(position, BasicTypeID.BOOL, null);
+		super(position, BasicTypeID.BOOL.stored, null);
 		
 		this.value = value;
 	}

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

 	public final int value;
 	
 	public ConstantByteExpression(CodePosition position, int value) {
-		super(position, BasicTypeID.BYTE, null);
+		super(position, BasicTypeID.BYTE.stored, null);
 		
 		this.value = value;
 	}

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

 	public final char value;
 	
 	public ConstantCharExpression(CodePosition position, char value) {
-		super(position, BasicTypeID.CHAR, null);
+		super(position, BasicTypeID.CHAR.stored, null);
 		
 		this.value = value;
 	}

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

 	public final double value;
 	
 	public ConstantDoubleExpression(CodePosition position, double value) {
-		super(position, BasicTypeID.DOUBLE, null);
+		super(position, BasicTypeID.DOUBLE.stored, null);
 		
 		this.value = value;
 	}

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

 	public final float value;
 	
 	public ConstantFloatExpression(CodePosition position, float value) {
-		super(position, BasicTypeID.FLOAT, null);
+		super(position, BasicTypeID.FLOAT.stored, null);
 		
 		this.value = value;
 	}

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

 	public final int value;
 	
 	public ConstantIntExpression(CodePosition position, int value) {
-		super(position, BasicTypeID.INT, null);
+		super(position, BasicTypeID.INT.stored, null);
 		
 		this.value = value;
 	}

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

 	public final long value;
 	
 	public ConstantLongExpression(CodePosition position, long value) {
-		super(position, BasicTypeID.LONG, null);
+		super(position, BasicTypeID.LONG.stored, null);
 		
 		this.value = value;
 	}

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

 	public final byte value;
 	
 	public ConstantSByteExpression(CodePosition position, byte value) {
-		super(position, BasicTypeID.SBYTE, null);
+		super(position, BasicTypeID.SBYTE.stored, null);
 		
 		this.value = value;
 	}

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

 	public final short value;
 	
 	public ConstantShortExpression(CodePosition position, short value) {
-		super(position, BasicTypeID.SHORT, null);
+		super(position, BasicTypeID.SHORT.stored, null);
 		
 		this.value = value;
 	}

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

 	public final int value;
 	
 	public ConstantUIntExpression(CodePosition position, int value) {
-		super(position, BasicTypeID.UINT, null);
+		super(position, BasicTypeID.UINT.stored, null);
 		
 		this.value = value;
 	}

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

 	public final long value;
 	
 	public ConstantULongExpression(CodePosition position, long value) {
-		super(position, BasicTypeID.ULONG, null);
+		super(position, BasicTypeID.ULONG.stored, null);
 		
 		this.value = value;
 	}

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

 	public final int value;
 	
 	public ConstantUShortExpression(CodePosition position, int value) {
-		super(position, BasicTypeID.USHORT, null);
+		super(position, BasicTypeID.USHORT.stored, null);
 		
 		this.value = value;
 	}

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

 	public final long value;
 	
 	public ConstantUSizeExpression(CodePosition position, long value) {
-		super(position, BasicTypeID.USIZE, null);
+		super(position, BasicTypeID.USIZE.stored, null);
 		
 		this.value = value;
 	}

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

 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ConstructorSuperCallExpression extends Expression {
-	public final ITypeID objectType;
+	public final StoredType objectType;
 	public final FunctionalMemberRef constructor;
 	public final CallArguments arguments;
 	
-	public ConstructorSuperCallExpression(CodePosition position, ITypeID type, FunctionalMemberRef constructor, CallArguments arguments) {
-		super(position, BasicTypeID.VOID, binaryThrow(position, constructor.getHeader().thrownType, multiThrow(position, arguments.arguments)));
+	public ConstructorSuperCallExpression(CodePosition position, StoredType type, FunctionalMemberRef constructor, CallArguments arguments) {
+		super(position, BasicTypeID.VOID.stored, binaryThrow(position, constructor.getHeader().thrownType, multiThrow(position, arguments.arguments)));
 		
 		this.objectType = type;
 		this.constructor = constructor;

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

 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ConstructorThisCallExpression extends Expression {
-	public final ITypeID objectType;
+	public final StoredType objectType;
 	public final FunctionalMemberRef constructor;
 	public final CallArguments arguments;
 	
-	public ConstructorThisCallExpression(CodePosition position, ITypeID type, FunctionalMemberRef constructor, CallArguments arguments) {
-		super(position, BasicTypeID.VOID, binaryThrow(position, constructor.getHeader().thrownType, multiThrow(position, arguments.arguments)));
+	public ConstructorThisCallExpression(CodePosition position, StoredType type, FunctionalMemberRef constructor, CallArguments arguments) {
+		super(position, BasicTypeID.VOID.stored, binaryThrow(position, constructor.getHeader().thrownType, multiThrow(position, arguments.arguments)));
 		
-		if (type instanceof BasicTypeID)
+		if (type.type instanceof BasicTypeID)
 			throw new IllegalArgumentException("Type cannot be basic type");
 		
 		this.objectType = type;

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class DummyExpression extends Expression {
-	public DummyExpression(ITypeID type) {
+	public DummyExpression(StoredType type) {
 		super(CodePosition.BUILTIN, type, null);
 	}
 

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

 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.storage.StaticStorageTag;
 
 /**
 public class EnumConstantExpression extends Expression {
 	public final EnumConstantMember value;
 	
-	public EnumConstantExpression(CodePosition position, ITypeID type, EnumConstantMember value) {
-		super(position, type, null);
+	public EnumConstantExpression(CodePosition position, TypeID type, EnumConstantMember value) {
+		super(position, type.stored(StaticStorageTag.INSTANCE), null);
 		
 		this.value = value;
 	}
 	
 	public EnumConstantExpression(CodePosition position, GlobalTypeRegistry registry, EnumDefinition type, EnumConstantMember value) {
-		super(position, registry.getForDefinition(type, StaticStorageTag.INSTANCE), null);
+		super(position, registry.getForDefinition(type).stored(StaticStorageTag.INSTANCE), null);
 		
 		this.value = value;
 	}

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

 
 import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 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.OperatorType;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.GenericName;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.StatementTransformer;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.FunctionTypeID;
+import org.openzen.zenscript.codemodel.type.InvalidTypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 
 /**
  *
 	public static final Expression[] NONE = new Expression[0];
 	
 	public final CodePosition position;
-	public final ITypeID type;
-	public final ITypeID thrownType;
+	public final StoredType type;
+	public final StoredType thrownType;
 	
-	public Expression(CodePosition position, ITypeID type, ITypeID thrownType) {
+	public Expression(CodePosition position, StoredType type, StoredType thrownType) {
 		if (type == null)
 			throw new NullPointerException();
-		if (type == BasicTypeID.UNDETERMINED)
+		if (type.type == BasicTypeID.UNDETERMINED)
 			throw new IllegalArgumentException(position + ": Cannot use undetermined type as expression type");
 		
 		this.position = position;
 				if (body == function.body)
 					return function;
 				
-				return new FunctionExpression(function.position, (FunctionTypeID)function.type, function.closure, function.header, body);
+				return new FunctionExpression(function.position, function.type, function.closure, function.header, body);
 			} else {
 				return expression;
 			}
 	public abstract Expression normalize(TypeScope scope);
 	
 	@Override
-	public List<ITypeID> getAssignHints() {
+	public List<StoredType> getAssignHints() {
 		return Collections.singletonList(type);
 	}
 	
 		return this;
 	}
 	
-	public Expression castExplicit(CodePosition position, TypeScope scope, ITypeID asType, boolean optional) {
+	public Expression castExplicit(CodePosition position, TypeScope scope, StoredType asType, boolean optional) {
 		return scope.getTypeMembers(type).castExplicit(position, this, asType, optional);
 	}
 	
-	public Expression castImplicit(CodePosition position, TypeScope scope, ITypeID asType) {
+	public Expression castImplicit(CodePosition position, TypeScope scope, StoredType asType) {
 		return scope.getTypeMembers(type).castImplicit(position, this, asType, true);
 	}
 	
 	}
 	
 	@Override
-	public List<ITypeID>[] predictCallTypes(TypeScope scope, List<ITypeID> hints, int arguments) {
+	public List<StoredType>[] predictCallTypes(TypeScope scope, List<StoredType> hints, int arguments) {
 		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).predictCallTypes(scope, hints, arguments);
 	}
 	
 	@Override
-	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<ITypeID> hints, int arguments) {
+	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) {
 		return scope.getTypeMembers(type)
 				.getOrCreateGroup(OperatorType.CALL)
 				.getMethodMembers().stream()
 	}
 	
 	@Override
-	public Expression call(CodePosition position, TypeScope scope, List<ITypeID> hints, CallArguments arguments) {
+	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) {
 		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).call(position, scope, this, arguments, false);
 	}
 	
 	@Override
-	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<ITypeID> hints, GenericName name) {
+	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) {
 		TypeMembers members = scope.getTypeMembers(type);
 		IPartialExpression result = members.getMemberExpression(position, scope, this, name, false);
 		if (result == null)
 	}
 	
 	@Override
-	public ITypeID[] getGenericCallTypes() {
+	public TypeID[] getGenericCallTypes() {
 		return null;
 	}
 	
 		throw new UnsupportedOperationException("Cannot evaluate this value to an enum constant!");
 	}
 	
-	public static ITypeID binaryThrow(CodePosition position, ITypeID left, ITypeID right) {
-		if (left == right)
+	public static StoredType binaryThrow(CodePosition position, StoredType left, StoredType right) {
+		if (Objects.equals(left, right))
 			return left;
 		else if (left == null)
 			return right;
 		else if (right == null)
 			return left;
 		else
-			throw new CompileException(position, CompileExceptionCode.DIFFERENT_EXCEPTIONS, "two different exceptions in same operation: " + left.toString() + " and " + right.toString());
+			return new InvalidTypeID(position, CompileExceptionCode.DIFFERENT_EXCEPTIONS, "two different exceptions in same operation: " + left.toString() + " and " + right.toString()).stored(UniqueStorageTag.INSTANCE);
 	}
 	
-	public static ITypeID multiThrow(CodePosition position, Expression[] expressions) {
-		ITypeID result = null;
+	public static StoredType multiThrow(CodePosition position, Expression[] expressions) {
+		StoredType result = null;
 		for (Expression expression : expressions)
 			result = binaryThrow(position, result, expression.thrownType);
 		return result;

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

 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.GenericName;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
+import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberGroup;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 import stdlib.Strings;
 		this.scope = scope;
 	}
 	
-	public Expression constructNew(String typename, Expression... arguments) {
+	public Expression constructNew(String typename, Expression... arguments) throws CompileException {
 		String[] nameParts = Strings.split(typename, '.');
 		List<GenericName> name = new ArrayList<>();
 		for (String namePart : nameParts)
 			name.add(new GenericName(namePart));
-		ITypeID type = scope.getType(position, name, UniqueStorageTag.INSTANCE);
+		TypeID type = scope.getType(position, name);
 		if (type == null)
 			throw new CompileException(position, CompileExceptionCode.NO_SUCH_TYPE, "No such type: " + typename);
 		
-		return constructNew(type, arguments);
+		return constructNew(type.stored(UniqueStorageTag.INSTANCE), arguments);
 	}
 	
-	public Expression constructNew(ITypeID type, Expression... arguments) {
-		DefinitionMemberGroup constructors = scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CONSTRUCTOR);
-		List<ITypeID>[] predictedTypes = constructors.predictCallTypes(scope, scope.hints, arguments.length);
+	public Expression constructNew(StoredType type, Expression... arguments) throws CompileException {
+		TypeMemberGroup constructors = scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CONSTRUCTOR);
+		List<StoredType>[] predictedTypes = constructors.predictCallTypes(scope, scope.hints, arguments.length);
 		CallArguments compiledArguments = new CallArguments(arguments);
 		FunctionalMemberRef member = constructors.selectMethod(position, scope, compiledArguments, true, true);
 		if (member == null)

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

 	
 	public T visitInterfaceCast(InterfaceCastExpression expression);
 	
+	public default T visitInvalid(InvalidExpression expression) {
+		throw new RuntimeException("Invalid expression");
+	}
+	
 	public T visitIs(IsExpression expression);
 	
 	public T visitMakeConst(MakeConstExpression expression);

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

 	
 	public R visitInterfaceCast(C context, InterfaceCastExpression expression);
 	
+	public R visitInvalid(C context, InvalidExpression expression);
+	
 	public R visitIs(C context, IsExpression expression);
 	
 	public R visitMakeConst(C context, MakeConstExpression expression);

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

 import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 	
 	public FunctionExpression(
 			CodePosition position,
-			FunctionTypeID type,
+			StoredType type,
 			LambdaClosure closure,
 			FunctionHeader header,
 			Statement body) {
 	@Override
 	public FunctionExpression transform(ExpressionTransformer transformer) {
 		Statement tBody = body.transform(transformer, ConcatMap.empty(LoopStatement.class, LoopStatement.class));
-		return tBody == body ? this : new FunctionExpression(position, (FunctionTypeID)type, closure, header, tBody);
+		return tBody == body ? this : new FunctionExpression(position, type, closure, header, tBody);
 	}
 	
 	@Override
 
 	@Override
 	public Expression normalize(TypeScope scope) {
-		return new FunctionExpression(position, (FunctionTypeID)type, closure, header, body.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class)));
+		return new FunctionExpression(position, type, closure, header, body.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class)));
 	}
 	
 	private static class ReturnExpressionTransformer implements ExpressionTransformer {

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

 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 	}
 	
 	@Override
-	public List<ITypeID> getAssignHints() {
+	public List<StoredType> getAssignHints() {
 		return Collections.singletonList(type);
 	}
 	

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

 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 	}
 	
 	@Override
-	public List<ITypeID> getAssignHints() {
+	public List<StoredType> getAssignHints() {
 		return Collections.singletonList(field.getType());
 	}
 	

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 public class InterfaceCastExpression extends Expression {
 	public final Expression value;
 	
-	public InterfaceCastExpression(CodePosition position, Expression value, ITypeID toType) {
+	public InterfaceCastExpression(CodePosition position, Expression value, StoredType toType) {
 		super(position, toType, value.thrownType);
 		
 		this.value = value;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/InvalidExpression.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.expression;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class InvalidExpression extends Expression {
+	public final CompileExceptionCode code;
+	public final String message;
+	
+	public InvalidExpression(CodePosition position, StoredType type, CompileExceptionCode code, String message) {
+		super(position, type, null);
+		
+		this.code = code;
+		this.message = message;
+	}
+	
+	public InvalidExpression(CodePosition position, CompileExceptionCode code, String message) {
+		this(position, BasicTypeID.UNDETERMINED.stored, code, message);
+	}
+	
+	public InvalidExpression(StoredType type, CompileException cause) {
+		this(cause.position, type, cause.code, cause.getMessage());
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitInvalid(this);
+	}
+
+	@Override
+	public <C, R> R accept(C context, ExpressionVisitorWithContext<C, R> visitor) {
+		return visitor.visitInvalid(context, this);
+	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
+}

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  */
 public class IsExpression extends Expression {
 	public final Expression value;
-	public final ITypeID isType;
+	public final TypeID isType;
 	
-	public IsExpression(CodePosition position, Expression value, ITypeID type) {
-		super(position, BasicTypeID.BOOL, value.thrownType);
+	public IsExpression(CodePosition position, Expression value, TypeID type) {
+		super(position, BasicTypeID.BOOL.stored, value.thrownType);
 		
 		this.value = value;
 		this.isType = type;
 	@Override
 	public Expression transform(ExpressionTransformer transformer) {
 		Expression tValue = value.transform(transformer);
-		return tValue == value ? this : new IsExpression(position, tValue, type);
+		return tValue == value ? this : new IsExpression(position, tValue, isType);
 	}
 
 	@Override
 	public Expression normalize(TypeScope scope) {
-		return new IsExpression(position, value.normalize(scope), type.getNormalized());
+		return new IsExpression(position, value.normalize(scope), isType.getNormalizedUnstored());
 	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 public class MakeConstExpression extends Expression {
 	public final Expression value;
 	
-	public MakeConstExpression(CodePosition position, Expression value, ITypeID constType) {
+	public MakeConstExpression(CodePosition position, Expression value, StoredType constType) {
 		super(position, constType, value.thrownType);
 		
 		this.value = value;

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 			CodePosition position,
 			Expression[] keys,
 			Expression[] values,
-			ITypeID type) {
+			StoredType type) {
 		super(position, type, binaryThrow(position, multiThrow(position, keys), multiThrow(position, values)));
 		
 		this.keys = keys;

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

 import org.openzen.zenscript.codemodel.statement.SwitchStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 	public final Expression value;
 	public final Case[] cases;
 	
-	public MatchExpression(CodePosition position, Expression value, ITypeID type, Case[] cases) {
+	public MatchExpression(CodePosition position, Expression value, StoredType type, Case[] cases) {
 		super(position, type, binaryThrow(position, value.thrownType, getThrownType(position, cases)));
 		
 		this.value = value;
 				hasDefault = true;
 		}
 		if (!hasDefault) {
-			Statement defaultCase = new ExpressionStatement(position, new PanicExpression(position, BasicTypeID.VOID, new ConstantStringExpression(position, "Missing case")));
+			Statement defaultCase = new ExpressionStatement(position, new PanicExpression(position, BasicTypeID.VOID.stored, new ConstantStringExpression(position, "Missing case")));
 			switchStatement.cases.add(new SwitchCase(null, new Statement[] { defaultCase }));
 		}
 		return new SwitchedMatch(result, switchStatement);
 		}
 	}
 	
-	private static ITypeID getThrownType(CodePosition position, Case[] cases) {
+	private static StoredType getThrownType(CodePosition position, Case[] cases) {
 		if (cases.length == 0)
 			return null;
 		
-		ITypeID result = cases[0].value.thrownType;
+		StoredType result = cases[0].value.thrownType;
 		for (int i = 1; i < cases.length; i++)
 			result = binaryThrow(position, result, cases[i].value.thrownType);
 		

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 	
 	public NewExpression(
 			CodePosition position,
-			ITypeID type,
+			StoredType type,
 			FunctionalMemberRef constructor,
 			CallArguments arguments)
 	{
 	
 	public NewExpression(
 			CodePosition position,
-			ITypeID type,
+			StoredType type,
 			FunctionalMemberRef constructor,
 			CallArguments arguments,
 			FunctionHeader instancedHeader)

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
  */
 public class NullExpression extends Expression {
 	public NullExpression(CodePosition position) {
-		super(position, BasicTypeID.NULL, null);
+		super(position, BasicTypeID.NULL.stored, null);
 	}
 	
-	public NullExpression(CodePosition position, ITypeID optionalType) {
+	public NullExpression(CodePosition position, StoredType optionalType) {
 		super(position, optionalType, null);
 	}
 

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

 	public final Expression right;
 	
 	public OrOrExpression(CodePosition position, Expression left, Expression right) {
-		super(position, BasicTypeID.BOOL, binaryThrow(position, left.thrownType, right.thrownType));
+		super(position, BasicTypeID.BOOL.stored, binaryThrow(position, left.thrownType, right.thrownType));
 		
 		this.left = left;
 		this.right = right;

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 public class PanicExpression extends Expression {
 	public final Expression value;
 	
-	public PanicExpression(CodePosition position, ITypeID type, Expression value) {
+	public PanicExpression(CodePosition position, StoredType type, Expression value) {
 		super(position, type, null);
 		
 		this.value = value;

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 	public final Expression from;
 	public final Expression to;
 	
-	public RangeExpression(CodePosition position, RangeTypeID type, Expression from, Expression to) {
+	public RangeExpression(CodePosition position, StoredType type, Expression from, Expression to) {
 		super(position, type, binaryThrow(position, from.thrownType, to.thrownType));
 	
 		this.from = from;
 		this.to = to;
 	}
 	
-	private RangeExpression(CodePosition position, ITypeID type, Expression from, Expression to, ITypeID thrownType) {
+	private RangeExpression(CodePosition position, StoredType type, Expression from, Expression to, StoredType thrownType) {
 		super(position, type, thrownType);
 		
 		this.from = from;
 
 	@Override
 	public Expression normalize(TypeScope scope) {
-		RangeTypeID rangeType = (RangeTypeID)type;
+		StoredType baseType = ((RangeTypeID)type.type).baseType;
 		return new RangeExpression(
 				position,
-				rangeType,
-				from.normalize(scope).castImplicit(position, scope, rangeType.baseType),
-				to.normalize(scope).castImplicit(position, scope, rangeType.baseType));
+				type.getNormalized(),
+				from.normalize(scope).castImplicit(position, scope, baseType),
+				to.normalize(scope).castImplicit(position, scope, baseType));
 	}
 }

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

 	public final boolean inverted;
 	
 	public SameObjectExpression(CodePosition position, Expression left, Expression right, boolean inverted) {
-		super(position, BasicTypeID.BOOL, binaryThrow(position, left.thrownType, right.thrownType));
+		super(position, BasicTypeID.BOOL.stored, binaryThrow(position, left.thrownType, right.thrownType));
 		
 		this.left = left;
 		this.right = right;

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 public class StorageCastExpression extends Expression {
 	public final Expression value;
 	
-	public StorageCastExpression(CodePosition position, Expression value, ITypeID toType) {
+	public StorageCastExpression(CodePosition position, Expression value, StoredType toType) {
 		super(position, toType, value.thrownType);
 		
 		this.value = value;

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  * Using to cast a class type to a base type.
 public class SupertypeCastExpression extends Expression {
 	public final Expression value;
 	
-	public SupertypeCastExpression(CodePosition position, Expression value, ITypeID type) {
+	public SupertypeCastExpression(CodePosition position, Expression value, StoredType type) {
 		super(position, type, value.thrownType);
 		
 		this.value = value;

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ThisExpression extends Expression {
-	public ThisExpression(CodePosition position, ITypeID type) {
+	public ThisExpression(CodePosition position, StoredType type) {
 		super(position, type, null);
 	}
 	

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 public class ThrowExpression extends Expression {
 	public final Expression value;
 	
-	public ThrowExpression(CodePosition position, ITypeID type, Expression value) {
+	public ThrowExpression(CodePosition position, StoredType type, Expression value) {
 		super(position, type, value.type);
 		
 		this.value = value;

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 public class TryConvertExpression extends Expression {
 	public final Expression value;
 	
-	public TryConvertExpression(CodePosition position, ITypeID type, Expression value) {
+	public TryConvertExpression(CodePosition position, StoredType type, Expression value) {
 		super(position, type, null);
 		
 		this.value = value;

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 public class TryRethrowAsExceptionExpression extends Expression {
 	public final Expression value;
 	
-	public TryRethrowAsExceptionExpression(CodePosition position, ITypeID type, Expression value, ITypeID thrownType) {
+	public TryRethrowAsExceptionExpression(CodePosition position, StoredType type, Expression value, StoredType thrownType) {
 		super(position, type, thrownType);
 		
 		this.value = value;

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 public class TryRethrowAsResultExpression extends Expression {
 	public final Expression value;
 	
-	public TryRethrowAsResultExpression(CodePosition position, ITypeID type, Expression value) {
+	public TryRethrowAsResultExpression(CodePosition position, StoredType type, Expression value) {
 		super(position, type, null);
 		
 		this.value = value;

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 	public final VariantOptionRef option;
 	public final Expression[] arguments;
 	
-	public VariantValueExpression(CodePosition position, ITypeID variantType, VariantOptionRef option) {
+	public VariantValueExpression(CodePosition position, StoredType variantType, VariantOptionRef option) {
 		this(position, variantType, option, Expression.NONE);
 	}
 	
-	public VariantValueExpression(CodePosition position, ITypeID variantType, VariantOptionRef option, Expression[] arguments) {
+	public VariantValueExpression(CodePosition position, StoredType variantType, VariantOptionRef option, Expression[] arguments) {
 		super(position, variantType, multiThrow(position, arguments));
 		
 		this.option = option;
 	}
 	
 	@Override
-	public Expression call(CodePosition position, TypeScope scope, List<ITypeID> hints, CallArguments arguments) {
+	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) {
 		if (arguments != null)
 			return super.call(position, scope, hints, arguments);
 		

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 public class WrapOptionalExpression extends Expression {
 	public final Expression value;
 	
-	public WrapOptionalExpression(CodePosition position, Expression value, ITypeID optionalType) {
+	public WrapOptionalExpression(CodePosition position, Expression value, StoredType optionalType) {
 		super(position, optionalType, value.thrownType);
 		
 		if (value.type.isOptional())

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/ParameterSuperBound.java

 
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ParameterSuperBound extends TypeParameterBound {
-	public final ITypeID type;
+	public final TypeID type;
 	
-	public ParameterSuperBound(ITypeID type) {
+	public ParameterSuperBound(TypeID type) {
 		this.type = type;
 	}
 	
 	}
 
 	@Override
-	public boolean matches(LocalMemberCache cache, ITypeID type) {
-		return cache.get(this.type).extendsOrImplements(type);
+	public boolean matches(LocalMemberCache cache, TypeID type) {
+		return cache.get(this.type.stored(BorrowStorageTag.THIS)).extendsOrImplements(type);
 	}
 
 	@Override
 	public TypeParameterBound instance(GenericMapper mapper) {
-		ITypeID translated = type.instance(mapper);
+		TypeID translated = type.instanceUnstored(mapper);
 		if (translated == type)
 			return this;
 		

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/ParameterTypeBound.java

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
+import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
 
 /**
  *
  */
 public class ParameterTypeBound extends TypeParameterBound {
 	public final CodePosition position;
-	public final ITypeID type;
+	public final TypeID type;
 	
-	public ParameterTypeBound(CodePosition position, ITypeID type) {
+	public ParameterTypeBound(CodePosition position, TypeID type) {
 		this.position = position;
 		this.type = type;
 	}
 	}
 
 	@Override
-	public void registerMembers(LocalMemberCache cache, TypeMembers type) {
-		cache.get(this.type).copyMembersTo(position, type, TypeMemberPriority.FROM_TYPE_BOUNDS);
+	public void registerMembers(LocalMemberCache cache, TypeMembers members) {
+		cache.get(this.type.stored(members.type.storage))
+				.copyMembersTo(position, members, TypeMemberPriority.FROM_TYPE_BOUNDS);
 	}
 
 	@Override
-	public boolean matches(LocalMemberCache cache, ITypeID type) {
-		return cache.get(type).extendsOrImplements(this.type);
+	public boolean matches(LocalMemberCache cache, TypeID type) {
+		return cache.get(type.stored(BorrowStorageTag.THIS))
+				.extendsOrImplements(this.type);
 	}
 
 	@Override
 	public TypeParameterBound instance(GenericMapper mapper) {
-		return new ParameterTypeBound(position, type.instance(mapper));
+		return new ParameterTypeBound(position, type.instanceUnstored(mapper));
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/TypeParameter.java

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.Taggable;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 
 /**
 		return false;
 	}
 	
-	public boolean matches(LocalMemberCache cache, ITypeID type) {
+	public boolean matches(LocalMemberCache cache, TypeID type) {
 		for (TypeParameterBound bound : bounds) {
 			if (!bound.matches(cache, type))
 				return false;
 		return true;
 	}
 	
-	public TypeParameter withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
+	public TypeParameter withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, TypeID> arguments) {
 		// TODO: think about this...
 		//List<GenericParameterBound> bounds = new ArrayList<>();
 		//for (GenericParameterBound bound : this.bounds)

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/TypeParameterBound.java

 package org.openzen.zenscript.codemodel.generic;
 
 import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 
 	
 	public abstract void registerMembers(LocalMemberCache cache, TypeMembers type);
 	
-	public abstract boolean matches(LocalMemberCache cache, ITypeID type);
+	public abstract boolean matches(LocalMemberCache cache, TypeID type);
 	
 	public abstract TypeParameterBound instance(GenericMapper mapper);
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/CasterMember.java

 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 
  * @author Hoofdgebruiker
  */
 public class CasterMember extends FunctionalMember {
-	public ITypeID toType;
+	public StoredType toType;
 	public CasterMemberRef overrides;
 	
 	public CasterMember(
 			CodePosition position,
 			HighLevelDefinition definition,
 			int modifiers,
-			ITypeID toType,
+			StoredType toType,
 			BuiltinID builtin)
 	{
 		super(position, definition, modifiers, new FunctionHeader(toType), builtin);
 
 	@Override
 	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
-		type.addCaster(new CasterMemberRef(this, type.type, mapper == null ? toType : mapper.map(toType)), priority);
+		type.addCaster(new CasterMemberRef(this, type.type, mapper == null ? toType : toType.instance(mapper)), priority);
 	}
 
 	@Override
 		return "caster to " + toType.toString();
 	}
 	
-	public ITypeID getTargetType() {
+	public StoredType getTargetType() {
 		return toType;
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ConstMember.java

 import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 	public final String name;
 	public Expression value;
 	
-	public ConstMember(CodePosition position, HighLevelDefinition definition, int modifiers, String name, ITypeID type, BuiltinID builtin) {
+	public ConstMember(CodePosition position, HighLevelDefinition definition, int modifiers, String name, StoredType type, BuiltinID builtin) {
 		super(position, definition, modifiers, type, builtin);
 		
 		this.name = name;
 	}
 
 	@Override
-	public DefinitionMemberRef ref(ITypeID type, GenericMapper mapper) {
+	public DefinitionMemberRef ref(StoredType type, GenericMapper mapper) {
 		return new ConstMemberRef(type, this, mapper);
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ConstructorMember.java

 				position,
 				definition,
 				modifiers,
-				new FunctionHeader(header.typeParameters, BasicTypeID.VOID, header.thrownType, header.parameters),
+				new FunctionHeader(header.typeParameters, BasicTypeID.VOID.stored, header.thrownType, header.parameters),
 				builtin);
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/DefinitionMember.java

 		return definition;
 	}
 	
+	@Override
 	public MemberAnnotation[] getAnnotations() {
 		return annotations;
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/FieldMember.java

 import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 
 			HighLevelDefinition definition,
 			int modifiers,
 			String name,
-			ITypeID thisType,
-			ITypeID type,
+			StoredType thisType,
+			StoredType type,
 			GlobalTypeRegistry registry,
 			int autoGetterAccess,
 			int autoSetterAccess,
 		this.autoGetterAccess = autoGetterAccess;
 		this.autoSetterAccess = autoSetterAccess;
 		
-		ITypeID[] parameters = null;
+		TypeID[] parameters = null;
 		if (definition.typeParameters != null) {
-			parameters = new ITypeID[definition.typeParameters.length];
+			parameters = new TypeID[definition.typeParameters.length];
 			for (int i = 0; i < parameters.length; i++)
-				parameters[i] = registry.getGeneric(definition.typeParameters[i], null);
+				parameters[i] = registry.getGeneric(definition.typeParameters[i]);
 		}
 		
 		if (autoGetterAccess != 0) {
 			HighLevelDefinition definition,
 			int modifiers,
 			String name,
-			ITypeID type,
+			StoredType type,
 			int autoGetterAccess,
 			int autoSetterAccess,
 			GetterMember autoGetter,
 	}
 
 	@Override
-	public DefinitionMemberRef ref(ITypeID type, GenericMapper mapper) {
+	public DefinitionMemberRef ref(StoredType type, GenericMapper mapper) {
 		return new FieldMemberRef(type, this, mapper);
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/FunctionalMember.java

 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 
 /**
 	
 	public abstract FunctionalKind getKind();
 	
-	public FunctionalMemberRef ref(ITypeID type, GenericMapper mapper) {
+	public FunctionalMemberRef ref(StoredType type) {
+		return new FunctionalMemberRef(this, type, null);
+	}
+	
+	public FunctionalMemberRef ref(StoredType type, GenericMapper mapper) {
 		return new FunctionalMemberRef(this, type, mapper);
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/GetterMember.java

 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 
 			HighLevelDefinition definition,
 			int modifiers,
 			String name,
-			ITypeID type,
+			StoredType type,
 			BuiltinID builtin) {
 		super(position, definition, modifiers, type, builtin);
 		
 	public void setBody(Statement body) {
 		this.body = body;
 		
-		if (type == BasicTypeID.UNDETERMINED)
+		if (type.type == BasicTypeID.UNDETERMINED)
 			type = body.getReturnType();
 	}
 	
 	public void setOverrides(GetterMemberRef override) {
 		this.overrides = override;
 		
-		if (type == BasicTypeID.UNDETERMINED)
+		if (type.type == BasicTypeID.UNDETERMINED)
 			type = override.getType();
 	}
 
 	@Override
-	public DefinitionMemberRef ref(ITypeID type, GenericMapper mapper) {
+	public DefinitionMemberRef ref(StoredType type, GenericMapper mapper) {
 		return new GetterMemberRef(type, this, mapper);
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/IDefinitionMember.java

 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 	
 	boolean isAbstract();
 	
-	DefinitionMemberRef ref(ITypeID type, GenericMapper mapper);
+	DefinitionMemberRef ref(StoredType type, GenericMapper mapper);
 	
 	FunctionHeader getHeader();
 }