WIP removing stored types

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;

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

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

 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;
 	public String visitBasic(BasicTypeID basic) {
 		return basic.name;
 	}
-	
-	@Override
-	public String visitString(StringTypeID string) {
-		return "string";
-	}
 
 	@Override
 	public String visitArray(ArrayTypeID array) {
 		result.append(importedName);
 		result.append("<");
 		int index = 0;
-		for (StoredType typeParameter : definition.typeArguments) {
+		for (TypeID typeParameter : definition.typeArguments) {
 			if (index > 0)
 				result.append(", ");
 			

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

 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  */
 public class FunctionHeader {
 	public final TypeParameter[] typeParameters;
-	private StoredType returnType;
+	private TypeID returnType;
 	public final FunctionParameter[] parameters;
-	public final StoredType thrownType;
-	public final StorageTag storage;
-	
+	public final TypeID thrownType;
+
 	public final int minParameters;
 	public final int maxParameters;
 	public final boolean hasUnknowns;
 	
-	public FunctionHeader(StoredType returnType) {
+	public FunctionHeader(TypeID returnType) {
 		if (returnType == null)
 			throw new NullPointerException();
 		
 		this.returnType = returnType;
 		this.parameters = FunctionParameter.NONE;
 		this.thrownType = null;
-		this.storage = null;
 		
 		minParameters = 0;
 		maxParameters = 0;
-		hasUnknowns = returnType.type == BasicTypeID.UNDETERMINED;
-	}
-	
-	public FunctionHeader(BasicTypeID returnType) {
-		this(returnType.stored);
+		hasUnknowns = returnType == BasicTypeID.UNDETERMINED;
 	}
 	
-	public FunctionHeader(StoredType returnType, StoredType... parameterTypes) {
+	public FunctionHeader(TypeID returnType, TypeID... 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(BasicTypeID returnType, StoredType... parameterTypes) {
-		this(returnType.stored, parameterTypes);
-	}
-	
-	public FunctionHeader(StoredType returnType, FunctionParameter... parameters) {
+	public FunctionHeader(TypeID 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(BasicTypeID returnType, FunctionParameter... parameters) {
-		this(returnType.stored, parameters);
-	}
-	
-	public FunctionHeader(TypeParameter[] typeParameters, StoredType returnType, StoredType thrownType, StorageTag storage, FunctionParameter... parameters) {
+	public FunctionHeader(TypeParameter[] typeParameters, TypeID returnType, TypeID thrownType, 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);
 		return useTypeParameters;
 	}
 	
-	public StoredType getReturnType() {
+	public TypeID getReturnType() {
 		return returnType;
 	}
 	
-	public void setReturnType(StoredType returnType) {
+	public void setReturnType(TypeID returnType) {
 		if (returnType == null)
 			throw new NullPointerException();
 		
 		this.returnType = returnType;
 	}
 	
-	public StoredType getParameterType(boolean isVariadic, int index) {
+	public TypeID getParameterType(boolean isVariadic, int index) {
 		return getParameter(isVariadic, index).type;
 	}
 	
 		FunctionParameter[] normalizedParameters = new FunctionParameter[parameters.length];
 		for (int i = 0; i < normalizedParameters.length; i++)
 			normalizedParameters[i] = parameters[i].normalize(registry);
-		return new FunctionHeader(typeParameters, returnType.getNormalized(), thrownType == null ? null : thrownType.getNormalized(), storage, normalizedParameters);
+		return new FunctionHeader(typeParameters, returnType.getNormalized(), thrownType == null ? null : thrownType.getNormalized(), normalizedParameters);
 	}
 	
 	public int getNumberOfTypeParameters() {
 	
 	public FunctionHeader inferFromOverride(GlobalTypeRegistry registry, FunctionHeader overridden) {
 		TypeParameter[] resultTypeParameters = typeParameters;
-		StoredType resultReturnType = this.returnType;
-		if (resultReturnType.type == BasicTypeID.UNDETERMINED)
+		TypeID resultReturnType = this.returnType;
+		if (resultReturnType == BasicTypeID.UNDETERMINED)
 			resultReturnType = overridden.returnType;
-		
-		StoredType resultThrownType = this.thrownType;
+
+		TypeID 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.type == BasicTypeID.UNDETERMINED) {
+			if (resultParameters[i].type == BasicTypeID.UNDETERMINED) {
 				FunctionParameter parameter = resultParameters[i];
 				FunctionParameter original = overridden.parameters[i];
 				resultParameters[i] = new FunctionParameter(original.type, parameter.name, parameter.defaultValue, original.variadic);
 			}
 		}
 		
-		StorageTag resultStorage = this.storage;
-		if (resultStorage == null)
-			resultStorage = overridden.storage;
-		
-		return new FunctionHeader(resultTypeParameters, resultReturnType, resultThrownType, resultStorage, resultParameters);
+		return new FunctionHeader(resultTypeParameters, resultReturnType, resultThrownType, resultParameters);
 	}
 	
 	public boolean matchesExactly(CodePosition position, CallArguments arguments, TypeScope scope) {
 			}
 			result.append('>');
 		}
-		if (storage != null && storage != AutoStorageTag.INSTANCE)
-			result.append('`').append(storage);
 		result.append('(');
 		for (int i = 0; i < parameters.length; i++) {
 			if (i > 0)
 	}
 	
 	public String getCanonical() {
-		return getCanonicalWithoutReturnType() + returnType.type.toString();
+		return getCanonicalWithoutReturnType() + returnType.toString();
 	}
 	
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
 			throw new NullPointerException();
 		if (parameters.length != other.parameters.length)
 			return false;
-		if (returnType.type != BasicTypeID.UNDETERMINED && !scope.getTypeMembers(returnType).canCastImplicit(other.returnType))
+		if (returnType != BasicTypeID.UNDETERMINED && !scope.getTypeMembers(returnType).canCastImplicit(other.returnType))
 			return false;
 		
 		for (int i = 0; i < parameters.length; i++) {
-			if (parameters[i].type.type == BasicTypeID.UNDETERMINED)
+			if (parameters[i].type == BasicTypeID.UNDETERMINED)
 				continue;
 			
 			if (parameters[i].variadic != other.parameters[i].variadic)
 	
 	public FunctionHeader instanceForCall(CodePosition position, GlobalTypeRegistry registry, CallArguments arguments) {
 		if (arguments.getNumberOfTypeArguments() > 0) {
-			Map<TypeParameter, StoredType> typeParameters = StoredType.getMapping(this.typeParameters, arguments.typeArguments);
+			Map<TypeParameter, TypeID> typeParameters = TypeID.getMapping(this.typeParameters, arguments.typeArguments);
 			return instance(new GenericMapper(position, registry, typeParameters));
 		} else {
 			return this;
 	
 	public FunctionHeader withGenericArguments(GenericMapper mapper) {
 		if (typeParameters.length > 0)
-			mapper = mapper.getInner(mapper.position, mapper.registry, StoredType.getSelfMapping(mapper.registry, typeParameters));
+			mapper = mapper.getInner(mapper.position, mapper.registry, TypeID.getSelfMapping(mapper.registry, typeParameters));
 		
 		return instance(mapper);
 	}
 	
 	private FunctionHeader instance(GenericMapper mapper) {
-		StoredType returnType = this.returnType.instance(mapper);
+		TypeID 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), storage, parameters);
+		return new FunctionHeader(typeParameters, returnType, thrownType == null ? null : thrownType.instance(mapper), parameters);
 	}
 	
-	public FunctionHeader fillGenericArguments(CodePosition position, TypeScope scope, StoredType[] arguments) {
+	public FunctionHeader fillGenericArguments(CodePosition position, TypeScope scope, TypeID[] arguments) {
 		if (arguments == null || arguments.length == 0)
 			return this;
 		
-		Map<TypeParameter, StoredType> typeArguments = StoredType.getMapping(typeParameters, arguments);
+		Map<TypeParameter, TypeID> typeArguments = TypeID.getMapping(typeParameters, arguments);
 		GenericMapper mapper = scope.getLocalTypeParameters().getInner(position, scope.getTypeRegistry(), typeArguments);
-		
-		StoredType returnType = this.returnType.instance(mapper);
+
+		TypeID 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), storage, parameters);
+		return new FunctionHeader(TypeParameter.NONE, returnType, thrownType == null ? null : thrownType.instance(mapper), parameters);
 	}
 	
 	public FunctionHeader forTypeParameterInference() {
-		return new FunctionHeader(BasicTypeID.UNDETERMINED.stored, parameters);
+		return new FunctionHeader(BasicTypeID.UNDETERMINED, 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, storage, parameters);
+		return new FunctionHeader(typeParameters, returnType, thrownType, parameters);
 	}
 	
 	public FunctionParameter getVariadicParameter() {
 		return parameters[parameters.length - 1].variadic ? Integer.MAX_VALUE : parameters.length;
 	}
 	
-	private static boolean hasUnknowns(StoredType[] types, StoredType returnType) {
-		if (returnType.type == BasicTypeID.UNDETERMINED)
+	private static boolean hasUnknowns(TypeID[] types, TypeID returnType) {
+		if (returnType == BasicTypeID.UNDETERMINED)
 			return true;
 		
-		for (StoredType type : types)
-			if (type.type == BasicTypeID.UNDETERMINED)
+		for (TypeID type : types)
+			if (type == BasicTypeID.UNDETERMINED)
 				return true;
 		
 		return false;
 	}
 	
-	private static boolean hasUnknowns(FunctionParameter[] parameters, StoredType returnType) {
-		if (returnType.type == BasicTypeID.UNDETERMINED)
+	private static boolean hasUnknowns(FunctionParameter[] parameters, TypeID returnType) {
+		if (returnType == BasicTypeID.UNDETERMINED)
 			return true;
 		
 		for (FunctionParameter parameter : parameters)
-			if (parameter.type.type == BasicTypeID.UNDETERMINED)
+			if (parameter.type == BasicTypeID.UNDETERMINED)
 				return true;
 		
 		return false;

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

 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.StoredType;
 import org.openzen.zenscript.codemodel.annotations.ParameterAnnotation;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 	public static final FunctionParameter[] NONE = new FunctionParameter[0];
 	
 	public ParameterAnnotation[] annotations;
-	public final StoredType type;
+	public final TypeID type;
 	public final String name;
 	public Expression defaultValue;
 	public final boolean variadic;
 	
-	public FunctionParameter(StoredType type) {
+	public FunctionParameter(TypeID type) {
 		this.annotations = ParameterAnnotation.NONE;
 		this.type = type;
 		this.name = "";
 		this.variadic = false;
 	}
 	
-	public FunctionParameter(BasicTypeID type) {
-		this(type.stored);
-	}
-	
-	public FunctionParameter(StoredType type, String name) {
+	public FunctionParameter(TypeID type, String name) {
 		this.annotations = ParameterAnnotation.NONE;
 		this.type = type;
 		this.name = name;
 		this.variadic = false;
 	}
 	
-	public FunctionParameter(StoredType type, String name, Expression defaultValue, boolean variadic) {
+	public FunctionParameter(TypeID type, String name, Expression defaultValue, boolean variadic) {
 		this.annotations = ParameterAnnotation.NONE;
 		this.type = type;
 		this.name = name;
 	}
 	
 	public FunctionParameter withGenericArguments(GenericMapper mapper) {
-		StoredType instanced = type.instance(mapper);
+		TypeID instanced = type.instance(mapper);
 		if (instanced.equals(type))
 			return this;
 		

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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 	
 	public final CodePosition position;
 	public final GlobalTypeRegistry registry;
-	private final Map<TypeParameter, StoredType> mapping;
+	private final Map<TypeParameter, TypeID> mapping;
 	
-	public GenericMapper(CodePosition position, GlobalTypeRegistry registry, Map<TypeParameter, StoredType> mapping) {
+	public GenericMapper(CodePosition position, GlobalTypeRegistry registry, Map<TypeParameter, TypeID> mapping) {
 		if (mapping == null)
 			throw new IllegalArgumentException();
 		
 		this.mapping = mapping;
 	}
 	
-	public Map<TypeParameter, StoredType> getMapping() {
+	public Map<TypeParameter, TypeID> getMapping() {
 		return mapping;
 	}
 	
-	public StoredType map(StoredType original) {
+	public TypeID map(TypeID original) {
 		return mapping.isEmpty() ? original : original.instance(this);
 	}
 	
-	public StoredType[] map(StoredType[] original) {
+	public TypeID[] map(TypeID[] original) {
 		if (mapping.isEmpty() || original.length == 0)
 			return original;
-		
-		StoredType[] mapped = new StoredType[original.length];
+
+		TypeID[] mapped = new TypeID[original.length];
 		for (int i = 0; i < original.length; i++)
 			mapped[i] = original[i].instance(this);
 		return mapped;
 	}
 	
-	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.stored();
+	public TypeID map(GenericTypeID type) {
+		return mapping.getOrDefault(type.parameter, type);
 	}
 	
 	public FunctionHeader map(FunctionHeader original) {
 		return mapping.isEmpty() ? original : original.withGenericArguments(this);
 	}
 	
-	public GenericMapper getInner(CodePosition position, GlobalTypeRegistry registry, Map<TypeParameter, StoredType> mapping) {
-		Map<TypeParameter, StoredType> resultMap = new HashMap<>(this.mapping);
+	public GenericMapper getInner(CodePosition position, GlobalTypeRegistry registry, Map<TypeParameter, TypeID> mapping) {
+		Map<TypeParameter, TypeID> resultMap = new HashMap<>(this.mapping);
 		resultMap.putAll(mapping);
 		return new GenericMapper(position, registry, resultMap);
 	}
 	
 	public GenericMapper getInner(CodePosition position, GlobalTypeRegistry registry, TypeParameter[] parameters) {
-		Map<TypeParameter, StoredType> resultMap = new HashMap<>(this.mapping);
+		Map<TypeParameter, TypeID> resultMap = new HashMap<>(this.mapping);
 		for (TypeParameter parameter : parameters)
-			resultMap.put(parameter, new StoredType(registry.getGeneric(parameter), null));
+			resultMap.put(parameter, registry.getGeneric(parameter));
 		return new GenericMapper(position, registry, resultMap);
 	}
 	
 		StringBuilder result = new StringBuilder();
 		result.append('{');
 		boolean first = true;
-		for (Map.Entry<TypeParameter, StoredType> entry : mapping.entrySet()) {
+		for (Map.Entry<TypeParameter, TypeID> entry : mapping.entrySet()) {
 			if (first) {
 				first = false;
 			} else {

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

 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 StoredType[] arguments;
+	public final TypeID[] arguments;
 	
 	public GenericName(String name) {
-		this(name, StoredType.NONE);
+		this(name, TypeID.NONE);
 	}
 	
-	public GenericName(String name, StoredType[] arguments) {
+	public GenericName(String name, TypeID[] arguments) {
 		if (arguments == null)
 			throw new NullPointerException("Arguments cannot be null");
 		

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, StringTypeID.UNIQUE));
+			new FunctionHeader(BasicTypeID.VOID, BasicTypeID.STRING));
 	
 	private NativeAnnotationDefinition() {}
 

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

 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 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.stored,
-				scope.getType(CodePosition.BUILTIN, enforcementLevelName).stored(),
-				BasicTypeID.BOOL.stored,
-				StringTypeID.UNIQUE));
+				BasicTypeID.VOID,
+				scope.getType(CodePosition.BUILTIN, enforcementLevelName),
+				BasicTypeID.BOOL,
+				BasicTypeID.STRING));
 	}
 
 	@Override

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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 	
 	public VariantOptionSwitchValue variantOptionSwitchValue;
 	
-	public StatementContext(CodePosition position, ModuleContext module, StoredType thisType) {
+	public StatementContext(CodePosition position, ModuleContext module, TypeID thisType) {
 		super(position, module, TypeParameter.NONE, thisType);
 		
 		loops = LoopStatement.NONE;
 		lambdaOuter = null;
 	}
 	
-	public StatementContext(CodePosition position, ModuleContext module, StoredType thisType, FunctionHeader header) {
+	public StatementContext(CodePosition position, ModuleContext module, TypeID thisType, FunctionHeader header) {
 		super(position, module, header.typeParameters, thisType);
 		
 		loops = LoopStatement.NONE;

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 public class TypeContext {
 	protected final CodePosition position;
 	protected final TypeParameter[] typeParameters;
-	public final StoredType thisType;
+	public final TypeID thisType;
 	private final LocalMemberCache memberCache;
 	public final ModuleContext moduleContext;
 	
-	public TypeContext(CodePosition position, ModuleContext context, TypeParameter[] parameters, StoredType thisType) {
+	public TypeContext(CodePosition position, ModuleContext context, TypeParameter[] parameters, TypeID thisType) {
 		this.position = position;
 		this.typeParameters = parameters;
 		this.thisType = thisType;
 		moduleContext = context;
 	}
 	
-	public TypeContext(CodePosition position, TypeContext outer, StoredType thisType, TypeParameter... inner) {
+	public TypeContext(CodePosition position, TypeContext outer, TypeID thisType, TypeParameter... inner) {
 		this.position = position;
 		typeParameters = concat(outer.typeParameters, inner);
 		this.thisType = thisType;
 		memberCache = new LocalMemberCache(moduleContext.registry, moduleContext.expansions);
 	}
 	
-	public TypeContext(CodePosition position, TypeContext outer, StoredType thisType, List<TypeParameter> inner) {
+	public TypeContext(CodePosition position, TypeContext outer, TypeID thisType, List<TypeParameter> inner) {
 		this(position, outer, thisType, inner.toArray(new TypeParameter[inner.size()]));
 	}
 	
 		return typeParameters[index];
 	}
 	
-	public TypeMembers getTypeMembers(StoredType type) {
+	public TypeMembers getTypeMembers(TypeID type) {
 		return memberCache.get(type);
 	}
 	
 	public GenericMapper getMapper() {
-		Map<TypeParameter, StoredType> mapper = StoredType.getSelfMapping(moduleContext.registry, typeParameters);
+		Map<TypeParameter, TypeID> mapper = TypeID.getSelfMapping(moduleContext.registry, typeParameters);
 		return new GenericMapper(position, moduleContext.registry, mapper);
 	}
 	

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

 import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-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);
 	
 	TypeID getType(CodePosition position, List<GenericName> name);
-	
-	StorageTag getStorageTag(CodePosition position, String name, String[] parameters);
-	
-	StoredType getThisType();
+
+	TypeID getThisType();
 }

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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ExpansionDefinition extends HighLevelDefinition {
-	public StoredType target;
+	public TypeID target;
 	
 	public ExpansionDefinition(CodePosition position, Module module, ZSPackage pkg, int modifiers, HighLevelDefinition outerDefinition) {
 		super(position, module, pkg, null, modifiers, outerDefinition);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 		public final VariantDefinition variant;
 		public final String name;
 		public final int ordinal;
-		public final StoredType[] types;
+		public final TypeID[] types;
 		
-		public Option(CodePosition position, VariantDefinition variant, String name, int ordinal, StoredType[] types) {
+		public Option(CodePosition position, VariantDefinition variant, String name, int ordinal, TypeID[] types) {
 			this.position = position;
 			this.variant = variant;
 			this.name = name;
 			this.types = types;
 		}
 		
-		public VariantOptionRef instance(StoredType variantType, GenericMapper mapper) {
+		public VariantOptionRef instance(TypeID variantType, GenericMapper mapper) {
 			return new VariantOptionRef(this, variantType, mapper.map(types));
 		}
 	}

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;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 	public final Expression[] expressions;
 	public final ArrayTypeID arrayType;
 	
-	public ArrayExpression(CodePosition position, Expression[] expressions, StoredType type) {
+	public ArrayExpression(CodePosition position, Expression[] expressions, TypeID type) {
 		super(position, type, multiThrow(position, expressions));
 		
 		this.expressions = expressions;
-		this.arrayType = (ArrayTypeID)type.type;
+		this.arrayType = (ArrayTypeID)type;
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class CallArguments {
-	public static final CallArguments EMPTY = new CallArguments(new Expression[0]);
+	public static final CallArguments EMPTY = new CallArguments(Expression.NONE);
 	
-	public final StoredType[] typeArguments;
+	public final TypeID[] typeArguments;
 	public final Expression[] arguments;
 	
 	public CallArguments(Expression... arguments) {
-		this.typeArguments = StoredType.NONE;
+		this.typeArguments = TypeID.NONE;
 		this.arguments = arguments;
 	}
 	
-	public CallArguments(StoredType[] typeArguments, Expression[] arguments) {
+	public CallArguments(TypeID[] typeArguments, Expression[] arguments) {
 		if (typeArguments == null)
-			typeArguments = StoredType.NONE;
+			typeArguments = TypeID.NONE;
 		if (arguments == null)
 			throw new IllegalArgumentException("Arguments cannot be null!");
 		
 	}
 	
 	public CallArguments(StoredType... dummy) {
-		this.typeArguments = StoredType.NONE;
+		this.typeArguments = TypeID.NONE;
 		this.arguments = new Expression[dummy.length];
 		for (int i = 0; i < dummy.length; i++)
 			arguments[i] = new DummyExpression(dummy[i]);

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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 public abstract class CapturedExpression extends Expression {
 	public final LambdaClosure closure;
 	
-	public CapturedExpression(CodePosition position, StoredType type, LambdaClosure closure) {
+	public CapturedExpression(CodePosition position, TypeID 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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class CapturedThisExpression extends CapturedExpression {
-	public CapturedThisExpression(CodePosition position, StoredType type, LambdaClosure closure) {
+	public CapturedThisExpression(CodePosition position, TypeID type, LambdaClosure closure) {
 		super(position, type, closure);
 	}
 

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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 			Expression condition,
 			Expression ifThen,
 			Expression ifElse,
-			StoredType type) {
+			TypeID type) {
 		super(position, type, binaryThrow(position, condition.thrownType, binaryThrow(position, ifThen.thrownType, ifElse.thrownType)));
 		
 		if (!ifThen.type.equals(ifElse.type))

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.StringTypeID;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
  *
 	public final String value;
 	
 	public ConstantStringExpression(CodePosition position, String value) {
-		super(position, StringTypeID.STATIC, null);
+		super(position, BasicTypeID.STRING, 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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ConstructorSuperCallExpression extends Expression {
-	public final StoredType objectType;
+	public final TypeID objectType;
 	public final FunctionalMemberRef constructor;
 	public final CallArguments 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)));
+	public ConstructorSuperCallExpression(CodePosition position, TypeID type, FunctionalMemberRef constructor, CallArguments arguments) {
+		super(position, BasicTypeID.VOID, 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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ConstructorThisCallExpression extends Expression {
-	public final StoredType objectType;
+	public final TypeID objectType;
 	public final FunctionalMemberRef constructor;
 	public final CallArguments 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)));
+	public ConstructorThisCallExpression(CodePosition position, TypeID type, FunctionalMemberRef constructor, CallArguments arguments) {
+		super(position, BasicTypeID.VOID, binaryThrow(position, constructor.getHeader().thrownType, multiThrow(position, arguments.arguments)));
 		
-		if (type.type instanceof BasicTypeID)
+		if (type instanceof BasicTypeID)
 			throw new IllegalArgumentException("Type cannot be basic type");
 		
 		this.objectType = type;

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.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.GenericName;
+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.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.StatementTransformer;
 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 StoredType type;
-	public final StoredType thrownType;
+	public final TypeID type;
+	public final TypeID thrownType;
 	
-	public Expression(CodePosition position, StoredType type, StoredType thrownType) {
+	public Expression(CodePosition position, TypeID type, TypeID thrownType) {
 		if (type == null)
 			throw new NullPointerException();
 		//if (type.type == BasicTypeID.UNDETERMINED)
 	public abstract Expression normalize(TypeScope scope);
 	
 	@Override
-	public List<StoredType> getAssignHints() {
+	public List<TypeID> getAssignHints() {
 		return Collections.singletonList(type);
 	}
 	
 		return this;
 	}
 	
-	public Expression castExplicit(CodePosition position, TypeScope scope, StoredType asType, boolean optional) {
+	public Expression castExplicit(CodePosition position, TypeScope scope, TypeID asType, boolean optional) {
 		return scope.getTypeMembers(type).castExplicit(position, this, asType, optional);
 	}
 	
-	public Expression castImplicit(CodePosition position, TypeScope scope, StoredType asType) {
+	public Expression castImplicit(CodePosition position, TypeScope scope, TypeID asType) {
 		return scope.getTypeMembers(type).castImplicit(position, this, asType, true);
 	}
 	
 	}
 	
 	@Override
-	public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) {
+	public List<TypeID>[] predictCallTypes(CodePosition position, TypeScope scope, List<TypeID> hints, int arguments) {
 		TypeMemberGroup group = scope.getTypeMembers(type).getGroup(OperatorType.CALL);
 		return group.predictCallTypes(position, scope, hints, arguments);
 	}
 	
 	@Override
-	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) {
+	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<TypeID> hints, int arguments) {
 		TypeMemberGroup group = scope.getTypeMembers(type).getGroup(OperatorType.CALL);
 		return group.getMethodMembers().stream()
 				.filter(method -> method.member.getHeader().accepts(arguments) && !method.member.isStatic())
 	}
 	
 	@Override
-	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException {
+	public Expression call(CodePosition position, TypeScope scope, List<TypeID> hints, CallArguments arguments) throws CompileException {
 		TypeMemberGroup group = scope.getTypeMembers(type).getGroup(OperatorType.CALL);
 		return group.call(position, scope, this, arguments, false);
 	}
 	
 	@Override
-	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) {
+	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<TypeID> hints, GenericName name) {
 		TypeMembers members = scope.getTypeMembers(type);
 		IPartialExpression result = members.getMemberExpression(position, scope, this, name, false);
 		if (result == null)
 	}
 	
 	@Override
-	public StoredType[] getTypeArguments() {
+	public TypeID[] getTypeArguments() {
 		return null;
 	}
 	
 		throw new UnsupportedOperationException("Cannot evaluate this value to an enum constant!");
 	}
 	
-	public static StoredType binaryThrow(CodePosition position, StoredType left, StoredType right) {
-		if (Objects.equals(left, right))
+	public static TypeID binaryThrow(CodePosition position, TypeID left, TypeID right) {
+		if (left == right)
 			return left;
 		else if (left == null)
 			return right;
 		else if (right == null)
 			return left;
 		else
-			return new InvalidTypeID(position, CompileExceptionCode.DIFFERENT_EXCEPTIONS, "two different exceptions in same operation: " + left.toString() + " and " + right.toString()).stored(UniqueStorageTag.INSTANCE);
+			return new InvalidTypeID(position, CompileExceptionCode.DIFFERENT_EXCEPTIONS, "two different exceptions in same operation: " + left.toString() + " and " + right.toString());
 	}
 	
-	public static StoredType multiThrow(CodePosition position, Expression[] expressions) {
-		StoredType result = null;
+	public static TypeID multiThrow(CodePosition position, Expression[] expressions) {
+		TypeID result = null;
 		for (Expression expression : expressions)
 			result = binaryThrow(position, result, expression.thrownType);
 		return result;

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

 	T visitStaticGetter(StaticGetterExpression expression);
 	
 	T visitStaticSetter(StaticSetterExpression expression);
-	
-	T visitStorageCast(StorageCastExpression expression);
-	
+
 	T visitSupertypeCast(SupertypeCastExpression expression);
 	
 	T visitThis(ThisExpression expression);

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

 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 	
 	public FunctionExpression(
 			CodePosition position,
-			StoredType type,
+			TypeID type,
 			LambdaClosure closure,
 			FunctionHeader header,
 			Statement body) {

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
-import jdk.nashorn.internal.ir.Assignment;
 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;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 	public final CompileExceptionCode code;
 	public final String message;
 	
-	public InvalidExpression(CodePosition position, StoredType type, CompileExceptionCode code, String message) {
+	public InvalidExpression(CodePosition position, TypeID type, CompileExceptionCode code, String message) {
 		super(position, type, null);
 		
 		this.code = code;
 		this.message = message;
 	}
 	
-	public InvalidExpression(StoredType type, CompileException cause) {
+	public InvalidExpression(TypeID type, CompileException cause) {
 		this(cause.position, type, cause.code, cause.message);
 	}
 	

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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 			CodePosition position,
 			Expression[] keys,
 			Expression[] values,
-			StoredType type) {
+			TypeID 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.VarStatement;
 import org.openzen.zenscript.codemodel.statement.VariableID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 	public final Expression value;
 	public final Case[] cases;
 	
-	public MatchExpression(CodePosition position, Expression value, StoredType type, Case[] cases) {
+	public MatchExpression(CodePosition position, Expression value, TypeID type, Case[] cases) {
 		super(position, type, binaryThrow(position, value.thrownType, getThrownType(position, cases)));
 		
 		this.value = value;
 				hasDefault = true;
 		}
 		if (!hasDefault) {
-			Statement defaultCase = new ExpressionStatement(position, new PanicExpression(position, BasicTypeID.VOID.stored, new ConstantStringExpression(position, "Missing case")));
+			Statement defaultCase = new ExpressionStatement(position, new PanicExpression(position, BasicTypeID.VOID, new ConstantStringExpression(position, "Missing case")));
 			switchStatement.cases.add(new SwitchCase(null, new Statement[] { defaultCase }));
 		}
 		return new SwitchedMatch(result, switchStatement);
 		}
 	}
 	
-	private static StoredType getThrownType(CodePosition position, Case[] cases) {
+	private static TypeID getThrownType(CodePosition position, Case[] cases) {
 		if (cases.length == 0)
 			return null;
-		
-		StoredType result = cases[0].value.thrownType;
+
+		TypeID 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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 	
 	public NewExpression(
 			CodePosition position,
-			StoredType type,
+			TypeID type,
 			FunctionalMemberRef constructor,
 			CallArguments arguments)
 	{
 	
 	public NewExpression(
 			CodePosition position,
-			StoredType type,
+			TypeID 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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  */
 public class NullExpression extends Expression {
 	public NullExpression(CodePosition position) {
-		super(position, BasicTypeID.NULL.stored, null);
+		super(position, BasicTypeID.NULL, null);
 	}
 	
-	public NullExpression(CodePosition position, StoredType optionalType) {
+	public NullExpression(CodePosition position, TypeID optionalType) {
 		super(position, optionalType, null);
 	}
 

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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 public class PanicExpression extends Expression {
 	public final Expression value;
 	
-	public PanicExpression(CodePosition position, StoredType type, Expression value) {
+	public PanicExpression(CodePosition position, TypeID 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.RangeTypeID;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 	public final Expression from;
 	public final Expression to;
 	
-	public RangeExpression(CodePosition position, StoredType type, Expression from, Expression to) {
+	public RangeExpression(CodePosition position, TypeID type, Expression from, Expression to) {
 		super(position, type, binaryThrow(position, from.thrownType, to.thrownType));
 	
 		this.from = from;
 		this.to = to;
 	}
 	
-	private RangeExpression(CodePosition position, StoredType type, Expression from, Expression to, StoredType thrownType) {
+	private RangeExpression(CodePosition position, TypeID type, Expression from, Expression to, TypeID thrownType) {
 		super(position, type, thrownType);
 		
 		this.from = from;
 
 	@Override
 	public Expression normalize(TypeScope scope) {
-		StoredType baseType = ((RangeTypeID)type.type).baseType;
+		TypeID baseType = ((RangeTypeID)type).baseType;
 		return new RangeExpression(
 				position,
 				type.getNormalized(),

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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  * 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, StoredType type) {
+	public SupertypeCastExpression(CodePosition position, Expression value, TypeID 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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ThisExpression extends Expression {
-	public ThisExpression(CodePosition position, StoredType type) {
+	public ThisExpression(CodePosition position, TypeID 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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 public class ThrowExpression extends Expression {
 	public final Expression value;
 	
-	public ThrowExpression(CodePosition position, StoredType type, Expression value) {
+	public ThrowExpression(CodePosition position, TypeID 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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 public class TryConvertExpression extends Expression {
 	public final Expression value;
 	
-	public TryConvertExpression(CodePosition position, StoredType type, Expression value) {
+	public TryConvertExpression(CodePosition position, TypeID 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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 public class TryRethrowAsExceptionExpression extends Expression {
 	public final Expression value;
 	
-	public TryRethrowAsExceptionExpression(CodePosition position, StoredType type, Expression value, StoredType thrownType) {
+	public TryRethrowAsExceptionExpression(CodePosition position, TypeID type, Expression value, TypeID 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.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 public class TryRethrowAsResultExpression extends Expression {
 	public final Expression value;
 	
-	public TryRethrowAsResultExpression(CodePosition position, StoredType type, Expression value) {
+	public TryRethrowAsResultExpression(CodePosition position, TypeID type, Expression value) {
 		super(position, type, null);
 		
 		this.value = value;

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

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

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

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

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

 import org.openzen.zencode.shared.Taggable;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	
 	public final CodePosition position;
 	public final String name;
-	public StorageTag storage = null;
 	public final List<TypeParameterBound> bounds = new ArrayList<>();
 	
 	public TypeParameter(CodePosition position, String name) {

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

 import org.openzen.zenscript.codemodel.member.ref.CasterMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 
  * @author Hoofdgebruiker
  */
 public class CasterMember extends FunctionalMember {
-	public StoredType toType;
+	public TypeID toType;
 	public CasterMemberRef overrides;
 	
 	public CasterMember(
 			CodePosition position,
 			HighLevelDefinition definition,
 			int modifiers,
-			StoredType toType,
+			TypeID toType,
 			BuiltinID builtin)
 	{
 		super(position, definition, modifiers, new FunctionHeader(toType), builtin);
 		return "caster to " + toType.toString();
 	}
 	
-	public StoredType getTargetType() {
+	public TypeID getTargetType() {
 		return toType;
 	}
 	

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

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

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

 import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 			HighLevelDefinition definition,
 			int modifiers,
 			String name,
-			StoredType thisType,
-			StoredType type,
+			TypeID thisType,
+			TypeID type,
 			GlobalTypeRegistry registry,
 			int autoGetterAccess,
 			int autoSetterAccess,
 			HighLevelDefinition definition,
 			int modifiers,
 			String name,
-			StoredType type,
+			TypeID type,
 			int autoGetterAccess,
 			int autoSetterAccess,
 			GetterMember autoGetter,
 	}
 
 	@Override
-	public DefinitionMemberRef ref(StoredType type, GenericMapper mapper) {
+	public DefinitionMemberRef ref(TypeID type, GenericMapper mapper) {
 		return new FieldMemberRef(type, this, mapper);
 	}
 	

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

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

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

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

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

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

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

 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 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 InnerDefinition {
 	public final HighLevelDefinition definition;
-	public final Map<TypeParameter, StoredType> outerTypeArguments;
+	public final Map<TypeParameter, TypeID> outerTypeArguments;
 	
 	public InnerDefinition(HighLevelDefinition definition) {
 		this.definition = definition;
 		this.outerTypeArguments = Collections.emptyMap();
 	}
 	
-	public InnerDefinition(HighLevelDefinition definition, Map<TypeParameter, StoredType> outerTypeArguments) {
+	public InnerDefinition(HighLevelDefinition definition, Map<TypeParameter, TypeID> outerTypeArguments) {
 		this.definition = definition;
 		this.outerTypeArguments = outerTypeArguments;
 	}
 	
-	public DefinitionTypeID instance(GlobalTypeRegistry registry, StoredType[] typeArguments, DefinitionTypeID outer) {
+	public DefinitionTypeID instance(GlobalTypeRegistry registry, TypeID[] typeArguments, DefinitionTypeID outer) {
 		return registry.getForDefinition(definition, typeArguments, outer);
 	}
 }

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

 import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class IteratorMember extends FunctionalMember {
-	private final StoredType[] iteratorTypes;
+	private final TypeID[] iteratorTypes;
 	public Statement body;
 	public IteratorMemberRef overrides;
 	
-	public IteratorMember(CodePosition position, HighLevelDefinition definition, int modifiers, StoredType[] iteratorTypes, GlobalTypeRegistry registry, BuiltinID builtin) {
+	public IteratorMember(CodePosition position, HighLevelDefinition definition, int modifiers, TypeID[] iteratorTypes, GlobalTypeRegistry registry, BuiltinID builtin) {
 		super(position, definition, modifiers, createIteratorHeader(registry, iteratorTypes), builtin);
 		
 		this.iteratorTypes = iteratorTypes;
 		return iteratorTypes.length;
 	}
 	
-	public StoredType[] getLoopVariableTypes() {
+	public TypeID[] getLoopVariableTypes() {
 		return iteratorTypes;
 	}
 
 		return FunctionalKind.ITERATOR;
 	}
 	
-	private static FunctionHeader createIteratorHeader(GlobalTypeRegistry registry, StoredType[] iteratorTypes) {
-		return new FunctionHeader(registry.getIterator(iteratorTypes).stored(UniqueStorageTag.INSTANCE));
+	private static FunctionHeader createIteratorHeader(GlobalTypeRegistry registry, TypeID[] iteratorTypes) {
+		return new FunctionHeader(registry.getIterator(iteratorTypes));
 	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 
 /**
  * @author Hoofdgebruiker
  */
 public abstract class PropertyMember extends DefinitionMember {
-	private StoredType type;
+	private TypeID type;
 	public final BuiltinID builtin;
 	
-	public PropertyMember(CodePosition position, HighLevelDefinition definition, int modifiers, StoredType type, BuiltinID builtin) {
+	public PropertyMember(CodePosition position, HighLevelDefinition definition, int modifiers, TypeID type, BuiltinID builtin) {
 		super(position, definition, modifiers);
 		
 		if (type == null)
 		this.builtin = builtin;
 	}
 	
-	public StoredType getType() {
+	public TypeID getType() {
 		return type;
 	}
 	
-	public void setType(StoredType type) {
+	public void setType(TypeID type) {
 		if (type == null)
 			throw new NullPointerException();
 		

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

 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 			HighLevelDefinition definition,
 			int modifiers,
 			String name,
-			StoredType type,
+			TypeID type,
 			BuiltinID builtin)
 	{
 		super(position,
 	public void setOverrides(SetterMemberRef overrides) {
 		this.overrides = overrides;
 		
-		if (getType().type == BasicTypeID.UNDETERMINED) {
+		if (getType() == BasicTypeID.UNDETERMINED) {
 			setType(overrides.getType());
 			parameter = new FunctionParameter(overrides.getType(), "value");
 		}
 	}
 
 	@Override
-	public DefinitionMemberRef ref(StoredType type, GenericMapper mapper) {
+	public DefinitionMemberRef ref(TypeID type, GenericMapper mapper) {
 		return new SetterMemberRef(type, this, mapper);
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/CasterMemberRef.java

 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  */
 public class CasterMemberRef implements DefinitionMemberRef {
 	public final CasterMember member;
-	public final StoredType type;
-	public final StoredType toType;
+	public final TypeID type;
+	public final TypeID toType;
 	
-	public CasterMemberRef(CasterMember member, StoredType type, StoredType toType) {
+	public CasterMemberRef(CasterMember member, TypeID type, TypeID toType) {
 		this.member = member;
 		this.type = type;
 		this.toType = toType;
 	}
 	
 	@Override
-	public StoredType getOwnerType() {
+	public TypeID getOwnerType() {
 		return type;
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/ConstMemberRef.java

 
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.member.ConstMember;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 public class ConstMemberRef extends PropertyRef {
 	public final ConstMember member;
 	
-	public ConstMemberRef(StoredType owner, ConstMember member, GenericMapper mapper) {
+	public ConstMemberRef(TypeID owner, ConstMember member, GenericMapper mapper) {
 		super(owner, member, mapper);
 		this.member = member;
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/DefinitionMemberRef.java

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 		return getTarget().hasTag(type);
 	}
 	
-	StoredType getOwnerType();
+	TypeID getOwnerType();
 	
 	DefinitionMemberRef getOverrides();
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/FieldMemberRef.java

 
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.member.FieldMember;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 public class FieldMemberRef extends PropertyRef {
 	public final FieldMember member;
 	
-	public FieldMemberRef(StoredType owner, FieldMember member, GenericMapper mapper) {
+	public FieldMemberRef(TypeID owner, FieldMember member, GenericMapper mapper) {
 		super(owner, member, mapper);
 		this.member = member;
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/FunctionalMemberRef.java

 import org.openzen.zenscript.codemodel.member.MethodMember;
 import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 
 	private final FunctionalMember target;
 	
 	private FunctionHeader header;
-	private final StoredType type;
+	private final TypeID type;
 	private GenericMapper mapper;
 	
-	public FunctionalMemberRef(FunctionalMember target, StoredType type, GenericMapper mapper) {
+	public FunctionalMemberRef(FunctionalMember target, TypeID type, GenericMapper mapper) {
 		this.target = target;
 		this.type = type;
 		
 	}
 	
 	@Override
-	public StoredType getOwnerType() {
+	public TypeID getOwnerType() {
 		return type;
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/GetterMemberRef.java

 import org.openzen.zenscript.codemodel.expression.GetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
 import org.openzen.zenscript.codemodel.member.GetterMember;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 public class GetterMemberRef extends PropertyRef {
 	public final GetterMember member;
 	
-	public GetterMemberRef(StoredType owner, GetterMember member, GenericMapper mapper) {
+	public GetterMemberRef(TypeID owner, GetterMember member, GenericMapper mapper) {
 		super(owner, member, mapper);
 		
 		this.member = member;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/ImplementationMemberRef.java

 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  */
 public class ImplementationMemberRef implements DefinitionMemberRef {
 	public final ImplementationMember member;
-	private final StoredType type;
-	public final StoredType implementsType;
+	private final TypeID type;
+	public final TypeID implementsType;
 	
-	public ImplementationMemberRef(ImplementationMember member, StoredType owner, StoredType implementsType) {
+	public ImplementationMemberRef(ImplementationMember member, TypeID owner, TypeID implementsType) {
 		this.member = member;
 		this.type = owner;
 		this.implementsType = implementsType;
 	}
 	
 	@Override
-	public StoredType getOwnerType() {
+	public TypeID getOwnerType() {
 		return type;
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/IteratorMemberRef.java

 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.IteratorMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  */
 public class IteratorMemberRef implements DefinitionMemberRef {
 	public final IteratorMember target;
-	private final StoredType owner;
-	public final StoredType[] types;
+	private final TypeID owner;
+	public final TypeID[] types;
 	
-	public IteratorMemberRef(IteratorMember target, StoredType owner, StoredType... types) {
+	public IteratorMemberRef(IteratorMember target, TypeID owner, TypeID... types) {
 		this.target = target;
 		this.owner = owner;
 		this.types = types;
 	}
 	
 	@Override
-	public StoredType getOwnerType() {
+	public TypeID getOwnerType() {
 		return owner;
 	}
 
 
 	@Override
 	public MemberAnnotation[] getAnnotations() {
-		if (target instanceof IteratorMember) {
-			return ((IteratorMember)target).annotations;
-		} else {
-			return null;
-		}
+		return target.annotations;
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/PropertyRef.java

 import org.openzen.zenscript.codemodel.member.PropertyMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 public abstract class PropertyRef implements DefinitionMemberRef {
 	private final PropertyMember member;
 	
-	private final StoredType owner;
-	private StoredType type;
+	private final TypeID owner;
+	private TypeID type;
 	private GenericMapper mapper;
 	
-	public PropertyRef(StoredType owner, PropertyMember member, GenericMapper mapper) {
+	public PropertyRef(TypeID owner, PropertyMember member, GenericMapper mapper) {
 		this.owner = owner;
 		this.member = member;
 		
-		if (member.getType().type == BasicTypeID.UNDETERMINED) {
+		if (member.getType() == BasicTypeID.UNDETERMINED) {
 			type = null;
 			this.mapper = mapper;
 		} else {
 	}
 	
 	@Override
-	public final StoredType getOwnerType() {
+	public final TypeID getOwnerType() {
 		return owner;
 	}
 	
-	public final StoredType getType() {
+	public final TypeID getType() {
 		if (type == null) {
 			//if (member.getType().type == BasicTypeID.UNDETERMINED)
 			//	throw new IllegalStateException("Property is not yet resolved!");

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/SetterMemberRef.java

 
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.member.SetterMember;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 public class SetterMemberRef extends PropertyRef {
 	public final SetterMember member;
 	
-	public SetterMemberRef(StoredType owner, SetterMember member, GenericMapper mapper) {
+	public SetterMemberRef(TypeID owner, SetterMember member, GenericMapper mapper) {
 		super(owner, member, mapper);
 		
 		this.member = member;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/TranslatedOperatorMemberRef.java

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 public class TranslatedOperatorMemberRef extends FunctionalMemberRef {
 	private final CallTranslator translator;
 	
-	public TranslatedOperatorMemberRef(OperatorMember member, StoredType type, GenericMapper mapper, CallTranslator translator) {
+	public TranslatedOperatorMemberRef(OperatorMember member, TypeID type, GenericMapper mapper, CallTranslator translator) {
 		super(member, type, mapper);
 		
 		this.translator = translator;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/VariantOptionRef.java

 
 import org.openzen.zencode.shared.Tag;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  */
 public class VariantOptionRef {
 	private final VariantDefinition.Option option;
-	public final StoredType variant;
-	public final StoredType[] types;
+	public final TypeID variant;
+	public final TypeID[] types;
 	
-	public VariantOptionRef(VariantDefinition.Option option, StoredType variant, StoredType[] types) {
+	public VariantOptionRef(VariantDefinition.Option option, TypeID variant, TypeID[] types) {
 		this.option = option;
 		this.variant = variant;
 		this.types = types;
 		return option.name;
 	}
 	
-	public StoredType getParameterType(int index) {
+	public TypeID getParameterType(int index) {
 		return types[index];
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/IPartialExpression.java

 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public interface IPartialExpression {
-	default List<StoredType> getAssignHints() {
+	default List<TypeID> getAssignHints() {
 		return Collections.emptyList();
 	}
 	
 	Expression eval() throws CompileException;
 	
-	List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) throws CompileException;
+	List<TypeID>[] predictCallTypes(CodePosition position, TypeScope scope, List<TypeID> hints, int arguments) throws CompileException;
 	
-	List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) throws CompileException;
+	List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<TypeID> hints, int arguments) throws CompileException;
 	
-	IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) throws CompileException;
+	IPartialExpression getMember(CodePosition position, TypeScope scope, List<TypeID> hints, GenericName name) throws CompileException;
 	
-	Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException;
-	
-	StoredType[] getTypeArguments();
+	Expression call(CodePosition position, TypeScope scope, List<TypeID> hints, CallArguments arguments) throws CompileException;
+
+	TypeID[] getTypeArguments();
 	
 	/**
 	 * Retrieves the (primary) member this expression refers to, or null if there is no primary target.

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialGlobalExpression.java

 import org.openzen.zenscript.codemodel.expression.GlobalExpression;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.GenericName;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 	private final CodePosition position;
 	private final String name;
 	private final IPartialExpression resolution;
-	private final StoredType[] typeArguments;
+	private final TypeID[] typeArguments;
 	
-	public PartialGlobalExpression(CodePosition position, String name, IPartialExpression resolution, StoredType[] typeArguments) {
+	public PartialGlobalExpression(CodePosition position, String name, IPartialExpression resolution, TypeID[] typeArguments) {
 		this.position = position;
 		this.name = name;
 		this.resolution = resolution;
 	}
 
 	@Override
-	public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) throws CompileException {
+	public List<TypeID>[] predictCallTypes(CodePosition position, TypeScope scope, List<TypeID> hints, int arguments) throws CompileException {
 		return resolution.predictCallTypes(position, scope, hints, arguments);
 	}
 
 	@Override
-	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) throws CompileException {
+	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<TypeID> hints, int arguments) throws CompileException {
 		return resolution.getPossibleFunctionHeaders(scope, hints, arguments);
 	}
 
 	@Override
-	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) throws CompileException {
+	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<TypeID> hints, GenericName name) throws CompileException {
 		return eval().getMember(position, scope, hints, name);
 	}
 
 	@Override
-	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException {
+	public Expression call(CodePosition position, TypeScope scope, List<TypeID> hints, CallArguments arguments) throws CompileException {
 		return new GlobalCallExpression(position, name, arguments, resolution.call(position, scope, hints, arguments));
 	}
 
 	@Override
-	public StoredType[] getTypeArguments() {
+	public TypeID[] getTypeArguments() {
 		return typeArguments;
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialMemberGroupExpression.java

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.LambdaClosure;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
+import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberGroup;
 import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.TypeMember;
 
 /**
 	private final CodePosition position;
 	private final Expression target;
 	private final TypeMemberGroup group;
-	private final StoredType[] typeArguments;
+	private final TypeID[] typeArguments;
 	private final boolean allowStaticUsage;
 	private final TypeScope scope;
 	
 			TypeScope scope,
 			Expression target,
 			TypeMemberGroup group,
-			StoredType[] typeArguments,
+			TypeID[] typeArguments,
 			boolean allowStaticMembers)
 	{
 		this.position = position;
 			Expression target,
 			String name,
 			FunctionalMemberRef member,
-			StoredType[] typeArguments,
+			TypeID[] typeArguments,
 			boolean allowStaticMembers)
 	{
 		this.position = position;
 	}
 	
 	@Override
-	public List<StoredType> getAssignHints() {
+	public List<TypeID> getAssignHints() {
 		if (group.getSetter() != null)
 			return Collections.singletonList(group.getSetter().getType());
 		if (group.getField() != null)
 	}
 
 	@Override
-	public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) {
+	public List<TypeID>[] predictCallTypes(CodePosition position, TypeScope scope, List<TypeID> hints, int arguments) {
 		return group.predictCallTypes(position, scope, hints, arguments);
 	}
 	
 	@Override
-	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) {
+	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<TypeID> hints, int arguments) {
 		List<FunctionHeader> results = new ArrayList<>();
 		for (TypeMember<FunctionalMemberRef> method : group.getMethodMembers()) {
 			if (!method.member.accepts(arguments) || method.member.isStatic())
 	}
 
 	@Override
-	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) throws CompileException {
+	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<TypeID> hints, GenericName name) throws CompileException {
 		return eval().getMember(position, scope, hints, name);
 	}
 
 	@Override
-	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException {
+	public Expression call(CodePosition position, TypeScope scope, List<TypeID> hints, CallArguments arguments) throws CompileException {
 		return group.call(position, scope, target, arguments, allowStaticUsage);
 	}
 	
 	}
 
 	@Override
-	public StoredType[] getTypeArguments() {
+	public TypeID[] getTypeArguments() {
 		return typeArguments;
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialStaticMemberGroupExpression.java

 	private final TypeScope scope;
 	private final TypeID target;
 	private final TypeMemberGroup group;
-	private final StoredType[] typeArguments;
+	private final TypeID[] typeArguments;
 	
-	public PartialStaticMemberGroupExpression(CodePosition position, TypeScope scope, TypeID target, TypeMemberGroup group, StoredType[] typeArguments) {
+	public PartialStaticMemberGroupExpression(CodePosition position, TypeScope scope, TypeID target, TypeMemberGroup group, TypeID[] typeArguments) {
 		this.position = position;
 		this.scope = scope;
 		this.group = group;
 	}
 
 	@Override
-	public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) {
+	public List<TypeID>[] predictCallTypes(CodePosition position, TypeScope scope, List<TypeID> hints, int arguments) {
 		return group.predictCallTypes(position, scope, hints, arguments);
 	}
 	
 	@Override
-	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) {
+	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<TypeID> hints, int arguments) {
 		return group.getMethodMembers().stream()
 				.filter(method -> method.member.getHeader().accepts(arguments) && method.member.isStatic())
 				.map(method -> method.member.getHeader())
 	}
 
 	@Override
-	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) throws CompileException {
+	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<TypeID> hints, GenericName name) throws CompileException {
 		return eval().getMember(position, scope, hints, name);
 	}
 
 	@Override
-	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException {
+	public Expression call(CodePosition position, TypeScope scope, List<TypeID> hints, CallArguments arguments) throws CompileException {
 		return group.callStatic(position, target, scope, arguments);
 	}
 	
 	}
 
 	@Override
-	public StoredType[] getTypeArguments() {
+	public TypeID[] getTypeArguments() {
 		return typeArguments;
 	}
 	
 	@Override
-	public List<StoredType> getAssignHints() {
+	public List<TypeID> getAssignHints() {
 		if (group.getSetter() != null)
 			return Collections.singletonList(group.getSetter().getType());
 		if (group.getField() != null)

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialTypeExpression.java

  */
 package org.openzen.zenscript.codemodel.partial;
 
-import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.expression.LambdaClosure;
 import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-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.storage.StaticExpressionStorageTag;
 
 /**
  *
  */
 public class PartialTypeExpression implements IPartialExpression {
 	private final CodePosition position;
-	private final StoredType type;
-	private final StoredType[] typeArguments;
+	private final TypeID type;
+	private final TypeID[] typeArguments;
 	
-	public PartialTypeExpression(CodePosition position, TypeID type, StoredType[] typeArguments) {
+	public PartialTypeExpression(CodePosition position, TypeID type, TypeID[] typeArguments) {
 		this.position = position;
-		this.type = type.stored(StaticExpressionStorageTag.INSTANCE);
+		this.type = type;
 		this.typeArguments = typeArguments;
 	}
 
 	}
 
 	@Override
-	public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) {
+	public List<TypeID>[] predictCallTypes(CodePosition position, TypeScope scope, List<TypeID> hints, int arguments) {
 		TypeMemberGroup group = scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL);
 		if (group == null)
 			return new List[0];
 	}
 	
 	@Override
-	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) {
+	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<TypeID> hints, int arguments) {
 		TypeMemberGroup group = scope.getTypeMembers(type).getGroup(OperatorType.CALL);
 		return group
 				.getMethodMembers().stream()
 	}
 
 	@Override
-	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) {
+	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<TypeID> hints, GenericName name) {
 		return scope.getTypeMembers(type).getStaticMemberExpression(position, scope, name);
 	}
 
 	@Override
-	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException {
+	public Expression call(CodePosition position, TypeScope scope, List<TypeID> hints, CallArguments arguments) throws CompileException {
 		if (arguments.getNumberOfTypeArguments() == 0 && (typeArguments != null && typeArguments.length > 0))
 			arguments = new CallArguments(typeArguments, arguments.arguments);
 
 		if (group == null)
 			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "This type has not call operator");
 
-		return group.callStatic(position, type.type, scope, arguments);
+		return group.callStatic(position, type, scope, arguments);
 	}
 
 	@Override
-	public StoredType[] getTypeArguments() {
+	public TypeID[] getTypeArguments() {
 		return typeArguments;
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialVariantOptionExpression.java

 import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.GenericName;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 	}
 
 	@Override
-	public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) {
+	public List<TypeID>[] predictCallTypes(CodePosition position, TypeScope scope, List<TypeID> hints, int arguments) {
 		if (arguments != option.getOption().types.length)
 			return new List[0];
 		
 	}
 
 	@Override
-	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) {
+	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<TypeID> hints, int arguments) {
 		if (arguments != option.getOption().types.length)
 			return Collections.emptyList();
 		
 	}
 
 	@Override
-	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) throws CompileException {
+	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<TypeID> hints, GenericName name) throws CompileException {
 		throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Variant options don't have members");
 	}
 
 	@Override
-	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) {
+	public Expression call(CodePosition position, TypeScope scope, List<TypeID> hints, CallArguments arguments) {
 		return new VariantValueExpression(position, option.variant, option, arguments.arguments);
 	}
 
 	@Override
-	public StoredType[] getTypeArguments() {
-		return StoredType.NONE;
+	public TypeID[] getTypeArguments() {
+		return TypeID.NONE;
 	}
 }

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

 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.TypeID;
-import org.openzen.zenscript.codemodel.type.storage.StaticExpressionStorageTag;
 
 /**
  *
 public class DefinitionScope extends BaseScope {
 	private final BaseScope outer;
 	private final HighLevelDefinition definition;
-	private final StoredType type;
+	private final TypeID type;
 	private final TypeMembers members;
 	private final TypeParameter[] typeParameters;
 	private final GenericMapper typeParameterMap;
 		this.outer = outer;
 		this.definition = definition;
 		
-		Map<TypeParameter, StoredType> typeParameters = new HashMap<>();
+		Map<TypeParameter, TypeID> typeParameters = new HashMap<>();
 		if (definition instanceof ExpansionDefinition) {
 			ExpansionDefinition expansion = (ExpansionDefinition)definition;
 			type = expansion.target;
 			this.typeParameters = expansion.typeParameters;
-			typeParameters = StoredType.getSelfMapping(outer.getTypeRegistry(), expansion.typeParameters);
+			typeParameters = TypeID.getSelfMapping(outer.getTypeRegistry(), expansion.typeParameters);
 		} else {
 			DefinitionTypeID definitionType = outer.getTypeRegistry().getForMyDefinition(definition);
-			type = definitionType.stored();
+			type = definitionType;
 			
 			List<TypeParameter> typeParameterList = new ArrayList<>();
 			while (definitionType != null) {
-				typeParameters = StoredType.getSelfMapping(outer.getTypeRegistry(), definitionType.definition.typeParameters);
+				typeParameters = TypeID.getSelfMapping(outer.getTypeRegistry(), definitionType.definition.typeParameters);
 				typeParameterList.addAll(Arrays.asList(definitionType.definition.typeParameters));
 				
 				definitionType = definitionType.definition.isStatic() ? null : definitionType.outer;
 		if (members != null && members.hasInnerType(name.get(0).name)) {
 			TypeID result = members.getInnerType(position, name.get(0));
 			for (int i = 1; i < name.size(); i++) {
-				result = getTypeMembers(result.stored(StaticExpressionStorageTag.INSTANCE)).getInnerType(position, name.get(i));
+				result = getTypeMembers(result).getInnerType(position, name.get(i));
 			}
 			return result;
 		} 
 		return outer.getType(position, name);
 	}
 
-	@Override
-	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
-		return outer.getStorageTag(position, name, parameters);
-	}
-
 	@Override
 	public LoopStatement getLoop(String name) {
 		return null;
 	}
 
 	@Override
-	public StoredType getThisType() {
+	public TypeID getThisType() {
 		return type;
 	}
 

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
 import org.openzen.zenscript.codemodel.expression.GetMatchingVariantField;
 import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
-import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
 	private final BaseScope outer;
 	private final DollarEvaluator dollar;
 	
-	public final List<StoredType> hints;
-	public final Map<TypeParameter, StoredType> genericInferenceMap;
+	public final List<TypeID> hints;
+	public final Map<TypeParameter, TypeID> genericInferenceMap;
 	private final Map<String, Function<CodePosition, Expression>> innerVariables = new HashMap<>();
 	
 	public ExpressionScope(BaseScope outer) {
 		this.genericInferenceMap = Collections.emptyMap();
 	}
 	
-	public ExpressionScope(BaseScope outer, List<StoredType> hints) {
+	public ExpressionScope(BaseScope outer, List<TypeID> hints) {
 		this.outer = outer;
 		this.hints = hints;
 		this.dollar = null;
 		this.genericInferenceMap = Collections.emptyMap();
 	}
 	
-	public ExpressionScope(BaseScope scope, StoredType hint) {
+	public ExpressionScope(BaseScope scope, TypeID hint) {
 		this.outer = scope;
-		this.hints = hint.type == BasicTypeID.UNDETERMINED ? Collections.emptyList() : Collections.singletonList(hint);
+		this.hints = hint == BasicTypeID.UNDETERMINED ? Collections.emptyList() : Collections.singletonList(hint);
 		this.dollar = null;
 		this.genericInferenceMap = Collections.emptyMap();
 	}
 	
 	private ExpressionScope(
 			BaseScope scope,
-			List<StoredType> hints,
+			List<TypeID> hints,
 			DollarEvaluator dollar,
-			Map<TypeParameter, StoredType> genericInferenceMap,
+			Map<TypeParameter, TypeID> genericInferenceMap,
 			Map<String, Function<CodePosition, Expression>> innerVariables) {
 		this.outer = scope;
 		this.hints = hints;
 		innerVariables.put(name, position -> new GetMatchingVariantField(position, value, index));
 	}
 	
-	public List<StoredType> getResultTypeHints() {
+	public List<TypeID> getResultTypeHints() {
 		return hints;
 	}
 	
 		return new ExpressionScope(outer, Collections.emptyList(), dollar, genericInferenceMap, innerVariables);
 	}
 	
-	public ExpressionScope withHint(StoredType hint) {
+	public ExpressionScope withHint(TypeID hint) {
 		return new ExpressionScope(outer, Collections.singletonList(hint), dollar, genericInferenceMap, innerVariables);
 	}
 	
-	public ExpressionScope withHints(List<StoredType> hints) {
+	public ExpressionScope withHints(List<TypeID> hints) {
 		return new ExpressionScope(outer, hints, dollar, genericInferenceMap, innerVariables);
 	}
 	
-	public ExpressionScope createInner(List<StoredType> hints, DollarEvaluator dollar) {
+	public ExpressionScope createInner(List<TypeID> hints, DollarEvaluator dollar) {
 		return new ExpressionScope(outer, hints, dollar, genericInferenceMap, innerVariables);
 	}
 	
 		if (header.typeParameters == null)
 			return this;
 		
-		Map<TypeParameter, StoredType> genericInferenceMap = new HashMap<>();
+		Map<TypeParameter, TypeID> genericInferenceMap = new HashMap<>();
 		for (TypeParameter parameter : header.typeParameters)
 			genericInferenceMap.put(parameter, null);
 		
 	public TypeID getType(CodePosition position, List<GenericName> name) {
 		return outer.getType(position, name);
 	}
-
-	@Override
-	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
-		return outer.getStorageTag(position, name, parameters);
-	}
 	
 	@Override
 	public LoopStatement getLoop(String name) {
 	}
 	
 	@Override
-	public StoredType getThisType() {
+	public TypeID getThisType() {
 		return outer.getThisType();
 	}
 

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

 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	private final BaseScope outer;
 	private final FunctionHeader header;
 	private final GenericMapper typeParameterMap;
-	private final StoredType thisType;
+	private final TypeID thisType;
 	private final DollarEvaluator dollar;
 	
 	public FunctionScope(CodePosition position, BaseScope outer, FunctionHeader header) {
 	public FunctionScope(CodePosition position, BaseScope outer, FunctionHeader header, DollarEvaluator dollar) {
 		this.outer = outer;
 		this.header = header;
-		this.thisType = outer.getThisType() == null || header.storage == null ? outer.getThisType() : outer.getThisType().type.stored(header.storage);
+		this.thisType = outer.getThisType();
 		this.dollar = dollar;
 		
 		if (outer.getLocalTypeParameters() == null)
 	}
 
 	@Override
-	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
-		return outer.getStorageTag(position, name, parameters);
-	}
-
-	@Override
-	public StoredType getThisType() {
+	public TypeID getThisType() {
 		return thisType;
 	}
 

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

 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 public interface TypeScope extends TypeResolutionContext {
 	public LocalMemberCache getMemberCache();
 	
-	default TypeMembers getTypeMembers(StoredType type) {
+	default TypeMembers getTypeMembers(TypeID type) {
 		return getMemberCache().get(type);
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/serialization/CodeSerializationInput.java

 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
-import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
 	
 	HighLevelDefinition readDefinition();
 	
-	DefinitionMemberRef readMember(TypeContext context, StoredType type);
+	DefinitionMemberRef readMember(TypeContext context, TypeID type);
 	
 	EnumConstantMember readEnumConstant(TypeContext context);
 	
-	VariantOptionRef readVariantOption(TypeContext context, StoredType type);
+	VariantOptionRef readVariantOption(TypeContext context, TypeID type);
 	
 	AnnotationDefinition readAnnotationType();
-	
-	TypeID deserializeTypeID(TypeContext context);
-	
-	StoredType deserializeType(TypeContext context);
-	
+
+	TypeID deserializeType(TypeContext context);
+
 	CodePosition deserializePosition();
 	
 	FunctionHeader deserializeHeader(TypeContext context);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/BlockStatement.java

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 		return unchanged ? this : new BlockStatement(position, tStatements);
 	}
 	
-	private static StoredType getThrownType(Statement[] statements) {
-		StoredType result = null;
+	private static TypeID getThrownType(Statement[] statements) {
+		TypeID result = null;
 		for (Statement statement : statements)
 			result = Expression.binaryThrow(statement.position, result, statement.thrownType);
 		return result;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/IfStatement.java

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 				: new IfStatement(position, tCondition, tOnThen, tOnElse);
 	}
 	
-	private static StoredType getThrownType(Expression condition, Statement onThen, Statement onElse) {
-		StoredType result = Expression.binaryThrow(onThen.position, condition.thrownType, onThen.thrownType);
+	private static TypeID getThrownType(Expression condition, Statement onThen, Statement onElse) {
+		TypeID result = Expression.binaryThrow(onThen.position, condition.thrownType, onThen.thrownType);
 		if (onElse != null)
 			result = Expression.binaryThrow(onElse.position, result, onElse.thrownType);
 		return result;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/Statement.java

 import org.openzen.zenscript.codemodel.annotations.StatementAnnotation;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  */
 public abstract class Statement extends Taggable {
 	public final CodePosition position;
-	public final StoredType thrownType;
+	public final TypeID thrownType;
 	public StatementAnnotation[] annotations = StatementAnnotation.NONE;
 	
-	public Statement(CodePosition position, StoredType thrownType) {
+	public Statement(CodePosition position, TypeID thrownType) {
 		this.position = position;
 		this.thrownType = thrownType;
 	}
 	
-	public StoredType getReturnType() {
+	public TypeID getReturnType() {
 		return null;
 	}
 	
-	public Statement withReturnType(TypeScope scope, StoredType returnType) {
+	public Statement withReturnType(TypeScope scope, TypeID returnType) {
 		return this;
 	}
 	
 	
 	public abstract Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified);
 	
-	public static List<Statement> withReturnType(TypeScope scope, List<Statement> statements, StoredType returnType) {
+	public static List<Statement> withReturnType(TypeScope scope, List<Statement> statements, TypeID returnType) {
 		return statements.stream()
 				.map(statement -> statement.withReturnType(scope, returnType))
 				.collect(Collectors.toList());

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/VarStatement.java

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  */
 public class VarStatement extends Statement {
 	public final String name;
-	public final StoredType type;
+	public final TypeID type;
 	public final Expression initializer;
 	public final VariableID variable;
 	public final boolean isFinal;
 	
-	public VarStatement(CodePosition position, VariableID variable, String name, StoredType type, Expression initializer, boolean isFinal) {
+	public VarStatement(CodePosition position, VariableID variable, String name, TypeID type, Expression initializer, boolean isFinal) {
 		super(position, initializer == null ? null : initializer.thrownType);
 		
 		this.name = name;

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

 import org.openzen.zenscript.codemodel.expression.ArrayExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ArrayTypeID implements TypeID {
-	public static final ArrayTypeID INT = new ArrayTypeID(BasicTypeID.INT.stored, 1);
-	public static final ArrayTypeID CHAR = new ArrayTypeID(BasicTypeID.CHAR.stored, 1);
+	public static final ArrayTypeID INT = new ArrayTypeID(BasicTypeID.INT, 1);
+	public static final ArrayTypeID CHAR = new ArrayTypeID(BasicTypeID.CHAR, 1);
 	
-	public final StoredType elementType;
+	public final TypeID elementType;
 	public final int dimension;
 	private final ArrayTypeID normalized;
 
-	private ArrayTypeID(StoredType elementType, int dimension) {
+	private ArrayTypeID(TypeID elementType, int dimension) {
 		this.elementType = elementType;
 		this.dimension = dimension;
 		this.normalized = this;
 	}
 	
-	public ArrayTypeID(GlobalTypeRegistry registry, StoredType elementType, int dimension) {
+	public ArrayTypeID(GlobalTypeRegistry registry, TypeID elementType, int dimension) {
 		this.elementType = elementType;
 		this.dimension = dimension;
 		this.normalized = elementType.getNormalized() == elementType ? this : registry.getArray(elementType.getNormalized(), dimension);
 	
 	@Override
 	public Expression getDefaultValue() {
-		return new ArrayExpression(CodePosition.UNKNOWN, Expression.NONE, this.stored());
+		return new ArrayExpression(CodePosition.UNKNOWN, Expression.NONE, this);
 	}
 	
 	@Override
 	
 	@Override
 	public boolean isDestructible() {
-		return elementType.type.isDestructible();
+		return elementType.isDestructible();
 	}
 	
 	@Override
 	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
-		return elementType.type.isDestructible(scanning);
+		return elementType.isDestructible(scanning);
 	}
 	
 	@Override
-	public StoredType instance(GenericMapper mapper, StorageTag storage) {
-		return mapper.registry.getArray(elementType.instance(mapper), dimension).stored(storage);
+	public TypeID instance(GenericMapper mapper) {
+		return mapper.registry.getArray(elementType.instance(mapper), dimension);
 	}
 
 	@Override
 
 	@Override
 	public void extractTypeParameters(List<TypeParameter> typeParameters) {
-		elementType.type.extractTypeParameters(typeParameters);
+		elementType.extractTypeParameters(typeParameters);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class AssocTypeID implements TypeID {
-	public final StoredType keyType;
-	public final StoredType valueType;
+	public final TypeID keyType;
+	public final TypeID valueType;
 	private final AssocTypeID normalized;
 	
-	public AssocTypeID(GlobalTypeRegistry typeRegistry, StoredType keyType, StoredType valueType) {
+	public AssocTypeID(GlobalTypeRegistry typeRegistry, TypeID keyType, TypeID valueType) {
 		this.keyType = keyType;
 		this.valueType = valueType;
 		
 	}
 	
 	@Override
-	public StoredType instance(GenericMapper mapper, StorageTag storage) {
+	public TypeID instance(GenericMapper mapper) {
 		return mapper.registry.getAssociative(
 				keyType.instance(mapper),
-				valueType.instance(mapper)).stored(storage);
+				valueType.instance(mapper));
 	}
 	
 	@Override
 
 	@Override
 	public void extractTypeParameters(List<TypeParameter> typeParameters) {
-		keyType.type.extractTypeParameters(typeParameters);
-		valueType.type.extractTypeParameters(typeParameters);
+		keyType.extractTypeParameters(typeParameters);
+		valueType.extractTypeParameters(typeParameters);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.expression.ConstantBoolExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantDoubleExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantFloatExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	FLOAT("float"),
 	DOUBLE("double"),
 	CHAR("char"),
+	STRING("string"),
 	
 	UNDETERMINED("undetermined");
 	
-	public static final List<StoredType> HINT_BOOL = Collections.singletonList(BOOL.stored);
+	public static final List<TypeID> HINT_BOOL = Collections.singletonList(BOOL);
 	
 	public final String name;
-	public final StoredType stored;
 	
 	private Expression defaultValue = null;
 	
 	BasicTypeID(String name) {
 		this.name = name;
-		stored = new StoredType(this, null);
-		this.defaultValue = defaultValue;
 	}
 	
 	@Override
 	public BasicTypeID getNormalized() {
 		return this;
 	}
-	
+
 	@Override
-	public StoredType instance(GenericMapper mapper, StorageTag storage) {
-		return stored(storage);
+	public TypeID instance(GenericMapper mapper) {
+		return this;
 	}
-	
+
 	@Override
 	public String toString() {
 		return name;

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

  */
 public class DefinitionTypeID implements TypeID {
 	public final HighLevelDefinition definition;
-	public final StoredType[] typeArguments;
+	public final TypeID[] typeArguments;
 	public final DefinitionTypeID outer;
 	private TypeID normalized;
 	
 	public TypeID superType;
 	
-	public DefinitionTypeID(GlobalTypeRegistry typeRegistry, HighLevelDefinition definition, StoredType[] typeArguments) {
+	public DefinitionTypeID(GlobalTypeRegistry typeRegistry, HighLevelDefinition definition, TypeID[] typeArguments) {
 		this(typeRegistry, definition, typeArguments, null);
 	}
 	
 	// For inner classes of generic outer classes
-	public DefinitionTypeID(GlobalTypeRegistry typeRegistry, HighLevelDefinition definition, StoredType[] typeArguments, DefinitionTypeID outer) {
+	public DefinitionTypeID(GlobalTypeRegistry typeRegistry, HighLevelDefinition definition, TypeID[] typeArguments, DefinitionTypeID outer) {
 		if (typeArguments == null)
 			throw new NullPointerException("typeParameters cannot be null");
 		if (typeArguments.length != definition.getNumberOfGenericParameters())
 		if (definition instanceof AliasDefinition)
 			return true;
 		
-		for (StoredType typeArgument : typeArguments)
+		for (TypeID typeArgument : typeArguments)
 			if (!typeArgument.getNormalized().equals(typeArgument))
 				return true;
 		if (outer != null && !outer.getNormalized().equals(outer))
 			if (alias.type == null)
 				throw new IllegalStateException("Alias type not yet initialized!");
 			
-			Map<TypeParameter, StoredType> typeMapping = new HashMap<>();
+			Map<TypeParameter, TypeID> typeMapping = new HashMap<>();
 			for (int i = 0; i < definition.typeParameters.length; i++)
 				typeMapping.put(definition.typeParameters[i], typeArguments[i].getNormalized());
 			GenericMapper mapper = new GenericMapper(definition.position, typeRegistry, typeMapping);
-			TypeID result = alias.type.instance(mapper, null).type.getNormalized();
-			return result;
+			return alias.type.instance(mapper).getNormalized();
 		}
-		
-		StoredType[] normalizedTypeParameters = new StoredType[typeArguments.length];
+
+		TypeID[] normalizedTypeParameters = new TypeID[typeArguments.length];
 		for (int i = 0; i < normalizedTypeParameters.length; i++)
 			normalizedTypeParameters[i] = typeArguments[i].getNormalized();
 		
 		return typeArguments.length > 0;
 	}
 	
-	public Map<TypeParameter, StoredType> getTypeParameterMapping() {
-		Map<TypeParameter, StoredType> mapping = new HashMap<>();
+	public Map<TypeParameter, TypeID> getTypeParameterMapping() {
+		Map<TypeParameter, TypeID> mapping = new HashMap<>();
 		DefinitionTypeID current = this;
 		do {
 			if (current.typeArguments != null) {
 	
 	public DefinitionTypeID(HighLevelDefinition definition) {
 		this.definition = definition;
-		this.typeArguments = StoredType.NONE;
+		this.typeArguments = TypeID.NONE;
 		this.superType = definition.getSuperType();
 		this.outer = null;
 	}
 	}
 	
 	@Override
-	public StoredType instance(GenericMapper mapper, StorageTag storage) {
+	public TypeID instance(GenericMapper mapper) {
 		if (!hasTypeParameters() && outer == null)
-			return stored(storage);
+			return this;
 		if (mapper == null || mapper.getMapping().isEmpty())
-			return stored(storage);
+			return this;
 		if (mapper.registry == null)
 			throw new NullPointerException();
-		
-		StoredType[] instancedArguments = StoredType.NONE;
+
+		TypeID[] instancedArguments = TypeID.NONE;
 		if (hasTypeParameters()) {
-			instancedArguments = new StoredType[typeArguments.length];
+			instancedArguments = new TypeID[typeArguments.length];
 			for (int i = 0; i < typeArguments.length; i++)
 				instancedArguments[i] = typeArguments[i].instance(mapper);
 		}
 		
-		DefinitionTypeID instancedOuter = outer == null ? null : (DefinitionTypeID)outer.instance(mapper, storage).type;
-		return mapper.registry.getForDefinition(definition, instancedArguments, instancedOuter).stored(storage);
+		DefinitionTypeID instancedOuter = outer == null ? null : (DefinitionTypeID)outer.instance(mapper);
+		return mapper.registry.getForDefinition(definition, instancedArguments, instancedOuter);
 	}
 	
 	@Override
 	public TypeID getSuperType(GlobalTypeRegistry registry) {
-		return definition.getSuperType() == null ? null : definition.getSuperType().instance(new GenericMapper(definition.position, registry, getTypeParameterMapping()), null).type;
+		return definition.getSuperType() == null ? null : definition.getSuperType().instance(new GenericMapper(definition.position, registry, getTypeParameterMapping()));
 	}
 	
 	@Override
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
 		if (hasTypeParameters()) {
-			for (StoredType typeArgument : typeArguments)
-				if (typeArgument.type.hasInferenceBlockingTypeParameters(parameters))
+			for (TypeID typeArgument : typeArguments)
+				if (typeArgument.hasInferenceBlockingTypeParameters(parameters))
 					return true;
 		}
 		
 
 	@Override
 	public void extractTypeParameters(List<TypeParameter> typeParameters) {
-		for (StoredType type : this.typeArguments)
-			type.type.extractTypeParameters(typeParameters);
+		for (TypeID type : this.typeArguments)
+			type.extractTypeParameters(typeParameters);
 	}
 
 	public DefinitionTypeID getInnerType(GenericName name, GlobalTypeRegistry registry) {

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class GenericMapTypeID implements TypeID {
-	public final StoredType value;
+	public final TypeID value;
 	public final TypeParameter key;
 	private final GenericMapTypeID normalized;
 	
-	public GenericMapTypeID(GlobalTypeRegistry registry, StoredType value, TypeParameter key) {
+	public GenericMapTypeID(GlobalTypeRegistry registry, TypeID value, TypeParameter key) {
 		this.value = value;
 		this.key = key;
 		
 	}
 	
 	@Override
-	public StoredType instance(GenericMapper mapper, StorageTag storage) {
-		return mapper.registry.getGenericMap(value.instance(mapper), key).stored(storage);
+	public TypeID instance(GenericMapper mapper) {
+		return mapper.registry.getGenericMap(value.instance(mapper), key);
 	}
 
 	@Override
 
 	@Override
 	public void extractTypeParameters(List<TypeParameter> typeParameters) {
-		value.type.extractTypeParameters(typeParameters);
+		value.extractTypeParameters(typeParameters);
 		typeParameters.remove(key);
 	}
 	

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 		this.parameter = parameter;
 	}
 	
-	public boolean matches(LocalMemberCache cache, StoredType type) {
-		if (type.getSpecifiedStorage() != null && parameter.storage != null && !type.getActualStorage().equals(parameter.storage))
-			return false;
-		
-		return parameter.matches(cache, type.type);
+	public boolean matches(LocalMemberCache cache, TypeID type) {
+		return parameter.matches(cache, type);
 	}
 	
 	@Override
 	}
 	
 	@Override
-	public StoredType instance(GenericMapper mapper, StorageTag storage) {
-		StoredType mapped = mapper.map(this);
-		return new StoredType(mapped.type, StorageTag.union(mapper.position, mapped.getSpecifiedStorage(), storage));
+	public TypeID instance(GenericMapper mapper) {
+		return mapper.map(this);
 	}
 	
 	@Override

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

 		rangeTypes.put(RangeTypeID.USIZE, RangeTypeID.USIZE);
 	}
 	
-	public ArrayTypeID getArray(StoredType baseType, int dimension) {
+	public ArrayTypeID getArray(TypeID baseType, int dimension) {
 		ArrayTypeID id = new ArrayTypeID(this, baseType, dimension);
 		return internalize(arrayTypes, id);
 	}
 	
-	public AssocTypeID getAssociative(StoredType keyType, StoredType valueType) {
+	public AssocTypeID getAssociative(TypeID keyType, TypeID valueType) {
 		AssocTypeID id = new AssocTypeID(this, keyType, valueType);
 		return internalize(assocTypes, id);
 	}
 	
-	public GenericMapTypeID getGenericMap(StoredType valueType, TypeParameter key) {
+	public GenericMapTypeID getGenericMap(TypeID valueType, TypeParameter key) {
 		GenericMapTypeID id = new GenericMapTypeID(this, valueType, key);
 		return internalize(genericMapTypes, id);
 	}
 	
-	public IteratorTypeID getIterator(StoredType[] loopTypes) {
+	public IteratorTypeID getIterator(TypeID[] loopTypes) {
 		IteratorTypeID id = new IteratorTypeID(this, loopTypes);
 		return internalize(iteratorTypes, id);
 	}
 		return internalize(functionTypes, id);
 	}
 	
-	public RangeTypeID getRange(StoredType type) {
+	public RangeTypeID getRange(TypeID type) {
 		RangeTypeID id = new RangeTypeID(this, type);
 		return internalize(rangeTypes, id);
 	}
 	}
 	
 	public DefinitionTypeID getForMyDefinition(HighLevelDefinition definition) {
-		StoredType[] typeArguments = StoredType.NONE;
+		TypeID[] typeArguments = TypeID.NONE;
 		if (definition.getNumberOfGenericParameters() > 0) {
-			typeArguments = new StoredType[definition.getNumberOfGenericParameters()];
+			typeArguments = new TypeID[definition.getNumberOfGenericParameters()];
 			for (int i = 0; i < definition.typeParameters.length; i++)
-				typeArguments[i] = new StoredType(getGeneric(definition.typeParameters[i]), definition.typeParameters[i].storage);
+				typeArguments[i] = getGeneric(definition.typeParameters[i]);
 		}
 		DefinitionTypeID outer = null;
 		if (definition.outerDefinition != null)
 		return getForDefinition(definition, typeArguments, outer);
 	}
 	
-	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, StoredType... typeArguments) {
+	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, TypeID... typeArguments) {
 		return this.getForDefinition(definition, typeArguments, null);
 	}
 	
-	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, StoredType[] typeArguments, DefinitionTypeID outer) {
+	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, TypeID[] typeArguments, DefinitionTypeID outer) {
 		DefinitionTypeID id = new DefinitionTypeID(this, definition, typeArguments, definition.isStatic() ? null : outer);
 		return internalize(definitionTypes, id);
 	}

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class IteratorTypeID implements TypeID {
-	public final StoredType[] iteratorTypes;
+	public final TypeID[] iteratorTypes;
 	private final IteratorTypeID normalized;
 	
-	public IteratorTypeID(GlobalTypeRegistry registry, StoredType[] iteratorTypes) {
+	public IteratorTypeID(GlobalTypeRegistry registry, TypeID[] iteratorTypes) {
 		this.iteratorTypes = iteratorTypes;
 		
 		normalized = isDenormalized() ? normalize(registry) : this;
 	}
 	
 	private boolean isDenormalized() {
-		for (StoredType type : iteratorTypes)
+		for (TypeID type : iteratorTypes)
 			if (type.getNormalized() != type)
 				return true;
 		
 	}
 	
 	private IteratorTypeID normalize(GlobalTypeRegistry registry) {
-		StoredType[] normalizedTypes = new StoredType[iteratorTypes.length];
+		TypeID[] normalizedTypes = new TypeID[iteratorTypes.length];
 		for (int i = 0; i < normalizedTypes.length; i++)
 			normalizedTypes[i] = iteratorTypes[i].getNormalized();
 		return registry.getIterator(normalizedTypes);
 	}
 	
 	@Override
-	public StoredType instance(GenericMapper mapper, StorageTag storage) {
-		StoredType[] instanced = mapper.map(iteratorTypes);
-		return mapper.registry.getIterator(instanced).stored(storage);
+	public TypeID instance(GenericMapper mapper) {
+		TypeID[] instanced = mapper.map(iteratorTypes);
+		return mapper.registry.getIterator(instanced);
 	}
 
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
-		for (StoredType type : iteratorTypes)
+		for (TypeID type : iteratorTypes)
 			if (type.hasInferenceBlockingTypeParameters(parameters))
 				return true;
 		
 
 	@Override
 	public void extractTypeParameters(List<TypeParameter> typeParameters) {
-		for (StoredType type : iteratorTypes)
-			type.type.extractTypeParameters(typeParameters);
+		for (TypeID type : iteratorTypes)
+			type.extractTypeParameters(typeParameters);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	}
 	
 	@Override
-	public StoredType instance(GenericMapper mapper, StorageTag storage) {
-		StoredType base = baseType.instance(mapper, storage);
-		return mapper.registry.getOptional(base.type).stored(StorageTag.union(mapper.position, base.getSpecifiedStorage(), storage));
+	public TypeID instance(GenericMapper mapper) {
+		TypeID base = baseType.instance(mapper);
+		return mapper.registry.getOptional(base);
 	}
 	
 	@Override
 	public String toString() {
 		return baseType.toString() + "?";
 	}
-	
-	@Override
-	public String toString(StorageTag storage) {
-		return baseType.toString(storage) + '?';
-	}
 }

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class RangeTypeID implements TypeID {
-	public static final RangeTypeID INT = new RangeTypeID(null, BasicTypeID.INT.stored);
-	public static final RangeTypeID USIZE = new RangeTypeID(null, BasicTypeID.USIZE.stored);
+	public static final RangeTypeID INT = new RangeTypeID(null, BasicTypeID.INT);
+	public static final RangeTypeID USIZE = new RangeTypeID(null, BasicTypeID.USIZE);
 	
-	public final StoredType baseType;
+	public final TypeID baseType;
 	private final RangeTypeID normalized;
-	public final StoredType stored;
-	
-	public RangeTypeID(GlobalTypeRegistry registry, StoredType baseType) {
+
+	public RangeTypeID(GlobalTypeRegistry registry, TypeID baseType) {
 		this.baseType = baseType;
 		
 		if (baseType.getNormalized().equals(baseType)) {
 		} else {
 			normalized = registry.getRange(baseType.getNormalized());
 		}
-		
-		stored = new StoredType(this, baseType.getSpecifiedStorage());
 	}
 	
 	@Override
 	}
 	
 	@Override
-	public StoredType instance(GenericMapper mapper, StorageTag storage) {
-		return mapper.registry.getRange(baseType.instance(mapper)).stored(storage);
+	public TypeID instance(GenericMapper mapper) {
+		return mapper.registry.getRange(baseType.instance(mapper));
 	}
 	
 	@Override
 	
 	@Override
 	public boolean isValueType() {
-		return baseType.type.isValueType();
+		return baseType.isValueType();
 	}
 	
 	@Override
 
 	@Override
 	public void extractTypeParameters(List<TypeParameter> typeParameters) {
-		baseType.type.extractTypeParameters(typeParameters);
+		baseType.extractTypeParameters(typeParameters);
 	}
 
 	@Override

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

  * @author Hoofdgebruiker
  */
 public class StoredType {
-	public static Map<TypeParameter, StoredType> getMapping(TypeParameter[] parameters, StoredType[] arguments) {
-		Map<TypeParameter, StoredType> typeArguments = new HashMap<>();
+	public static Map<TypeParameter, TypeID> getMapping(TypeParameter[] parameters, TypeID[] arguments) {
+		Map<TypeParameter, TypeID> typeArguments = new HashMap<>();
 		for (int i = 0; i < parameters.length; i++)
 			typeArguments.put(parameters[i], arguments[i]);
 		return typeArguments;
 	}
 	
-	public static Map<TypeParameter, StoredType> getSelfMapping(GlobalTypeRegistry registry, TypeParameter[] parameters) {
-		Map<TypeParameter, StoredType> typeArguments = new HashMap<>();
+	public static Map<TypeParameter, TypeID> getSelfMapping(GlobalTypeRegistry registry, TypeParameter[] parameters) {
+		Map<TypeParameter, TypeID> typeArguments = new HashMap<>();
 		for (TypeParameter parameter : parameters)
-			typeArguments.put(parameter, registry.getGeneric(parameter).stored(parameter.storage));
+			typeArguments.put(parameter, registry.getGeneric(parameter));
 		return typeArguments;
 	}
 	
 		return type.getNormalized() == type ? this : new StoredType(type.getNormalized(), storage);
 	}
 	
-	public StoredType getSuperType(GlobalTypeRegistry registry) {
+	public TypeID getSuperType(GlobalTypeRegistry registry) {
 		TypeID superType = type.getSuperType(registry);
-		return superType == null ? null : superType.stored(storage);
+		return superType == null ? null : superType;
 	}
 	
-	public StoredType instance(GenericMapper mapper) {
-		return type.instance(mapper, storage);
+	public TypeID instance(GenericMapper mapper) {
+		return type.instance(mapper);
 	}
 	
 	public boolean isDestructible() {
 	
 	// Infers type parameters for this type so it matches with targetType
 	// returns false if that isn't possible
-	public Map<TypeParameter, StoredType> inferTypeParameters(LocalMemberCache cache, StoredType targetType) {
+	public Map<TypeParameter, TypeID> inferTypeParameters(LocalMemberCache cache, TypeID targetType) {
 		return type.inferTypeParameters(cache, targetType);
 	}
 	
 		if (obj == null || getClass() != obj.getClass())
 			return false;
 		
-		final StoredType other = (StoredType) obj;
-		return Objects.equals(this.type, other.type)
-				&& Objects.equals(this.storage, other.storage);
+		final TypeID other = (TypeID) obj;
+		return Objects.equals(this.type, other);
 	}
 	
 	@Override

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

 import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
-import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
-import org.openzen.zenscript.codemodel.type.storage.SharedStorageTag;
-import org.openzen.zenscript.codemodel.type.storage.StaticStorageTag;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
-import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 
 /**
  *
 public class StringTypeID implements TypeID {
 	public static final StringTypeID INSTANCE = new StringTypeID();
 	
-	public static final StoredType AUTO = new StoredType(INSTANCE, AutoStorageTag.INSTANCE);
-	public static final StoredType STATIC = new StoredType(INSTANCE, StaticStorageTag.INSTANCE);
-	public static final StoredType UNIQUE = new StoredType(INSTANCE, UniqueStorageTag.INSTANCE);
-	public static final StoredType BORROW = new StoredType(INSTANCE, BorrowStorageTag.INVOCATION);
-	public static final StoredType SHARED = new StoredType(INSTANCE, SharedStorageTag.INSTANCE);
-	
 	private StringTypeID() {}
 	
 	@Override
 	}
 
 	@Override
-	public StoredType instance(GenericMapper mapper, StorageTag storage) {
-		return new StoredType(this, storage);
+	public TypeID instance(GenericMapper mapper) {
+		return this;
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.type;
 
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
-import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public interface TypeID {
+	static Map<TypeParameter, TypeID> getMapping(TypeParameter[] parameters, TypeID[] arguments) {
+		Map<TypeParameter, TypeID> typeArguments = new HashMap<>();
+		for (int i = 0; i < parameters.length; i++)
+			typeArguments.put(parameters[i], arguments[i]);
+		return typeArguments;
+	}
+
+	static Map<TypeParameter, TypeID> getSelfMapping(GlobalTypeRegistry registry, TypeParameter[] parameters) {
+		Map<TypeParameter, TypeID> typeArguments = new HashMap<>();
+		for (TypeParameter parameter : parameters)
+			typeArguments.put(parameter, registry.getGeneric(parameter));
+		return typeArguments;
+	}
+
 	TypeID[] NONE = new TypeID[0];
 	
 	default TypeID getSuperType(GlobalTypeRegistry registry) {
 		return null;
 	}
 	
-	StoredType instance(GenericMapper mapper, StorageTag storage);
+	TypeID instance(GenericMapper mapper);
 	
 	TypeID getNormalized();
 	
 	
 	// Infers type parameters for this type so it matches with targetType
 	// returns false if that isn't possible
-	default Map<TypeParameter, StoredType> inferTypeParameters(LocalMemberCache cache, StoredType targetType) {
-		return TypeMatcher.match(cache, stored(), targetType);
+	default Map<TypeParameter, TypeID> inferTypeParameters(LocalMemberCache cache, TypeID targetType) {
+		return TypeMatcher.match(cache, this, targetType);
 	}
 	
 	void extractTypeParameters(List<TypeParameter> typeParameters);
 	
 	<C, R, E extends Exception> R accept(C context, TypeVisitorWithContext<C, R, E> visitor) throws E;
 	
-	default StoredType stored(StorageTag storage) {
-		return new StoredType(this, storage);
-	}
-	
-	default StoredType stored() {
-		return new StoredType(this, null);
-	}
-	
 	default boolean isOptional() {
 		return false;
 	}
 	default boolean isDefinition(HighLevelDefinition definition) {
 		return false;
 	}
-	
-	default String toString(StorageTag storage) {
-		if (storage == ValueStorageTag.INSTANCE)
-			return toString();
-		
-		return toString() + "`" + storage.toString();
-	}
 }

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

  * @author Hoofdgebruiker
  */
 public class TypeMatcher implements TypeVisitorWithContext<TypeMatcher.Matching, Boolean, RuntimeException> {
-	public static Map<TypeParameter, StoredType> match(LocalMemberCache cache, StoredType type, StoredType pattern) {
+	public static Map<TypeParameter, TypeID> match(LocalMemberCache cache, TypeID type, TypeID pattern) {
 		Matching matching = new Matching(cache, type);
-		if (pattern.type.accept(matching, INSTANCE))
+		if (pattern.accept(matching, INSTANCE))
 			return matching.mapping;
 		
 		return null;
 	
 	@Override
 	public Boolean visitBasic(Matching context, BasicTypeID basic) {
-		return context.type.isBasic(basic);
-	}
-
-	@Override
-	public Boolean visitString(Matching context, StringTypeID string) {
-		return context.type.type == StringTypeID.INSTANCE;
+		return context.type == basic;
 	}
 
 	@Override
 	public Boolean visitArray(Matching context, ArrayTypeID array) {
-		if (context.type.type instanceof ArrayTypeID) {
-			ArrayTypeID arrayType = (ArrayTypeID) context.type.type;
+		if (context.type instanceof ArrayTypeID) {
+			ArrayTypeID arrayType = (ArrayTypeID) context.type;
 			if (arrayType.dimension != array.dimension)
 				return false;
 
 
 	@Override
 	public Boolean visitAssoc(Matching context, AssocTypeID assoc) {
-		if (context.type.type instanceof AssocTypeID) {
-			AssocTypeID assocType = (AssocTypeID) context.type.type;
+		if (context.type instanceof AssocTypeID) {
+			AssocTypeID assocType = (AssocTypeID) context.type;
 			return match(context, assocType.keyType, assoc.keyType)
 					&& match(context, assocType.valueType, assoc.valueType);
 		} else {
 
 	@Override
 	public Boolean visitIterator(Matching context, IteratorTypeID iterator) {
-		if (context.type.type instanceof IteratorTypeID) {
-			IteratorTypeID iteratorType = (IteratorTypeID) context.type.type;
+		if (context.type instanceof IteratorTypeID) {
+			IteratorTypeID iteratorType = (IteratorTypeID) context.type;
 			if (iteratorType.iteratorTypes.length != iterator.iteratorTypes.length)
 				return false;
 
 
 	@Override
 	public Boolean visitFunction(Matching context, FunctionTypeID function) {
-		if (context.type.type instanceof FunctionTypeID) {
-			FunctionTypeID functionType = (FunctionTypeID) context.type.type;
+		if (context.type instanceof FunctionTypeID) {
+			FunctionTypeID functionType = (FunctionTypeID) context.type;
 			if (functionType.header.parameters.length != function.header.parameters.length)
 				return false;
 
 
 	@Override
 	public Boolean visitDefinition(Matching context, DefinitionTypeID definition) {
-		if (context.type.type instanceof DefinitionTypeID) {
-			DefinitionTypeID definitionType = (DefinitionTypeID) context.type.type;
+		if (context.type instanceof DefinitionTypeID) {
+			DefinitionTypeID definitionType = (DefinitionTypeID) context.type;
 			if (definitionType.definition != definition.definition)
 				return false;
 
 	@Override
 	public Boolean visitGeneric(Matching context, GenericTypeID generic) {
 		if (context.mapping.containsKey(generic.parameter)) {
-			StoredType argument = context.mapping.get(generic.parameter);
-			return argument.type == context.type && (argument.getSpecifiedStorage() == null || argument.getSpecifiedStorage() == context.type.getSpecifiedStorage());
-		} else if (context.type.type == generic || generic.matches(context.cache, context.type)) {
+			TypeID argument = context.mapping.get(generic.parameter);
+			return argument == context.type;
+		} else if (context.type == generic || generic.matches(context.cache, context.type)) {
 			context.mapping.put(generic.parameter, context.type);
 			return true;
 		} else {
 
 	@Override
 	public Boolean visitRange(Matching context, RangeTypeID range) {
-		if (context.type.type instanceof RangeTypeID) {
-			RangeTypeID rangeType = (RangeTypeID) context.type.type;
+		if (context.type instanceof RangeTypeID) {
+			RangeTypeID rangeType = (RangeTypeID) context.type;
 			return match(context, rangeType.baseType, range.baseType);
 		} else {
 			return false;
 
 	@Override
 	public Boolean visitOptional(Matching context, OptionalTypeID type) {
-		if (context.type.type instanceof OptionalTypeID) {
-			OptionalTypeID modified = (OptionalTypeID) context.type.type;
-			return match(context, modified.baseType.stored(), type.baseType.stored());
+		if (context.type instanceof OptionalTypeID) {
+			OptionalTypeID modified = (OptionalTypeID) context.type;
+			return match(context, modified.baseType, type.baseType);
 		} else {
 			return false;
 		}
 	}
 
-	private boolean match(Matching context, StoredType type, StoredType pattern) {
-		if (pattern.getSpecifiedStorage() != null && !pattern.getSpecifiedStorage().equals(type.getSpecifiedStorage()))
-			return false;
-		
-		return pattern.type.accept(context.withType(type), this);
+	private boolean match(Matching context, TypeID type, TypeID pattern) {
+		return pattern.accept(context.withType(type), this);
 	}
 
 	@Override
 	public Boolean visitGenericMap(Matching context, GenericMapTypeID map) {
-		return map == context.type.type; // TODO: improve this
+		return map == context.type; // TODO: improve this
 	}
 		
 	public static final class Matching {
 		public final LocalMemberCache cache;
-		public final StoredType type;
-		public final Map<TypeParameter, StoredType> mapping;
+		public final TypeID type;
+		public final Map<TypeParameter, TypeID> mapping;
 		
-		public Matching(LocalMemberCache cache, StoredType type) {
+		public Matching(LocalMemberCache cache, TypeID type) {
 			this.cache = cache;
 			this.type = type;
 			mapping = new HashMap<>();
 		}
 		
-		private Matching(LocalMemberCache cache, StoredType type, Map<TypeParameter, StoredType> mapping) {
+		private Matching(LocalMemberCache cache, TypeID type, Map<TypeParameter, TypeID> mapping) {
 			this.cache = cache;
 			this.type = type;
 			this.mapping = mapping;
 		}
 		
-		public Matching withType(StoredType type) {
+		public Matching withType(TypeID type) {
 			return new Matching(cache, type, mapping);
 		}
 	}

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

 public interface TypeVisitor<T> {
 	T visitBasic(BasicTypeID basic);
 	
-	T visitString(StringTypeID string);
-	
 	T visitArray(ArrayTypeID array);
 	
 	T visitAssoc(AssocTypeID assoc);

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

  */
 public interface TypeVisitorWithContext<C, R, E extends Exception> {
 	R visitBasic(C context, BasicTypeID basic) throws E;
-	
-	R visitString(C context, StringTypeID string) throws E;
-	
+
 	R visitArray(C context, ArrayTypeID array) throws E;
 	
 	R visitAssoc(C context, AssocTypeID assoc) throws E;

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

 import java.util.Map;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  */
 public class LocalMemberCache {
 	private final GlobalTypeRegistry registry;
-	private final Map<StoredType, TypeMembers> types = new HashMap<>();
+	private final Map<TypeID, TypeMembers> types = new HashMap<>();
 	private final List<ExpansionDefinition> expansions = new ArrayList<>();
 	
 	public LocalMemberCache(
 		return registry;
 	}
 	
-	public TypeMembers get(StoredType type) {
+	public TypeMembers get(TypeID type) {
 		type = type.getNormalized();
 		if (types.containsKey(type)) {
 			return types.get(type);
 	}
 	
 	private void registerMembers(TypeMembers members) {
-		members.type.type.accept(null, new TypeMemberBuilder(registry, members, this));
+		members.type.accept(null, new TypeMemberBuilder(registry, members, this));
 	}
 	
 	public List<ExpansionDefinition> getExpansions() {

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

 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
 		return false;
 	}
 	
-	public FunctionalMemberRef getStaticMethod(int arguments, StoredType returnType) {
+	public FunctionalMemberRef getStaticMethod(int arguments, TypeID returnType) {
 		for (TypeMember<FunctionalMemberRef> method : methods) {
 			if (method.member.isStatic() && method.member.getHeader().accepts(arguments) && method.member.getHeader().getReturnType().equals(returnType))
 				return method.member;
 		}
 	}
 	
-	public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> typeHints, int arguments) {
-		List<StoredType>[] result = (List<StoredType>[])(new List[arguments]);
+	public List<TypeID>[] predictCallTypes(CodePosition position, TypeScope scope, List<TypeID> typeHints, int arguments) {
+		List<TypeID>[] result = (List<TypeID>[])(new List[arguments]);
 		for (int i = 0; i < result.length; i++)
 			result[i] = new ArrayList<>();
 		
 			if (header.parameters.length != arguments)
 				continue;
 			
-			if (header.typeParameters != null) {
-				for (StoredType resultHint : typeHints) {
-					Map<TypeParameter, StoredType> mapping = header.getReturnType().inferTypeParameters(scope.getMemberCache(), resultHint);
-					if (mapping != null) {
-						header = header.withGenericArguments(scope.getLocalTypeParameters().getInner(position, scope.getTypeRegistry(), mapping));
-						break;
-					}
+			for (TypeID resultHint : typeHints) {
+				Map<TypeParameter, TypeID> mapping = header.getReturnType().inferTypeParameters(scope.getMemberCache(), resultHint);
+				if (mapping != null) {
+					header = header.withGenericArguments(scope.getLocalTypeParameters().getInner(position, scope.getTypeRegistry(), mapping));
+					break;
 				}
 			}
-			
+
 			for (int i = 0; i < header.parameters.length; i++) {
 				if (!result[i].contains(header.parameters[i].type))
 					result[i].add(header.parameters[i].type);

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

 import org.openzen.zenscript.codemodel.expression.InterfaceCastExpression;
 import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
-import org.openzen.zenscript.codemodel.expression.StorageCastExpression;
 import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
  */
 public final class TypeMembers {
 	private final LocalMemberCache cache;
-	public final StoredType type;
+	public final TypeID type;
 	
 	private final List<TypeMember<CasterMemberRef>> casters = new ArrayList<>();
 	private final List<TypeMember<ImplementationMemberRef>> implementations = new ArrayList<>();
 	private final Map<String, InnerDefinition> innerTypes = new HashMap<>();
 	private final Map<OperatorType, TypeMemberGroup> operators = new HashMap<>();
 	
-	public TypeMembers(LocalMemberCache cache, StoredType type) {
+	public TypeMembers(LocalMemberCache cache, TypeID type) {
 		if (type == null)
 			throw new NullPointerException("Type must not be null!");
-		if (type.type == BasicTypeID.UNDETERMINED)
+		if (type == BasicTypeID.UNDETERMINED)
 			throw new IllegalArgumentException("Cannot retrieve members of undetermined type");
 		
 		this.cache = cache;
 	
 	public boolean extendsOrImplements(TypeID other) {
 		other = other.getNormalized();
-		TypeID superType = type.type.getSuperType(cache.getRegistry());
+		TypeID superType = type.getSuperType(cache.getRegistry());
 		if (superType != null) {
 			if (superType == other)
 				return true;
-			if (cache.get(superType.stored(type.getActualStorage())).extendsOrImplements(other))
+			if (cache.get(superType).extendsOrImplements(other))
 				return true;
 		}
 		
 		for (TypeMember<ImplementationMemberRef> implementation : implementations) {
-			if (implementation.member.implementsType.type == other)
+			if (implementation.member.implementsType == other)
 				return true;
 			if (cache.get(implementation.member.implementsType).extendsOrImplements(other))
 				return true;
 	
 	public boolean extendsType(TypeID other) {
 		other = other.getNormalized();
-		TypeID superType = type.type.getSuperType(cache.getRegistry());
+		TypeID superType = type.getSuperType(cache.getRegistry());
 		if (superType != null) {
 			if (superType == other)
 				return true;
-			if (cache.get(superType.stored(type.getActualStorage())).extendsType(other))
+			if (cache.get(superType).extendsType(other))
 				return true;
 		}
 		
 		return null;
 	}
 	
-	public StoredType union(StoredType other) {
+	public TypeID union(TypeID other) {
 		other = other.getNormalized();
 		if (type == other)
 			return type;
 		return null;
 	}
 	
-	public StoredType[] getLoopTypes(int variables) {
+	public TypeID[] getLoopTypes(int variables) {
 		for (TypeMember<IteratorMemberRef> iterator : iterators)
 			if (iterator.member.getLoopVariableCount() == variables)
 				return iterator.member.types;
 		return null;
 	}
 	
-	public boolean canCastImplicit(StoredType toType) {
+	public boolean canCastImplicit(TypeID toType) {
 		toType = toType.getNormalized();
-		if (areEquivalent(type, toType))
+		if (type == toType)
 			return true;
-		if (toType.type == BasicTypeID.UNDETERMINED)
+		if (toType == BasicTypeID.UNDETERMINED)
 			throw new IllegalArgumentException("Cannot cast to undetermined type!");
-		if (type.type == BasicTypeID.NULL && toType.type.isOptional())
+		if (type == BasicTypeID.NULL && toType.isOptional())
 			return true;
 		
-		if (!type.getActualStorage().canCastTo(toType.getActualStorage()) && !toType.getActualStorage().canCastFrom(type.getActualStorage()))
-			return false;
-		
 		if (toType.isOptional() && canCastImplicit(toType.withoutOptional()))
 			return true;
-		if (type.isOptional() && areEquivalent(type.withoutOptional(), toType))
-			return true;
-		
-		return getImplicitCaster(toType) != null || extendsOrImplements(toType.type);
-	}
-	
-	private boolean areEquivalent(StoredType fromType, StoredType toType) {
-		if (fromType == toType)
+		if (type.isOptional() && type.withoutOptional() == toType)
 			return true;
-		if (!fromType.getActualStorage().canCastTo(toType.getActualStorage()) && !toType.getActualStorage().canCastFrom(fromType.getActualStorage()))
-			return false;
 		
-		return fromType.type == toType.type;
+		return getImplicitCaster(toType) != null || extendsOrImplements(toType);
 	}
 	
-	public CasterMemberRef getImplicitCaster(StoredType toType) {
+	public CasterMemberRef getImplicitCaster(TypeID toType) {
 		toType = toType.getNormalized();
 		for (TypeMember<CasterMemberRef> caster : casters) {
-			if (caster.member.isImplicit() && areEquivalent(caster.member.toType, toType))
+			if (caster.member.isImplicit() && caster.member.toType == toType)
 				return caster.member;
 		}
 		
 		return null;
 	}
 	
-	public CasterMemberRef getCaster(StoredType toType) {
+	public CasterMemberRef getCaster(TypeID toType) {
 		toType = toType.getNormalized();
 		for (TypeMember<CasterMemberRef> caster : casters) {
-			if (areEquivalent(caster.member.toType, toType))
+			if (caster.member.toType == toType)
 				return caster.member;
 		}
 		
 		return null;
 	}
 	
-	public boolean canCast(StoredType toType) {
+	public boolean canCast(TypeID toType) {
 		toType = toType.getNormalized();
 		if (canCastImplicit(toType))
 			return true;
 		
 		for (TypeMember<CasterMemberRef> caster : casters) {
-			if (areEquivalent(caster.member.toType, toType))
+			if (caster.member.toType == toType)
 				return true;
 		}
 		
 		return result;
 	}
 	
-	private Expression castEquivalent(CodePosition position, Expression value, StoredType toType) {
-		if (toType.equals(value.type))
-			return value;
-		
-		//if (!(toType.type instanceof StringTypeID))
-		//	System.out.println(position + ": " + value.type.getActualStorage() + " -> " + toType.getActualStorage());
-		
-		return new StorageCastExpression(position, value, toType);
-	}
-	
-	public Expression castImplicit(CodePosition position, Expression value, StoredType toType, boolean implicit) {
+	public Expression castImplicit(CodePosition position, Expression value, TypeID toType, boolean implicit) {
 		if (toType == null)
 			throw new NullPointerException();
 		
 		toType = toType.getNormalized();
-		if (toType.type == BasicTypeID.UNDETERMINED)
+		if (toType == BasicTypeID.UNDETERMINED)
 			return value;
-		if (areEquivalent(type, toType))
-			return castEquivalent(position, value, toType);
-		
-		if (type.type == BasicTypeID.NULL && toType.isOptional())
+		if (type == toType)
+			return value;
+
+		if (type == BasicTypeID.NULL && toType.isOptional())
 			return new NullExpression(position, toType);
 		if (toType.isOptional() && canCastImplicit(toType.withoutOptional()))
-			return castEquivalent(position, new WrapOptionalExpression(position, castImplicit(position, value, toType.withoutOptional(), implicit), toType), toType);
-		if (type.isOptional() && areEquivalent(type.withoutOptional(), toType))
-			return castEquivalent(position, new CheckNullExpression(position, value), toType);
+			return new WrapOptionalExpression(position, castImplicit(position, value, toType.withoutOptional(), implicit), toType);
+		if (type.isOptional() && type.withoutOptional() == toType)
+			return new CheckNullExpression(position, value);
 		
 		for (TypeMember<CasterMemberRef> caster : casters) {
-			if (caster.member.isImplicit() && areEquivalent(caster.member.toType, toType))
-				return castEquivalent(position, caster.member.cast(position, value, implicit), toType);
+			if (caster.member.isImplicit() && caster.member.toType == toType)
+				return caster.member.cast(position, value, implicit);
 		}
 		for (TypeMember<ImplementationMemberRef> implementation : implementations) {
-			if (implementation.member.implementsType.type.getNormalized() == toType.type)
-				return castEquivalent(position, new InterfaceCastExpression(position, value, implementation.member), toType);
+			if (implementation.member.implementsType.getNormalized() == toType)
+				return new InterfaceCastExpression(position, value, implementation.member);
 		}
-		if (extendsType(toType.type))
+		if (extendsType(toType))
 			return new SupertypeCastExpression(position, value, toType);
 		
 		return new InvalidExpression(position, toType, CompileExceptionCode.INVALID_CAST, "Could not cast " + toString() + " to " + toType);
 	}
 	
-	public Expression castExplicit(CodePosition position, Expression value, StoredType toType, boolean optional) {
+	public Expression castExplicit(CodePosition position, Expression value, TypeID toType, boolean optional) {
 		toType = toType.getNormalized();
 		if (this.canCastImplicit(toType))
 			return castImplicit(position, value, toType, false);
 		
 		for (TypeMember<CasterMemberRef> caster : casters)
-			if (areEquivalent(caster.member.toType, toType))
-				return castEquivalent(position, caster.member.cast(position, value, false), toType);
-		
+			if (caster.member.toType == toType)
+				return value;
+
 		return new InvalidExpression(position, toType, CompileExceptionCode.INVALID_CAST, "Cannot cast " + toString() + " to " + toType + ", even explicitly");
 	}
 	
 			TypeMemberGroup group = members.get(name.name);
 			
 			if (group.isStatic)
-				return new PartialStaticMemberGroupExpression(position, scope, type.type, group, name.arguments);
+				return new PartialStaticMemberGroupExpression(position, scope, type, group, name.arguments);
 			else
 				return new PartialMemberGroupExpression(position, scope, target, group, name.arguments, allowStatic);
 		}
 	
 	public IPartialExpression getStaticMemberExpression(CodePosition position, TypeScope scope, GenericName name) {
 		if (members.containsKey(name.name))
-			return new PartialStaticMemberGroupExpression(position, scope, type.type, members.get(name.name), name.arguments);
+			return new PartialStaticMemberGroupExpression(position, scope, type, members.get(name.name), name.arguments);
 		if (innerTypes.containsKey(name.name))
-			return new PartialTypeExpression(position, innerTypes.get(name.name).instance(cache.getRegistry(), name.arguments, (DefinitionTypeID)type.type), name.arguments);
+			return new PartialTypeExpression(position, innerTypes.get(name.name).instance(cache.getRegistry(), name.arguments, (DefinitionTypeID)type), name.arguments);
 		if (variantOptions.containsKey(name.name))
 			return new PartialVariantOptionExpression(position, scope, variantOptions.get(name.name));
 		
 		if (!innerTypes.containsKey(name.name))
 			throw new RuntimeException("No such inner type in " + type + ": " + name.name);
 		
-		return innerTypes.get(name.name).instance(cache.getRegistry(), name.arguments, (DefinitionTypeID)type.type);
+		return innerTypes.get(name.name).instance(cache.getRegistry(), name.arguments, (DefinitionTypeID)type);
 	}
 	
 	@Override