Merge branch 'feature/remove-stored-types' into feature/remove-storedtypes

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.GenericTypeID;
 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 format(TypeID type) {
 		return type.accept(this);
 	}
-	
-	public String format(StoredType type) {
-		return type.type.accept(this) + (type.getSpecifiedStorage() == null ? "" : "`" + type.getSpecifiedStorage().toString());
-	}
 
 	@Override
 	public String visitBasic(BasicTypeID basic) {
 		return basic.name;
 	}
-	
-	@Override
-	public String visitString(StringTypeID string) {
-		return "string";
-	}
 
 	@Override
 	public String visitArray(ArrayTypeID array) {
 		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;
 	}
 	
 	public FunctionParameter getParameter(boolean isVariadic, int index) {
 		if (isVariadic && index >= parameters.length - 1) {
 			final FunctionParameter parameter = parameters[parameters.length - 1];
-			if(parameter.type.type instanceof ArrayTypeID) {
-				return new FunctionParameter(((ArrayTypeID) parameter.type.type).elementType, parameter.name);
+			if(parameter.type instanceof ArrayTypeID) {
+				return new FunctionParameter(((ArrayTypeID) parameter.type).elementType, parameter.name);
 			}
 			return parameter;
 		} else {
 		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;
             return false;
         if(!Arrays.equals(parameters, that.parameters))
             return false;
-        if(!Objects.equals(thrownType, that.thrownType))
-            return false;
-        return Objects.equals(storage, that.storage);
-    }
+		return thrownType == that.thrownType;
+	}
     
     @Override
     public int hashCode() {
         result = 31 * result + returnType.hashCode();
         result = 31 * result + Arrays.hashCode(parameters);
         result = 31 * result + (thrownType != null ? thrownType.hashCode() : 0);
-        result = 31 * result + (storage != null ? storage.hashCode() : 0);
         result = 31 * result + minParameters;
         result = 31 * result + maxParameters;
         result = 31 * result + (hasUnknowns ? 1 : 0);

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

     
     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) {
+    public TypeID mapGeneric(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();
+        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);
         mapping.forEach((typeParameter, storedType) -> {
             if(resultMap.containsKey(typeParameter)) {
-                if(storedType.type instanceof GenericTypeID && ((GenericTypeID) storedType.type).parameter == typeParameter) {
+                if(storedType instanceof GenericTypeID && ((GenericTypeID) storedType).parameter == typeParameter) {
                     return;
                 }
             }
     }
     
     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/HighLevelDefinition.java

 	
 	public HighLevelDefinition outerDefinition;
 	private TypeID superType;
-	
-	private boolean isDestructible = false;
-	
+
 	public HighLevelDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
 		if (module == null)
 			throw new NullPointerException();
 	
 	public void setSuperType(TypeID superType) {
 		this.superType = superType;
-		if (outerDefinition != null)
-			isDestructible |= outerDefinition.isDestructible;
 	}
 	
 	public boolean isSubclassOf(HighLevelDefinition other) {
 			collector.member(member);
 	}
 	
-	public boolean isDestructible() {
-		Set<HighLevelDefinition> scanning = new HashSet<>();
-		return isDestructible(scanning);
-	}
-	
-	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
-		if (scanning.contains(this))
-			return false;
-		
-		scanning.add(this);
-		
-		boolean isDestructible = false;
-		for (IDefinitionMember member : members) {
-			if (member instanceof DestructorMember)
-				isDestructible = true;
-			if (member instanceof FieldMember) {
-				FieldMember field = (FieldMember)member;
-				if (field.getType().isDestructible(scanning))
-					isDestructible = true;
-			}
-			if ((member instanceof ImplementationMember) && ((ImplementationMember)member).type.isDestructible())
-				isDestructible = true;
-		}
-		
-		scanning.remove(this);
-		return isDestructible;
-	}
-	
 	public void setTypeParameters(TypeParameter[] typeParameters) {
 		this.typeParameters = typeParameters;
 	}
 	}
 	
 	public void normalize(TypeScope scope) {
-		DestructorMember destructor = null;
 		List<FieldMember> fields = new ArrayList<>();
 		
 		for (IDefinitionMember member : members) {
 			member.normalize(scope);
 			
-			if (member instanceof DestructorMember)
-				destructor = (DestructorMember)member;
 			if (member instanceof FieldMember)
 				fields.add((FieldMember)member);
 		}
 		
-		if (isDestructible() && destructor == null && !(this instanceof ExpansionDefinition)) {
-			//System.out.println("Added destructor to " + position);
-			destructor = new DestructorMember(position, this, Modifiers.PUBLIC);
-			members.add(destructor);
-		}
-		
 		for (FieldMember field : fields) {
 			if (field.autoGetter != null)
 				members.add(field.autoGetter);

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

 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ISymbol;
-import org.openzen.zenscript.codemodel.type.storage.StorageType;
 
 /**
  *
 	private final List<ExpansionDefinition> expansions = new ArrayList<>();
 	private final Map<String, ISymbol> globals = new HashMap<>();
 	private final AnnotationDefinition[] annotations;
-	private final StorageType[] storageTypes;
 	private final Map<String, SemanticModule> modules = new HashMap<>();
 	
-	public ModuleSpace(GlobalTypeRegistry registry, List<AnnotationDefinition> annotations, StorageType[] storageTypes) {
+	public ModuleSpace(GlobalTypeRegistry registry, List<AnnotationDefinition> annotations) {
 		this.registry = registry;
 		
 		annotations.add(NativeAnnotationDefinition.INSTANCE);
 		annotations.add(PreconditionAnnotationDefinition.INSTANCE);
 		this.annotations = annotations.toArray(new AnnotationDefinition[annotations.size()]);
-		this.storageTypes = storageTypes;
 	}
 	
 	public void addModule(String name, SemanticModule dependency) throws CompileException {
 	public AnnotationDefinition[] getAnnotations() {
 		return annotations;
 	}
-	
-	public StorageType[] getStorageTypes() {
-		return storageTypes;
-	}
 }

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

 import org.openzen.zenscript.codemodel.scope.FileScope;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ISymbol;
-import org.openzen.zenscript.codemodel.type.storage.StorageType;
 
 /**
  *
 	public final GlobalTypeRegistry registry;
 	public final List<ExpansionDefinition> expansions;
 	public final AnnotationDefinition[] annotations;
-	public final StorageType[] storageTypes;
 	public final IZSLogger logger;
 	
 	public SemanticModule(
             GlobalTypeRegistry registry,
             List<ExpansionDefinition> expansions,
             AnnotationDefinition[] annotations,
-            StorageType[] storageTypes,
             IZSLogger logger)
 	{
 		this.name = module.name;
 		this.registry = registry;
 		this.expansions = expansions;
 		this.annotations = annotations;
-		this.storageTypes = storageTypes;
         this.logger = logger;
     }
 	
 		if (state != State.ASSEMBLED)
 			throw new IllegalStateException("Module is invalid");
 		
-		ModuleTypeResolutionContext context = new ModuleTypeResolutionContext(registry, annotations, storageTypes, rootPackage, null, globals);
+		ModuleTypeResolutionContext context = new ModuleTypeResolutionContext(registry, annotations, rootPackage, null, globals);
 		AnnotationProcessor annotationProcessor = new AnnotationProcessor(context, expansions);
 		List<ScriptBlock> processedScripts = new ArrayList<>();
 		FileScope fileScope = new FileScope(context, expansions, globals, member -> {});
 				registry,
 				expansions,
 				annotations,
-				storageTypes,
                 logger);
 	}
 	

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;
 
 import java.util.Collections;
 import java.util.List;
 	public static final NativeAnnotationDefinition INSTANCE = new NativeAnnotationDefinition();
 	
 	private 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/annotations/PreconditionForMethod.java

 			Expression inverseCondition = members.getGroup(OperatorType.NOT)
 					.call(position, scope, condition, CallArguments.EMPTY, false);
 
-			Statement throwStatement = new ExpressionStatement(position, new PanicExpression(position, BasicTypeID.VOID.stored, message));
+			Statement throwStatement = new ExpressionStatement(position, new PanicExpression(position, BasicTypeID.VOID, message));
 			List<Statement> statements = new ArrayList<>();
 			statements.add(new IfStatement(position, inverseCondition, throwStatement, null));
 

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

 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
-import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 		
 		return module.getType(position, name);
 	}
-	
-	@Override
-	public StorageTag getStorageTag(CodePosition position, String name, String[] arguments) {
-		return module.getStorageTag(position, name, arguments);
-	}
 
 	@Override
-	public StoredType getThisType() {
+	public TypeID getThisType() {
 		return null;
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/LocalTypeResolutionContext.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.BorrowStorageTag;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 		
 		return outer.getType(position, name);
 	}
-
-	@Override
-	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
-		return outer.getStorageTag(position, name, parameters);
-	}
 	
 	@Override
-	public StoredType getThisType() {
+	public TypeID getThisType() {
 		if (type == null)
 			return null;
 		
-		TypeID self = getTypeRegistry().getForMyDefinition(type.load());
-		return self.stored(BorrowStorageTag.THIS);
+		return getTypeRegistry().getForMyDefinition(type.load());
 	}
 }

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

 import java.util.List;
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ISymbol;
-import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
-import org.openzen.zenscript.codemodel.type.storage.InvalidStorageTag;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
-import org.openzen.zenscript.codemodel.type.storage.StorageType;
 
 /**
  *
 public class ModuleTypeResolutionContext implements TypeResolutionContext {
 	private final GlobalTypeRegistry registry;
 	private final Map<String, AnnotationDefinition> annotations = new HashMap<>();
-	private final Map<String, StorageType> storageTypes = new HashMap<>();
 	private final Map<String, ISymbol> globals;
 	private final ZSPackage rootPackage;
 	
 	public ModuleTypeResolutionContext(
 			GlobalTypeRegistry registry,
 			AnnotationDefinition[] annotations,
-			StorageType[] storageTypes,
 			ZSPackage rootPackage,
 			CompilingPackage rootCompiling,
 			Map<String, ISymbol> globals)
 		
 		for (AnnotationDefinition annotation : annotations)
 			this.annotations.put(annotation.getAnnotationName(), annotation);
-		for (StorageType storageType : storageTypes)
-			this.storageTypes.put(storageType.getName(), storageType);
 	}
 	
 	@Override
 	}
 	
 	@Override
-	public StorageTag getStorageTag(CodePosition position, String name, String[] arguments) {
-		if (!storageTypes.containsKey(name))
-			return new InvalidStorageTag(position, CompileExceptionCode.NO_SUCH_STORAGE_TYPE, "No such storage type: " + name);
-		
-		return storageTypes.get(name).instance(position, arguments);
-	}
-	
-	@Override
-	public StoredType getThisType() {
+	public TypeID getThisType() {
 		return null;
 	}
 }

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

 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
-import org.openzen.zenscript.codemodel.type.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) {
-		this(position, outer, thisType, inner.toArray(new TypeParameter[inner.size()]));
+	public TypeContext(CodePosition position, TypeContext outer, TypeID thisType, List<TypeParameter> inner) {
+		this(position, outer, thisType, inner.toArray(TypeParameter.NONE));
 	}
 	
 	public int getId(TypeParameter parameter) {
 		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/FunctionDefinition.java

 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberGroup;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
-import org.openzen.zenscript.codemodel.type.storage.StaticStorageTag;
 
 /**
  *
 	public void setHeader(GlobalTypeRegistry registry, FunctionHeader header) {
 		this.header = header;
 		addMember(caller = new CallerMember(position, this, Modifiers.PUBLIC | Modifiers.STATIC, header, null));
-		callerGroup.addMethod(new FunctionalMemberRef(caller, registry.getFunction(header).stored(StaticStorageTag.INSTANCE), GenericMapper.EMPTY), TypeMemberPriority.SPECIFIED);
+		callerGroup.addMethod(new FunctionalMemberRef(caller, registry.getFunction(header), GenericMapper.EMPTY), TypeMemberPriority.SPECIFIED);
 	}
 	
 	public void setCode(Statement statement) {

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

 		baseInterfaces.add(baseInterface);
 	}
 	
-	@Override
-	public boolean isDestructible() {
-		for (TypeID baseInterface : baseInterfaces)
-			if (baseInterface.isDestructible())
-				return true;
-		
-		return super.isDestructible();
-	}
-	
 	@Override
 	public boolean isStatic() {
 		return true;

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
-import org.openzen.zenscript.codemodel.type.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/AndAndExpression.java

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

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
-import org.openzen.zenscript.codemodel.type.StoredType;
+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.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.*;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.*;
+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!");
 		
 		this.arguments = arguments;
 	}
 	
-	public CallArguments(StoredType... dummy) {
-		this.typeArguments = StoredType.NONE;
+	public CallArguments(TypeID... dummy) {
+		this.typeArguments = TypeID.NONE;
 		this.arguments = new Expression[dummy.length];
 		for (int i = 0; i < dummy.length; i++)
 			arguments[i] = new DummyExpression(dummy[i]);

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/CompareExpression.java

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

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.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/ConstantBoolExpression.java

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.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/ConstantUIntExpression.java

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

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

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

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

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

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

 	public final long value;
 	
 	public ConstantUSizeExpression(CodePosition position, long value) {
-		super(position, BasicTypeID.USIZE.stored, null);
+		super(position, BasicTypeID.USIZE, 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/DummyExpression.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 DummyExpression extends Expression {
-	public DummyExpression(StoredType type) {
+	public DummyExpression(TypeID type) {
 		super(CodePosition.BUILTIN, type, null);
 	}
 

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

 	public final EnumConstantMember value;
 	
 	public EnumConstantExpression(CodePosition position, TypeID type, EnumConstantMember value) {
-		super(position, type.stored(), null);
+		super(position, type, null);
 		
 		this.value = value;
 	}
 	
 	public EnumConstantExpression(CodePosition position, GlobalTypeRegistry registry, EnumDefinition type, EnumConstantMember value) {
-		super(position, registry.getForDefinition(type).stored(), null);
+		super(position, registry.getForDefinition(type), null);
 		
 		this.value = value;
 	}

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

 
 import java.util.Collections;
 import java.util.List;
-import java.util.Objects;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.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) throws CompileException {
+	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<TypeID> hints, GenericName name) throws CompileException {
 		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/ExpressionSymbol.java

 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.type.ISymbol;
-import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
 	}
 
 	@Override
-	public IPartialExpression getExpression(CodePosition position, BaseScope scope, StoredType[] typeArguments) {
+	public IPartialExpression getExpression(CodePosition position, BaseScope scope, TypeID[] typeArguments) {
 		return function.apply(position, scope);
 	}
 
 	@Override
-	public TypeID getType(CodePosition position, TypeResolutionContext context, StoredType[] typeArguments) {
+	public TypeID getType(CodePosition position, TypeResolutionContext context, TypeID[] typeArguments) {
 		return null;
 	}
 }

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

 	T visitOrOr(OrOrExpression expression);
 	
 	T visitPanic(PanicExpression expression);
-	
+
+	T visitPlatformSpecific(Expression expression);
+
 	T visitPostCall(PostCallExpression expression);
 	
 	T visitRange(RangeExpression expression);
 	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/ExpressionVisitorWithContext.java

 	R visitOrOr(C context, OrOrExpression expression);
 	
 	R visitPanic(C context, PanicExpression expression);
-	
+
+	R visitPlatformSpecific(C context, Expression expression);
+
 	R visitPostCall(C context, PostCallExpression expression);
 	
 	R visitRange(C context, RangeExpression expression);
 	R visitStaticGetter(C context, StaticGetterExpression expression);
 	
 	R visitStaticSetter(C context, StaticSetterExpression expression);
-	
-	R visitStorageCast(C context, StorageCastExpression expression);
-	
+
 	R visitSupertypeCast(C context, SupertypeCastExpression expression);
 	
 	R visitThis(C context, 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/GetFieldExpression.java

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

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

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

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/IsExpression.java

 	public final TypeID isType;
 	
 	public IsExpression(CodePosition position, Expression value, TypeID type) {
-		super(position, BasicTypeID.BOOL.stored, value.thrownType);
+		super(position, BasicTypeID.BOOL, value.thrownType);
 		
 		this.value = value;
 		this.isType = type;

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

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

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.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/OrOrExpression.java

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

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.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/SameObjectExpression.java

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

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/ParameterSuperBound.java

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

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

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

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) {
         
         if(!name.equals(that.name))
             return false;
-        if(!Objects.equals(storage, that.storage))
-            return false;
         return bounds.equals(that.bounds);
     }
     
     @Override
     public int hashCode() {
         int result = name.hashCode();
-        result = 31 * result + (storage != null ? storage.hashCode() : 0);
         result = 31 * result + bounds.hashCode();
         return result;
     }

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/ConstructorMember.java

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

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/ImplementationMember.java

 import org.openzen.zenscript.codemodel.member.ref.ImplementationMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 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;
 import org.openzen.zenscript.codemodel.type.TypeID;
 
 	@Override
 	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
-		TypeID instancedType = mapper == null ? type : mapper.map(type.stored()).type;
-		members.addImplementation(new ImplementationMemberRef(this, members.type, instancedType.stored(members.type.getSpecifiedStorage())), priority);
+		TypeID instancedType = mapper == null ? type : mapper.map(type);
+		members.addImplementation(new ImplementationMemberRef(this, members.type, instancedType), priority);
 		
-		TypeMembers interfaceTypeMembers = members.getMemberCache().get(instancedType.stored(members.type.getActualStorage()));
+		TypeMembers interfaceTypeMembers = members.getMemberCache().get(instancedType);
 		interfaceTypeMembers.copyMembersTo(members, TypeMemberPriority.INTERFACE);
 	}
 
 				implemented.add(member.getOverrides().getTarget());
 		}
 		
-		TypeMembers interfaceMembers = scope.getTypeMembers(type.stored());
-		TypeMembers definitionMembers = scope.getTypeMembers(scope.getTypeRegistry().getForMyDefinition(definition).stored());
+		TypeMembers interfaceMembers = scope.getTypeMembers(type);
+		TypeMembers definitionMembers = scope.getTypeMembers(scope.getTypeRegistry().getForMyDefinition(definition));
 		
 		definitionBorrowedMembers.clear();
 		definitionBorrowedMembers.putAll(interfaceMembers.borrowInterfaceMembersFromDefinition(implemented, definitionMembers));
 	}
 
 	@Override
-	public DefinitionMemberRef ref(StoredType type, GenericMapper mapper) {
+	public DefinitionMemberRef ref(TypeID type, GenericMapper mapper) {
 		throw new UnsupportedOperationException("Cannot create an implementation reference");
 	}
 

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/InnerDefinitionMember.java

 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 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;
 	}
 
 	@Override
-	public DefinitionMemberRef ref(StoredType type, GenericMapper mapper) {
+	public DefinitionMemberRef ref(TypeID type, GenericMapper mapper) {
 		throw new UnsupportedOperationException("Cannot create an inner definition reference");
 	}
 	

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/StaticInitializerMember.java

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 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.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;
 	}
 
 	@Override
-	public DefinitionMemberRef ref(StoredType type, GenericMapper mapper) {
+	public DefinitionMemberRef ref(TypeID type, GenericMapper mapper) {
 		throw new UnsupportedOperationException("Cannot reference a static initializer");
 	}
 	

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

 import org.openzen.zenscript.codemodel.expression.Expression;
 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.annotations.MemberAnnotation;
 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;
 	}