Merge branch 'development' of git.openzen.org:ZenScript/ZenScript into development

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

 import org.openzen.zenscript.codemodel.expression.SetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
+import org.openzen.zenscript.codemodel.expression.StorageCastExpression;
 import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
 import org.openzen.zenscript.codemodel.expression.ThrowExpression;
 				case CAST: {
 					StringBuilder result = new StringBuilder();
 					result.append(" as ");
-					result.append(expression.arguments.typeArguments[0].accept(typeFormatter));
+					result.append(typeFormatter.format(expression.arguments.typeArguments[0]));
 					return new ExpressionString(result.toString(), ZenScriptOperator.CAST);
 				}
 				default:
 		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);
 	}
 	
+	@Override
+	public ExpressionString visitStorageCast(StorageCastExpression expression) {
+		return expression.value.accept(this);
+	}
+	
 	@Override
 	public ExpressionString visitSupertypeCast(SupertypeCastExpression expression) {
 		return expression.value.accept(this);

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.StoredType;
 
 /**
  *
 			output.append("protected ");
 		if (Modifiers.isPublic(modifiers))
 			output.append("public ");
-		if (Modifiers.isExport(modifiers))
-			output.append("export ");
+		if (Modifiers.isInternal(modifiers))
+			output.append("internal ");
 		if (Modifiers.isStatic(modifiers))
 			output.append("static ");
 		if (Modifiers.isAbstract(modifiers))
 			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 (StoredType typeArgument : arguments.typeArguments) {
 				if (index > 0)
 					result.append(", ");
-				result.append(typeArgument.accept(typeFormatter));
+				result.append(typeFormatter.format(typeArgument));
 				index++;
 			}
 			result.append(">");

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

 	@Override
 	public Void visitConst(ConstMember member) {
 		visit(true);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		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");
 	@Override
 	public Void visitField(FieldMember member) {
 		visit(true);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		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(" = ")
 	@Override
 	public Void visitConstructor(ConstructorMember member) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		output.append("this");
 		FormattingUtils.formatHeader(output, settings, member.header, typeFormatter);
 		formatBody(member.body);
 	@Override
 	public Void visitDestructor(DestructorMember member) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		output.append("this");
 		formatBody(member.body);
 		return null;
 	@Override
 	public Void visitMethod(MethodMember member) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		output.append(member.name);
 		FormattingUtils.formatHeader(output, settings, member.header, typeFormatter);
 		formatBody(member.body);
 	@Override
 	public Void visitGetter(GetterMember member) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		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;
 	}
 	@Override
 	public Void visitSetter(SetterMember member) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		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;
 	}
 	@Override
 	public Void visitOperator(OperatorMember member) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		switch (member.operator) {
 			case ADD: output.append("+"); break;
 			case SUB: output.append("-"); break;
 	@Override
 	public Void visitCaster(CasterMember member) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		output.append(" as ");
-		output.append(member.toType.accept(typeFormatter));
+		output.append(typeFormatter.format(member.toType));
 		formatBody(member.body);
 		return null;
 	}
 	@Override
 	public Void visitCaller(CallerMember member) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		FormattingUtils.formatHeader(output, settings, member.header, typeFormatter);
 		formatBody(member.body);
 		return null;
 	@Override
 	public Void visitImplementation(ImplementationMember implementation) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, implementation.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, implementation.getSpecifiedModifiers());
 		output.append("implements ");
 		output.append(implementation.type.accept(typeFormatter));
 		if (settings.classBracketOnSameLine) {

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.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
+import org.openzen.zenscript.codemodel.type.OptionalTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 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.getSpecifiedStorage() == null ? "" : "`" + type.getSpecifiedStorage().toString());
+	}
 
 	@Override
 	public String visitBasic(BasicTypeID basic) {
 		return basic.name;
 	}
+	
+	@Override
+	public String visitString(StringTypeID string) {
+		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) {
-			return element + "[]";
+			result = element + "[]";
 		} else {
-			return element + "[" + Chars.times(',', array.dimension - 1) + "]";
+			result = element + "[" + Chars.times(',', array.dimension - 1) + "]";
 		}
+		return result;
 	}
 
 	@Override
 	public String visitAssoc(AssocTypeID assoc) {
-		return assoc.valueType.accept(this) + "[" + assoc.keyType.accept(this) + "]";
+		return format(assoc.valueType) + "[" + format(assoc.keyType) + "]";
 	}
 
 	@Override
 	@Override
 	public String visitDefinition(DefinitionTypeID definition) {
 		String importedName = importer.importDefinition(definition.definition);
-		if (definition.typeParameters == null)
+		if (definition.typeArguments == null)
 			return importedName;
 		
 		StringBuilder result = new StringBuilder();
 		result.append(importedName);
 		result.append("<");
 		int index = 0;
-		for (ITypeID typeParameter : definition.typeParameters) {
+		for (StoredType typeParameter : definition.typeArguments) {
 			if (index > 0)
 				result.append(", ");
 			
-			result.append(typeParameter.accept(this));
+			result.append(format(typeParameter));
 		}
 		result.append(">");
 		return result.toString();
 
 	@Override
 	public String visitRange(RangeTypeID range) {
-		return range.baseType.accept(this) + " .. " + range.baseType.accept(this);
+		return format(range.baseType) + " .. " + format(range.baseType);
 	}
 
 	@Override
-	public String visitModified(ModifiedTypeID type) {
-		StringBuilder result = new StringBuilder();
-		if (type.isConst())
-			result.append("const ");
-		if (type.isImmutable())
-			result.append("immutable ");
-		result.append(type.accept(this));
-		if (type.isOptional())
-			result.append("?");
-		
-		return result.toString();
+	public String visitOptional(OptionalTypeID type) {
+		return type.accept(this) + "?";
 	}
 
 	@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("]>");

CodeModel/src/main/java/org/openzen/zenscript/codemodel/AccessScope.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;
+
+import java.util.Objects;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public final class AccessScope {
+	public final Module module;
+	public final HighLevelDefinition definition;
+	
+	public AccessScope(Module module, HighLevelDefinition definition) {
+		this.module = module;
+		this.definition = definition;
+	}
+	
+	public boolean hasAccessTo(AccessScope other, int access) {
+		if (Modifiers.isPublic(access))
+			return true;
+		if (definition == other.definition || definition.isOuterOf(other.definition) || other.definition.isOuterOf(definition))
+			return true;
+		if (Modifiers.isPrivate(access))
+			return false;
+		if (Modifiers.isInternal(access))
+			return module == other.module;
+		if (Modifiers.isProtected(access))
+			return definition.isSubclassOf(other.definition);
+		
+		return false;
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = 7;
+		hash = 79 * hash + Objects.hashCode(this.module);
+		hash = 79 * hash + Objects.hashCode(this.definition);
+		return hash;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null || getClass() != obj.getClass())
+			return false;
+		
+		final AccessScope other = (AccessScope) obj;
+		return module == other.module && definition == other.definition;
+	}
+}

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.storage.StorageTag;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class FunctionHeader {
-	private static final FunctionParameter[] NO_PARAMETERS = new FunctionParameter[0];
-	
 	public final TypeParameter[] typeParameters;
-	private ITypeID returnType;
+	private StoredType returnType;
 	public final FunctionParameter[] parameters;
-	public final ITypeID thrownType;
+	public final StoredType thrownType;
+	public final StorageTag storage;
 	
 	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();
 		
 		this.typeParameters = TypeParameter.NONE;
 		this.returnType = returnType;
-		this.parameters = NO_PARAMETERS;
+		this.parameters = FunctionParameter.NONE;
 		this.thrownType = null;
+		this.storage = null;
 		
 		minParameters = 0;
 		maxParameters = 0;
-		hasUnknowns = returnType == BasicTypeID.UNDETERMINED;
+		hasUnknowns = returnType.type == BasicTypeID.UNDETERMINED;
+	}
+	
+	public FunctionHeader(BasicTypeID returnType) {
+		this(returnType.stored);
 	}
 	
-	public FunctionHeader(ITypeID returnType, ITypeID... parameterTypes) {
+	public FunctionHeader(StoredType returnType, StoredType... parameterTypes) {
 		if (returnType == null)
 			throw new NullPointerException();
 		
 		this.returnType = returnType;
 		this.parameters = new FunctionParameter[parameterTypes.length];
 		this.thrownType = null;
+		this.storage = null;
 		
 		for (int i = 0; i < parameterTypes.length; i++)
 			parameters[i] = new FunctionParameter(parameterTypes[i], null);
 		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();
 		
 		this.returnType = returnType;
 		this.parameters = parameters;
 		this.thrownType = null;
+		this.storage = null;
 		
 		minParameters = getMinParameters(parameters);
 		maxParameters = getMaxParameters(parameters);
 		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, StorageTag storage, FunctionParameter... parameters) {
 		if (returnType == null)
 			throw new NullPointerException();
 		if (typeParameters == null)
 		this.returnType = returnType;
 		this.parameters = parameters;
 		this.thrownType = thrownType;
+		this.storage = storage;
 		
 		minParameters = getMinParameters(parameters);
 		maxParameters = getMaxParameters(parameters);
 		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();
 		
 	}
 	
 	public boolean isDenormalized() {
-		if (returnType.getNormalized() != returnType)
+		if (!returnType.getNormalized().equals(returnType))
 			return true;
 		for (FunctionParameter parameter : parameters)
 			if (parameter.type.getNormalized() != parameter.type)
 		
 		FunctionParameter[] normalizedParameters = new FunctionParameter[parameters.length];
 		for (int i = 0; i < normalizedParameters.length; i++)
-			normalizedParameters[i] = parameters[i].normalized(registry);
-		return new FunctionHeader(typeParameters, returnType.getNormalized(), thrownType == null ? null : thrownType.getNormalized(), normalizedParameters);
+			normalizedParameters[i] = parameters[i].normalize(registry);
+		return new FunctionHeader(typeParameters, returnType.getNormalized(), thrownType == null ? null : thrownType.getNormalized(), storage, normalizedParameters);
 	}
 	
 	public int getNumberOfTypeParameters() {
 		return false;
 	}
 	
-	public FunctionHeader withReturnType(ITypeID 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 new FunctionHeader(resultTypeParameters, resultReturnType, resultThrownType, resultParameters);
+		StorageTag resultStorage = this.storage;
+		if (resultStorage == null)
+			resultStorage = overridden.storage;
+		
+		return new FunctionHeader(resultTypeParameters, resultReturnType, resultThrownType, resultStorage, resultParameters);
 	}
 	
 	public boolean matchesExactly(CallArguments arguments, TypeScope scope) {
 		if (arguments.arguments.length < minParameters || arguments.arguments.length > maxParameters)
 			return false;
 		
-		FunctionHeader header = fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
+		FunctionHeader header = fillGenericArguments(scope, arguments.typeArguments);
 		for (int i = 0; i < header.parameters.length; i++) {
-			if (arguments.arguments[i].type != header.parameters[i].type)
+			if (!arguments.arguments[i].type.equals(header.parameters[i].type))
 				return false;
 		}
 		
 		if (arguments.arguments.length < minParameters || arguments.arguments.length > maxParameters)
 			return false;
 		
-		FunctionHeader header = fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
+		FunctionHeader header = fillGenericArguments(scope, arguments.typeArguments);
 		for (int i = 0; i < header.parameters.length; i++) {
 			if (!scope.getTypeMembers(arguments.arguments[i].type).canCastImplicit(header.parameters[i].type))
 				return false;
 			}
 			result.append('>');
 		}
+		if (storage != null)
+			result.append(storage);
 		result.append('(');
 		for (int i = 0; i < parameters.length; i++) {
 			if (i > 0)
 		return result.toString();
 	}
 	
-	public ITypeID[] inferTypes(LocalMemberCache cache, CallArguments arguments, List<ITypeID> resultHint) {
+	public StoredType[] 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, StoredType> 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, StoredType> 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, StoredType> 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];
+		StoredType[] result = new StoredType[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)
 			return false;
 		
 		for (int i = 0; i < parameters.length; i++) {
-			if (parameters[i].type != other.parameters[i].type)
+			if (!parameters[i].type.equals(other.parameters[i].type))
 				return false;
 		}
 		
 	
 	public FunctionHeader instanceForCall(GlobalTypeRegistry registry, CallArguments arguments) {
 		if (arguments.getNumberOfTypeArguments() > 0) {
-			Map<TypeParameter, ITypeID> typeParameters = new HashMap<>();
-			for (int i = 0; i < this.typeParameters.length; i++) {
-				typeParameters.put(this.typeParameters[i], arguments.typeArguments[i]);
-			}
-			return withGenericArguments(
-					registry,
-					new GenericMapper(registry, typeParameters));
+			Map<TypeParameter, StoredType> typeParameters = StoredType.getMapping(this.typeParameters, arguments.typeArguments);
+			return instance(new GenericMapper(registry, typeParameters));
 		} else {
 			return this;
 		}
 	}
 	
-	public FunctionHeader withGenericArguments(GlobalTypeRegistry registry, GenericMapper mapper) {
-		if (typeParameters.length > 0) {
-			Map<TypeParameter, ITypeID> innerMap = new HashMap<>();
-			for (TypeParameter parameter : typeParameters)
-				innerMap.put(parameter, mapper.registry.getGeneric(parameter));
-			
-			mapper = mapper.getInner(registry, innerMap);
-		}
+	public FunctionHeader withGenericArguments(GenericMapper mapper) {
+		if (typeParameters.length > 0)
+			mapper = mapper.getInner(mapper.registry, StoredType.getSelfMapping(mapper.registry, typeParameters));
 		
-		ITypeID returnType = this.returnType.instance(mapper);
+		return instance(mapper);
+	}
+	
+	private FunctionHeader instance(GenericMapper 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);
+		return new FunctionHeader(typeParameters, returnType, thrownType == null ? null : thrownType.instance(mapper), storage, parameters);
 	}
 	
-	public FunctionHeader fillGenericArguments(GlobalTypeRegistry registry, ITypeID[] arguments, GenericMapper typeParameterMapping) {
+	public FunctionHeader fillGenericArguments(TypeScope scope, StoredType[] arguments) {
 		if (arguments == null || arguments.length == 0)
 			return this;
 		
-		Map<TypeParameter, ITypeID> typeArguments = new HashMap<>();
-		for (int i = 0; i < typeParameters.length; i++)
-			typeArguments.put(typeParameters[i], arguments[i]);
-		GenericMapper mapper = typeParameterMapping.getInner(registry, typeArguments);
+		Map<TypeParameter, StoredType> typeArguments = StoredType.getMapping(typeParameters, arguments);
+		GenericMapper mapper = scope.getLocalTypeParameters().getInner(scope.getTypeRegistry(), 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);
 		}
-		return new FunctionHeader(TypeParameter.NONE, returnType, thrownType == null ? null : thrownType.instance(mapper), parameters);
+		return new FunctionHeader(TypeParameter.NONE, returnType, thrownType == null ? null : thrownType.instance(mapper), storage, parameters);
 	}
 	
 	public FunctionHeader forTypeParameterInference() {
-		return new FunctionHeader(BasicTypeID.UNDETERMINED, parameters);
+		return new FunctionHeader(BasicTypeID.UNDETERMINED.stored, parameters);
 	}
 	
 	public FunctionHeader forLambda(FunctionHeader lambdaHeader) {
 		for (int i = 0; i < lambdaHeader.parameters.length; i++)
 			parameters[i] = new FunctionParameter(this.parameters[i].type, lambdaHeader.parameters[i].name);
 		
-		return new FunctionHeader(typeParameters, returnType, thrownType, parameters);
+		return new FunctionHeader(typeParameters, returnType, thrownType, storage, parameters);
 	}
 	
 	public FunctionParameter getVariadicParameter() {
 		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;
 		this.variadic = variadic;
 	}
 	
-	public FunctionParameter normalized(GlobalTypeRegistry registry) {
+	public FunctionParameter normalize(GlobalTypeRegistry registry) {
 		FunctionParameter result = new FunctionParameter(type.getNormalized(), name, defaultValue, variadic);
 		result.annotations = this.annotations;
 		return result;
 	}
 	
 	public FunctionParameter withGenericArguments(GenericMapper mapper) {
-		ITypeID instanced = type.instance(mapper);
-		if (instanced == type)
+		StoredType instanced = type.instance(mapper);
+		if (instanced.equals(type))
 			return this;
 		
 		FunctionParameter result = new FunctionParameter(instanced, name, defaultValue, variadic);
 			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;
 
 /**
  *
 	public static final GenericMapper EMPTY = new GenericMapper(null, Collections.emptyMap());
 	
 	public final GlobalTypeRegistry registry;
-	private final Map<TypeParameter, ITypeID> mapping;
+	private final Map<TypeParameter, StoredType> mapping;
 	
-	public GenericMapper(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
+	public GenericMapper(GlobalTypeRegistry registry, Map<TypeParameter, StoredType> mapping) {
 		this.registry = registry;
 		this.mapping = mapping;
 	}
 	
-	public Map<TypeParameter, ITypeID> getMapping() {
+	public Map<TypeParameter, StoredType> getMapping() {
 		return mapping;
 	}
 	
-	public ITypeID map(ITypeID original) {
+	public StoredType map(StoredType original) {
 		return mapping.isEmpty() ? original : original.instance(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) {
-		if (!mapping.containsKey(type.parameter))
-			throw new IllegalStateException("No mapping found for type " + type);
+	public StoredType 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) : type;
+		return mapping.containsKey(type.parameter) ? mapping.get(type.parameter) : type.stored();
 	}
 	
 	public FunctionHeader map(FunctionHeader original) {
-		return mapping.isEmpty() ? original : original.withGenericArguments(registry, this);
+		return mapping.isEmpty() ? original : original.withGenericArguments(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, StoredType> mapping) {
+		Map<TypeParameter, StoredType> 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, StoredType> resultMap = new HashMap<>(this.mapping);
 		for (TypeParameter parameter : parameters)
-			resultMap.put(parameter, registry.getGeneric(parameter));
+			resultMap.put(parameter, new StoredType(registry.getGeneric(parameter), null));
 		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, StoredType> entry : mapping.entrySet()) {
 			if (first) {
 				first = false;
 			} else {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/GenericName.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/GenericName.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.codemodel.type;
+package org.openzen.zenscript.codemodel;
 
 import java.util.List;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  */
 public class GenericName {
 	public final String name;
-	public final ITypeID[] arguments;
+	public final StoredType[] arguments;
 	
 	public GenericName(String name) {
-		this(name, ITypeID.NONE);
+		this(name, StoredType.NONE);
 	}
 	
-	public GenericName(String name, ITypeID[] arguments) {
+	public GenericName(String name, StoredType[] arguments) {
 		if (arguments == null)
 			throw new NullPointerException("Arguments cannot be null");
 		
 		return arguments.length == 0;
 	}
 	
-	public static ITypeID getInnerType(GlobalTypeRegistry registry, DefinitionTypeID type, List<GenericName> name, int index) {
+	public static TypeID getInnerType(GlobalTypeRegistry registry, DefinitionTypeID type, List<GenericName> name, int index) {
 		while (index < name.size()) {
 			GenericName innerName = name.get(index++);
 			type = type.getInnerType(innerName, registry);

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

 package org.openzen.zenscript.codemodel;
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.Taggable;
 import org.openzen.zenscript.codemodel.annotations.DefinitionAnnotation;
 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.DefinitionTypeID;
+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;
 	}
 	
+	public boolean isSubclassOf(HighLevelDefinition other) {
+		if (superType.isDefinition(other))
+			return true;
+		if (superType == null || !(superType instanceof DefinitionTypeID))
+			return false;
+		
+		DefinitionTypeID superDefinition = (DefinitionTypeID)superType;
+		return superDefinition.definition.isSubclassOf(other);
+	}
+	
 	public int getNumberOfGenericParameters() {
 		return typeParameters == null ? 0 : typeParameters.length;
 	}
 	}
 	
 	public boolean isDestructible() {
+		Set<HighLevelDefinition> scanning = new HashSet<>();
+		return isDestructible(scanning);
+	}
+	
+	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
+		if (scanning.contains(this))
+			return false;
+		
+		scanning.add(this);
+		
 		boolean isDestructible = false;
 		for (IDefinitionMember member : members) {
 			if (member instanceof DestructorMember)
 				isDestructible = true;
-			if ((member instanceof FieldMember) && ((FieldMember)member).type.isDestructible())
-				isDestructible = true;
+			if (member instanceof FieldMember) {
+				FieldMember field = (FieldMember)member;
+				if (field.type.isDestructible(scanning))
+					isDestructible = true;
+			}
 			if ((member instanceof ImplementationMember) && ((ImplementationMember)member).type.isDestructible())
 				isDestructible = true;
 		}
+		
+		scanning.remove(this);
 		return isDestructible;
 	}
 	
 		this.typeParameters = typeParameters;
 	}
 	
+	public AccessScope getAccessScope() {
+		return new AccessScope(module, this);
+	}
+	
 	public List<FieldMember> getFields() {
 		List<FieldMember> fields = new ArrayList<>();
 		for (IDefinitionMember member : members)
 		
 		return null;
 	}
+
+	public boolean isOuterOf(HighLevelDefinition definition) {
+		if (definition.outerDefinition == this)
+			return true;
+		if (definition.outerDefinition == null)
+			return false;
+		
+		return isOuterOf(definition.outerDefinition);
+	}
 }

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

 	private Modifiers() {}
 	
 	public static final int PUBLIC = 1;
-	public static final int EXPORT = 2;
+	public static final int INTERNAL = 2;
 	public static final int PRIVATE = 4;
 	public static final int ABSTRACT = 8;
 	public static final int FINAL = 16;
 		return (modifiers & PUBLIC) > 0;
 	}
 	
-	public static boolean isExport(int modifiers) {
-		return (modifiers & EXPORT) > 0;
+	public static boolean isInternal(int modifiers) {
+		return (modifiers & INTERNAL) > 0;
 	}
 	
 	public static boolean isProtected(int modifiers) {
 	public static boolean isOverride(int modifiers) {
 		return (modifiers & OVERRIDE) > 0;
 	}
+	
+	public static boolean hasAccess(int modifiers) {
+		return (modifiers & (PRIVATE | PUBLIC | PROTECTED | INTERNAL)) > 0;
+	}
 }

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

  */
 package org.openzen.zenscript.codemodel;
 
-import org.openzen.zencode.shared.Taggable;
-
 /**
  *
  * @author Hoofdgebruiker
  */
-public class Module extends Taggable {
+public class Module {
 	public static final Module BUILTIN = new Module("builtin");
 	
 	public final String name;
 	public Module(String name) {
 		this.name = name;
 	}
+	
+	@Override
+	public String toString() {
+		return name;
+	}
 }

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

  */
 package org.openzen.zenscript.codemodel;
 
+import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zencode.shared.ConcatMap;
 import org.openzen.zencode.shared.Taggable;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 
 /**
  * @author Hoofdgebruiker
  */
 public class ScriptBlock extends Taggable {
+	public final Module module;
 	public final ZSPackage pkg;
 	public final List<Statement> statements;
 	
-	public ScriptBlock(ZSPackage pkg, List<Statement> statements) {
+	public ScriptBlock(Module module, ZSPackage pkg, List<Statement> statements) {
+		this.module = module;
 		this.pkg = pkg;
 		this.statements = statements;
 	}
 	
 	public ScriptBlock withStatements(List<Statement> newStatements) {
-		ScriptBlock result = new ScriptBlock(pkg, newStatements);
+		ScriptBlock result = new ScriptBlock(module, pkg, newStatements);
+		result.addAllTagsFrom(this);
+		return result;
+	}
+	
+	public ScriptBlock normalize(TypeScope scope) {
+		List<Statement> normalized = new ArrayList<>();
+		for (Statement statement : statements) {
+			normalized.add(statement.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class)));
+		}
+		ScriptBlock result = new ScriptBlock(module, pkg, normalized);
 		result.addAllTagsFrom(this);
 		return result;
 	}

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

 
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zencode.shared.Tag;
 import stdlib.Strings;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class WhitespaceInfo {
+public class WhitespaceInfo implements Tag {
 	public static WhitespaceInfo from(String whitespaceBefore, String lineAfter, boolean skipLineBefore) {
 		int numNewLines = 0;
 		for (char c : whitespaceBefore.toCharArray())

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

 
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zencode.shared.Tag;
 import stdlib.Strings;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class WhitespacePostComment {
+public class WhitespacePostComment implements Tag {
 	public static WhitespacePostComment fromWhitespace(String whitespace) {
 		List<String> comments = new ArrayList<>();
 		for (String line : Strings.split(whitespace, '\n')) {

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

 import org.openzen.zenscript.codemodel.serialization.CodeSerializationInput;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
 
 /**
  *
 	public static final NativeAnnotationDefinition INSTANCE = new NativeAnnotationDefinition();
 	
 	private static final List<FunctionHeader> INITIALIZERS = Collections.singletonList(
-			new FunctionHeader(BasicTypeID.VOID, BasicTypeID.STRING));
+			new FunctionHeader(BasicTypeID.VOID, StringTypeID.UNIQUE));
 	
 	private NativeAnnotationDefinition() {}
 
 	}
 
 	@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/NativeTag.java

  */
 package org.openzen.zenscript.codemodel.annotations;
 
+import org.openzen.zencode.shared.Tag;
+
 /**
  *
  * @author Hoofdgebruiker
  */
-public class NativeTag {
+public class NativeTag implements Tag {
 	public final String value;
 	
 	public NativeTag(String value) {

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

 import org.openzen.zenscript.codemodel.serialization.CodeSerializationInput;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
 	@Override
 	public List<FunctionHeader> getInitializers(BaseScope scope) {
 		return Collections.singletonList(new FunctionHeader(
-				BasicTypeID.VOID,
-				scope.getType(CodePosition.BUILTIN, enforcementLevelName),
-				BasicTypeID.BOOL,
-				BasicTypeID.STRING));
+				BasicTypeID.VOID.stored,
+				scope.getType(CodePosition.BUILTIN, enforcementLevelName).stored(),
+				BasicTypeID.BOOL.stored,
+				StringTypeID.UNIQUE));
 	}
 
 	@Override
 	}
 
 	@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

 import java.util.Arrays;
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.context.StatementContext;
 import org.openzen.zenscript.codemodel.context.TypeContext;
 import org.openzen.zenscript.codemodel.expression.Expression;
 		if (body == null)
 			return body;
 		
-		ExpressionScope expressionScope = new ExpressionScope(scope, BasicTypeID.BOOL);
-		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));
-		statements.add(new IfStatement(position, inverseCondition, throwStatement, null));
-		
-		if (body instanceof BlockStatement) {
-			statements.addAll(Arrays.asList(((BlockStatement)body).statements));
-		} else {
-			statements.add(body);
+		try {
+			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.stored, message));
+			statements.add(new IfStatement(position, inverseCondition, throwStatement, null));
+
+			if (body instanceof BlockStatement) {
+				statements.addAll(Arrays.asList(((BlockStatement)body).statements));
+			} else {
+				statements.add(body);
+			}
+			return new BlockStatement(position, statements.toArray(new Statement[statements.size()]));
+		} catch (CompileException ex) {
+			// TODO
+			ex.printStackTrace();
+			return body;
 		}
-		return new BlockStatement(position, statements.toArray(new Statement[statements.size()]));
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.Module;
 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.GenericName;
+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;
 		
 		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;
 		

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

 import java.util.List;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 
 /**

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

 import java.util.List;
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+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.StorageTag;
 
 /**
  *
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
+	public TypeID getType(CodePosition position, List<GenericName> name) {
 		if (imports.containsKey(name.get(0).name)) {
+			HighLevelDefinition definition = imports.get(name.get(0).name);
+			if (definition.getNumberOfGenericParameters() != name.get(0).arguments.length)
+				return new InvalidTypeID(position, CompileExceptionCode.INVALID_TYPE_ARGUMENTS, "Invalid number of type arguments");
+			
 			return GenericName.getInnerType(
 					getTypeRegistry(),
-					getTypeRegistry().getForDefinition(imports.get(name.get(0).name), name.get(0).arguments),
+					getTypeRegistry().getForDefinition(definition, name.get(0).arguments),
 					name,
 					1);
 		}
 		
-		ITypeID moduleType = modulePackage.getType(this, name);
+		TypeID moduleType = modulePackage.getType(this, name);
 		if (moduleType != null)
 			return moduleType;
 		
 		return module.getType(position, name);
 	}
+	
+	@Override
+	public StorageTag getStorageTag(CodePosition position, String name, String[] arguments) {
+		return module.getStorageTag(position, name, arguments);
+	}
 
 	@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.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.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;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
+	public TypeID getType(CodePosition position, List<GenericName> name) {
 		if (type != null) {
 			CompilingType compiling = type.getInner(name.get(0).name);
 			if (compiling != null) {
 		
 		return outer.getType(position, name);
 	}
+
+	@Override
+	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
+		return outer.getStorageTag(position, name, parameters);
+	}
 	
 	@Override
-	public ITypeID getThisType() {
-		return type == null ? null : getTypeRegistry().getForMyDefinition(type.load());
+	public StoredType getThisType() {
+		if (type == null)
+			return null;
+		
+		TypeID self = getTypeRegistry().getForMyDefinition(type.load());
+		return self.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.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.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;
 
 /**
  *
 public class ModuleTypeResolutionContext implements TypeResolutionContext {
 	private final GlobalTypeRegistry registry;
 	private final Map<String, AnnotationDefinition> annotations = new HashMap<>();
+	private final Map<String, StorageType> storageTypes = new HashMap<>();
 	private final Map<String, ISymbol> globals;
 	private final ZSPackage rootPackage;
 	
 	public ModuleTypeResolutionContext(
 			GlobalTypeRegistry registry,
 			AnnotationDefinition[] annotations,
+			StorageType[] storageTypes,
 			ZSPackage rootPackage,
 			CompilingPackage rootCompiling,
 			Map<String, ISymbol> globals)
 		
 		for (AnnotationDefinition annotation : annotations)
 			this.annotations.put(annotation.getAnnotationName(), annotation);
+		for (StorageType storageType : storageTypes)
+			this.storageTypes.put(storageType.getName(), storageType);
 	}
 	
 	@Override
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
+	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;
 		}
 	}
 	
 	@Override
-	public ITypeID getThisType() {
+	public StorageTag getStorageTag(CodePosition position, String name, String[] arguments) {
+		if (!storageTypes.containsKey(name))
+			return new InvalidStorageTag(position, CompileExceptionCode.NO_SUCH_STORAGE_TYPE, "No such storage type: " + name);
+		
+		return storageTypes.get(name).instance(position, arguments);
+	}
+	
+	@Override
+	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

 package org.openzen.zenscript.codemodel.context;
 
 import java.util.Arrays;
-import java.util.HashMap;
 import java.util.List;
 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;
 
  */
 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<>();
-		for (TypeParameter parameter : typeParameters)
-			mapper.put(parameter, moduleContext.registry.getGeneric(parameter));
+		Map<TypeParameter, StoredType> mapper = StoredType.getSelfMapping(moduleContext.registry, typeParameters);
 		return new GenericMapper(moduleContext.registry, mapper);
 	}
 	

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

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.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);
+	TypeID getType(CodePosition position, List<GenericName> name);
 	
-	ITypeID getThisType();
+	StorageTag getStorageTag(CodePosition position, String name, String[] parameters);
+	
+	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/EnumDefinition.java

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class EnumDefinition extends HighLevelDefinition {
+	public TypeID asType;
 	public List<EnumConstantMember> enumConstants = new ArrayList<>();
 	
 	public EnumDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {

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.StoredType;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ExpansionDefinition extends HighLevelDefinition {
-	public ITypeID target;
+	public StoredType 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 class FunctionDefinition extends HighLevelDefinition {
 	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), GenericMapper.EMPTY), TypeMemberPriority.SPECIFIED);
+		addMember(caller = new CallerMember(position, this, Modifiers.PUBLIC | Modifiers.STATIC, header, null));
+		callerGroup.addMethod(new FunctionalMemberRef(caller, registry.getFunction(header).stored(StaticStorageTag.INSTANCE), GenericMapper.EMPTY), TypeMemberPriority.SPECIFIED);
 	}
 	
 	public void setCode(Statement statement) {
-		this.statement = statement;
 		caller.setBody(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 static class Option extends Taggable {
+		public final CodePosition position;
 		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(CodePosition position, VariantDefinition variant, String name, int ordinal, StoredType[] types) {
+			this.position = position;
 			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 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.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 		subPackages.put(name, subPackage);
 	}
 	
-	public IPartialExpression getMember(CodePosition position, GlobalTypeRegistry registry, GenericName name) {
+	public IPartialExpression getMember(CodePosition position, GlobalTypeRegistry registry, GenericName name) throws CompileException {
 		if (subPackages.containsKey(name.name) && name.hasNoArguments())
 			return new PartialPackageExpression(position, subPackages.get(name.name));
 		
 		return null;
 	}
 	
-	public ITypeID getType(CodePosition position, TypeResolutionContext context, List<GenericName> nameParts) {
+	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) {
+	public TypeID getType(CodePosition position, TypeResolutionContext context, GenericName name) {
 		if (types.containsKey(name.name)) {
 			return context.getTypeRegistry().getForDefinition(types.get(name.name), name.arguments);
 		}
 		return null;
 	}
 	
-	private ITypeID getType(CodePosition position, TypeResolutionContext context, List<GenericName> nameParts, int depth) {
+	private TypeID getType(CodePosition position, TypeResolutionContext context, List<GenericName> nameParts, int depth) {
 		if (depth >= nameParts.size())
 			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.StoredType;
 
 /**
  *
 public class CallArguments {
 	public static final CallArguments EMPTY = new CallArguments(new Expression[0]);
 	
-	public final ITypeID[] typeArguments;
+	public final StoredType[] typeArguments;
 	public final Expression[] arguments;
 	
 	public CallArguments(Expression... arguments) {
-		this.typeArguments = ITypeID.NONE;
+		this.typeArguments = StoredType.NONE;
 		this.arguments = arguments;
 	}
 	
-	public CallArguments(ITypeID[] typeArguments, Expression[] arguments) {
+	public CallArguments(StoredType[] typeArguments, Expression[] arguments) {
 		if (typeArguments == null)
-			typeArguments = ITypeID.NONE;
+			typeArguments = StoredType.NONE;
 		if (arguments == null)
 			throw new IllegalArgumentException("Arguments cannot be null!");
 		
 		this.arguments = arguments;
 	}
 	
-	public CallArguments(ITypeID... dummy) {
-		this.typeArguments = ITypeID.NONE;
+	public CallArguments(StoredType... dummy) {
+		this.typeArguments = StoredType.NONE;
 		this.arguments = new Expression[dummy.length];
 		for (int i = 0; i < dummy.length; i++)
 			arguments[i] = new DummyExpression(dummy[i]);
 		CallArguments result = this;
 		
 		for (int i = 0; i < arguments.length; i++) {
-			arguments[i] = arguments[i].castImplicit(position, scope, header.parameters[i].type);
+			arguments[i] = arguments[i].normalize(scope).castImplicit(position, scope, header.parameters[i].type);
 		}
 		
 		if (arguments.length < header.parameters.length) {
 			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;

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)
+		if (!ifThen.type.equals(ifElse.type))
 			throw new AssertionError();
 		
 		this.condition = condition;

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/ConstantStringExpression.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.StringTypeID;
 
 /**
  *
 	public final String value;
 	
 	public ConstantStringExpression(CodePosition position, String value) {
-		super(position, BasicTypeID.STRING, null);
+		super(position, StringTypeID.STATIC, 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.ValueStorageTag;
 
 /**
  *
 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(), null);
 		
 		this.value = value;
 	}
 	
 	public EnumConstantExpression(CodePosition position, GlobalTypeRegistry registry, EnumDefinition type, EnumConstantMember value) {
-		super(position, registry.getForDefinition(type), null);
+		super(position, registry.getForDefinition(type).stored(), 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.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.GenericName;
 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.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) throws CompileException {
 		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 StoredType[] getTypeArguments() {
 		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.OperatorType;
 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.GenericName;
+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);
+		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)
 				type,
 				member,
 				compiledArguments,
-				compiledArguments.getNumberOfTypeArguments() == 0 ? member.getHeader() : member.getHeader().fillGenericArguments(scope.getTypeRegistry(), compiledArguments.typeArguments, scope.getLocalTypeParameters()));
+				compiledArguments.getNumberOfTypeArguments() == 0 ? member.getHeader() : member.getHeader().fillGenericArguments(scope, compiledArguments.typeArguments));
 	}
 	
-	public Expression not(Expression value) {
+	public Expression not(Expression value) throws CompileException {
 		TypeMembers members = scope.getTypeMembers(value.type);
 		return members.getOrCreateGroup(OperatorType.NOT)
 				.call(position, scope, value, CallArguments.EMPTY, false);

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);
 	
 	public T visitStaticSetter(StaticSetterExpression expression);
 	
+	public T visitStorageCast(StorageCastExpression expression);
+	
 	public T visitSupertypeCast(SupertypeCastExpression expression);
 	
 	public T visitThis(ThisExpression 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);
 	
 	public R visitStaticSetter(C context, StaticSetterExpression expression);
 	
+	public R visitStorageCast(C context, StorageCastExpression expression);
+	
 	public R visitSupertypeCast(C context, SupertypeCastExpression expression);
 	
 	public R visitThis(C context, ThisExpression 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/GetterExpression.java

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
  *
 	public Expression normalize(TypeScope scope) {
 		return new GetterExpression(position, target.normalize(scope), getter);
 	}
+	
+	@Override
+	public Expression assign(CodePosition position, TypeScope scope, Expression value) throws CompileException {
+		return scope.getTypeMembers(getter.getOwnerType())
+				.getOrCreateGroup(getter.member.name, false)
+				.setter(position, scope, target, value, false);
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.member.ref.ImplementationMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
  *
  */
 public class InterfaceCastExpression extends Expression {
 	public final Expression value;
+	public final ImplementationMemberRef implementation;
 	
-	public InterfaceCastExpression(CodePosition position, Expression value, ITypeID toType) {
-		super(position, toType, value.thrownType);
+	public InterfaceCastExpression(CodePosition position, Expression value, ImplementationMemberRef implementation) {
+		super(position, implementation.implementsType, value.thrownType);
 		
 		this.value = value;
+		this.implementation = implementation;
 	}
 
 	@Override
 	@Override
 	public Expression transform(ExpressionTransformer transformer) {
 		Expression tValue = value.transform(transformer);
-		return value == tValue ? this : new InterfaceCastExpression(position, tValue, type);
+		return value == tValue ? this : new InterfaceCastExpression(position, tValue, implementation);
 	}
 
 	@Override
 	public Expression normalize(TypeScope scope) {
-		return new InterfaceCastExpression(position, value.normalize(scope), type.getNormalized());
+		return new InterfaceCastExpression(position, value.normalize(scope), implementation);
 	}
 }

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.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(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.getNormalized());
 	}
 }

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.SwitchCase;
 import org.openzen.zenscript.codemodel.statement.SwitchStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
+import org.openzen.zenscript.codemodel.statement.VariableID;
 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;
 	}
 	
 	public SwitchedMatch convertToSwitch(String tempVariable) {
-		VarStatement result = new VarStatement(position, tempVariable, type, null, false);
+		VarStatement result = new VarStatement(position, new VariableID(), tempVariable, type, null, false);
 		SwitchStatement switchStatement = new SwitchStatement(position, null, value);
 		boolean hasDefault = false;
 		for (MatchExpression.Case matchCase : cases) {
 				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;
+import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 
 /**
  *
 	
 	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/StaticGetterExpression.java

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 	public Expression normalize(TypeScope scope) {
 		return this;
 	}
+	
+	@Override
+	public Expression assign(CodePosition position, TypeScope scope, Expression value) throws CompileException {
+		return scope.getTypeMembers(getter.getOwnerType())
+				.getOrCreateGroup(getter.member.name, false)
+				.staticSetter(position, scope, value);
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/StorageCastExpression.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.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.StoredType;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class StorageCastExpression extends Expression {
+	public final Expression value;
+	
+	public StorageCastExpression(CodePosition position, Expression value, StoredType toType) {
+		super(position, toType, value.thrownType);
+		
+		this.value = value;
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitStorageCast(this);
+	}
+
+	@Override
+	public <C, R> R accept(C context, ExpressionVisitorWithContext<C, R> visitor) {
+		return visitor.visitStorageCast(context, this);
+	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression transformed = transformer.transform(value);
+		return transformed == this ? this : new StorageCastExpression(position, transformed, type);
+	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		Expression normalized = value.normalize(scope);
+		return normalized == value ? this : new StorageCastExpression(position, normalized, type);
+	}
+}

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 java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 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) throws CompileException {
 		if (arguments != null)
 			return super.call(position, scope, hints, arguments);
 		
 	public Expression normalize(TypeScope scope) {
 		Expression[] normalized = new Expression[arguments.length];
 		for (int i = 0; i < normalized.length; i++)
-			normalized[i] = arguments[i].normalize(scope);
+			normalized[i] = arguments[i].normalize(scope).castImplicit(position, scope, option.types[i]);
 		return new VariantValueExpression(position, type, option, normalized);
 	}
 }

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())