Removed TypeArgument and simplified type system a little

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.TypeArgument;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 			result.append("<");
 			
 			int index = 0;
-			for (TypeArgument typeArgument : arguments.typeArguments) {
+			for (StoredType 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.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
+import org.openzen.zenscript.codemodel.type.OptionalTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import stdlib.Chars;
 import org.openzen.zenscript.codemodel.type.TypeVisitor;
 		return type.accept(this);
 	}
 	
-	public String format(TypeArgument type) {
-		return type.storage == null ? format(type.type) : format(type.stored());
-	}
-	
 	public String format(StoredType type) {
-		return type.type.accept(this) + "`" + type.storage.toString();
+		return type.type.accept(this) + (type.getSpecifiedStorage() == null ? "" : "`" + type.getSpecifiedStorage().toString());
 	}
 
 	@Override
 		result.append(importedName);
 		result.append("<");
 		int index = 0;
-		for (TypeArgument typeParameter : definition.typeArguments) {
+		for (StoredType typeParameter : definition.typeArguments) {
 			if (index > 0)
 				result.append(", ");
 			
 	}
 
 	@Override
-	public String visitModified(ModifiedTypeID type) {
-		StringBuilder result = new StringBuilder();
-		if (type.isConst())
-			result.append("const ");
-		if (type.isImmutable())
-			result.append("immutable ");
-		result.append(type.accept(this));
-		if (type.isOptional())
-			result.append("?");
-		
-		return result.toString();
+	public String visitOptional(OptionalTypeID type) {
+		return type.accept(this) + "?";
 	}
 
 	@Override

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

 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.TypeArgument;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 		return result.toString();
 	}
 	
-	public TypeArgument[] inferTypes(LocalMemberCache cache, CallArguments arguments, List<StoredType> resultHint) {
+	public StoredType[] inferTypes(LocalMemberCache cache, CallArguments arguments, List<StoredType> resultHint) {
 		if (arguments.arguments.length != this.parameters.length)
 			return null;
 		
-		Map<TypeParameter, TypeArgument> mapping = new HashMap<>();
+		Map<TypeParameter, StoredType> mapping = new HashMap<>();
 		if (!resultHint.isEmpty()) {
 			for (StoredType hint : resultHint) {
-				Map<TypeParameter, TypeArgument> temp = returnType.inferTypeParameters(cache, hint.asArgument());
+				Map<TypeParameter, StoredType> temp = returnType.inferTypeParameters(cache, hint);
 				if (temp != null) {
 					mapping = temp;
 					break;
 		
 		// TODO: lambda header inference
 		for (int i = 0; i < parameters.length; i++) {
-			Map<TypeParameter, TypeArgument> forParameter = parameters[i].type.inferTypeParameters(cache, arguments.arguments[i].type.asArgument());
+			Map<TypeParameter, StoredType> forParameter = parameters[i].type.inferTypeParameters(cache, arguments.arguments[i].type);
 			if (forParameter == null)
 				return null;
 			
 		if (mapping.size() > typeParameters.length)
 			return null;
 		
-		TypeArgument[] result = new TypeArgument[typeParameters.length];
+		StoredType[] result = new StoredType[typeParameters.length];
 		for (int i = 0; i < typeParameters.length; i++) {
 			TypeParameter typeParameter = typeParameters[i];
 			if (!mapping.containsKey(typeParameter)) {
 	
 	public FunctionHeader instanceForCall(GlobalTypeRegistry registry, CallArguments arguments) {
 		if (arguments.getNumberOfTypeArguments() > 0) {
-			Map<TypeParameter, TypeArgument> typeParameters = TypeArgument.getMapping(this.typeParameters, arguments.typeArguments);
+			Map<TypeParameter, StoredType> typeParameters = StoredType.getMapping(this.typeParameters, arguments.typeArguments);
 			return withGenericArguments(
 					registry,
 					new GenericMapper(registry, typeParameters));
 	
 	public FunctionHeader withGenericArguments(GlobalTypeRegistry registry, GenericMapper mapper) {
 		if (typeParameters.length > 0)
-			mapper = mapper.getInner(registry, TypeArgument.getSelfMapping(registry, typeParameters));
+			mapper = mapper.getInner(registry, StoredType.getSelfMapping(registry, typeParameters));
 		
 		StoredType returnType = this.returnType.instance(mapper);
 		FunctionParameter[] parameters = new FunctionParameter[this.parameters.length];
 		return new FunctionHeader(typeParameters, returnType, thrownType == null ? null : thrownType.instance(mapper), storage, parameters);
 	}
 	
-	public FunctionHeader fillGenericArguments(GlobalTypeRegistry registry, TypeArgument[] arguments, GenericMapper typeParameterMapping) {
+	public FunctionHeader fillGenericArguments(GlobalTypeRegistry registry, StoredType[] arguments, GenericMapper typeParameterMapping) {
 		if (arguments == null || arguments.length == 0)
 			return this;
 		
-		Map<TypeParameter, TypeArgument> typeArguments = TypeArgument.getMapping(typeParameters, arguments);
+		Map<TypeParameter, StoredType> typeArguments = StoredType.getMapping(typeParameters, arguments);
 		GenericMapper mapper = typeParameterMapping.getInner(registry, typeArguments);
 		
 		StoredType returnType = this.returnType.instance(mapper);

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

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

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

 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.TypeArgument;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 	}
 	
 	public GenericMapper getMapper() {
-		Map<TypeParameter, TypeArgument> mapper = TypeArgument.getSelfMapping(moduleContext.registry, typeParameters);
+		Map<TypeParameter, StoredType> mapper = StoredType.getSelfMapping(moduleContext.registry, typeParameters);
 		return new GenericMapper(moduleContext.registry, mapper);
 	}
 	

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

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

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

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

 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 
 /**
 	}
 	
 	@Override
-	public TypeArgument[] getTypeArguments() {
+	public StoredType[] getTypeArguments() {
 		return null;
 	}
 	

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

 
 	@Override
 	public void registerMembers(LocalMemberCache cache, TypeMembers members) {
-		cache.get(this.type.stored(members.type.storage))
+		cache.get(this.type.stored(members.type.getSpecifiedStorage()))
 				.copyMembersTo(position, members, TypeMemberPriority.FROM_TYPE_BOUNDS);
 	}
 

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

 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.TypeArgument;
 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(position, new TypeArgument(type, null)).type;
+		TypeID instancedType = mapper == null ? type : mapper.map(position, type.stored()).type;
 		members.addImplementation(new ImplementationMemberRef(this, members.type, instancedType), priority);
 		
-		TypeMembers interfaceTypeMembers = members.getMemberCache().get(instancedType.stored(members.type.storage));
+		TypeMembers interfaceTypeMembers = members.getMemberCache().get(instancedType.stored(members.type.getActualStorage()));
 		interfaceTypeMembers.copyMembersTo(position, members, TypeMemberPriority.INTERFACE);
 	}
 

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

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
-import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 	
 	Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException;
 	
-	TypeArgument[] getTypeArguments();
+	StoredType[] getTypeArguments();
 	
 	/**
 	 * Retrieves the (primary) member this expression refers to, or null if there is no primary target.

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

 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 
 /**
  *
 	private final CodePosition position;
 	private final String name;
 	private final IPartialExpression resolution;
-	private final TypeArgument[] typeArguments;
+	private final StoredType[] typeArguments;
 	
-	public PartialGlobalExpression(CodePosition position, String name, IPartialExpression resolution, TypeArgument[] typeArguments) {
+	public PartialGlobalExpression(CodePosition position, String name, IPartialExpression resolution, StoredType[] typeArguments) {
 		this.position = position;
 		this.name = name;
 		this.resolution = resolution;
 	}
 
 	@Override
-	public TypeArgument[] getTypeArguments() {
+	public StoredType[] getTypeArguments() {
 		return typeArguments;
 	}
 }

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.member.TypeMember;
 
 /**
 	private final CodePosition position;
 	private final Expression target;
 	private final TypeMemberGroup group;
-	private final TypeArgument[] typeArguments;
+	private final StoredType[] typeArguments;
 	private final boolean allowStaticUsage;
 	private final TypeScope scope;
 	
 			TypeScope scope,
 			Expression target,
 			TypeMemberGroup group,
-			TypeArgument[] typeArguments,
+			StoredType[] typeArguments,
 			boolean allowStaticMembers)
 	{
 		this.position = position;
 			Expression target,
 			String name,
 			FunctionalMemberRef member,
-			TypeArgument[] typeArguments,
+			StoredType[] typeArguments,
 			boolean allowStaticMembers)
 	{
 		this.position = position;
 	}
 
 	@Override
-	public TypeArgument[] getTypeArguments() {
+	public StoredType[] getTypeArguments() {
 		return typeArguments;
 	}
 }

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 
 /**
  *
 	}
 
 	@Override
-	public TypeArgument[] getTypeArguments() {
+	public StoredType[] getTypeArguments() {
 		return null;
 	}
 }

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.TypeID;
 
  * @author Hoofdgebruiker
  */
 public class PartialStaticMemberGroupExpression implements IPartialExpression {
-	public static PartialStaticMemberGroupExpression forMethod(CodePosition position, TypeScope scope, String name, TypeID target, FunctionalMemberRef method, TypeArgument[] typeArguments) {
+	public static PartialStaticMemberGroupExpression forMethod(CodePosition position, TypeScope scope, String name, TypeID target, FunctionalMemberRef method, StoredType[] typeArguments) {
 		TypeMemberGroup group = new TypeMemberGroup(true, name);
 		group.addMethod(method, TypeMemberPriority.SPECIFIED);
 		return new PartialStaticMemberGroupExpression(position, scope, target, group, typeArguments);
 	private final TypeScope scope;
 	private final TypeID target;
 	private final TypeMemberGroup group;
-	private final TypeArgument[] typeArguments;
+	private final StoredType[] typeArguments;
 	
-	public PartialStaticMemberGroupExpression(CodePosition position, TypeScope scope, TypeID target, TypeMemberGroup group, TypeArgument[] typeArguments) {
+	public PartialStaticMemberGroupExpression(CodePosition position, TypeScope scope, TypeID target, TypeMemberGroup group, StoredType[] typeArguments) {
 		this.position = position;
 		this.scope = scope;
 		this.group = group;
 	}
 
 	@Override
-	public TypeArgument[] getTypeArguments() {
+	public StoredType[] getTypeArguments() {
 		return typeArguments;
 	}
 	

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.storage.StaticExpressionStorageTag;
 
 public class PartialTypeExpression implements IPartialExpression {
 	private final CodePosition position;
 	private final StoredType type;
-	private final TypeArgument[] typeArguments;
+	private final StoredType[] typeArguments;
 	
-	public PartialTypeExpression(CodePosition position, TypeID type, TypeArgument[] typeArguments) {
+	public PartialTypeExpression(CodePosition position, TypeID type, StoredType[] typeArguments) {
 		this.position = position;
 		this.type = type.stored(StaticExpressionStorageTag.INSTANCE);
 		this.typeArguments = typeArguments;
 	}
 
 	@Override
-	public TypeArgument[] getTypeArguments() {
+	public StoredType[] getTypeArguments() {
 		return typeArguments;
 	}
 	

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

 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
-import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 	}
 
 	@Override
-	public TypeArgument[] getTypeArguments() {
-		return TypeArgument.NONE;
+	public StoredType[] getTypeArguments() {
+		return StoredType.NONE;
 	}
 }

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

 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StaticExpressionStorageTag;
-import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
 		this.outer = outer;
 		this.definition = definition;
 		
-		Map<TypeParameter, TypeArgument> typeParameters = new HashMap<>();
+		Map<TypeParameter, StoredType> typeParameters = new HashMap<>();
 		if (definition instanceof ExpansionDefinition) {
 			ExpansionDefinition expansion = (ExpansionDefinition)definition;
-			type = expansion.target.storage == null
-					? expansion.target.stored(BorrowStorageTag.THIS)
-					: expansion.target.stored();
+			type = expansion.target;
 			this.typeParameters = expansion.typeParameters;
-			typeParameters = TypeArgument.getSelfMapping(outer.getTypeRegistry(), expansion.typeParameters);
+			typeParameters = StoredType.getSelfMapping(outer.getTypeRegistry(), expansion.typeParameters);
 		} else {
 			DefinitionTypeID definitionType = outer.getTypeRegistry().getForMyDefinition(definition);
 			type = definitionType.stored(BorrowStorageTag.THIS);
 			
 			List<TypeParameter> typeParameterList = new ArrayList<>();
 			while (definitionType != null) {
-				typeParameters = TypeArgument.getSelfMapping(outer.getTypeRegistry(), definitionType.definition.typeParameters);
+				typeParameters = StoredType.getSelfMapping(outer.getTypeRegistry(), definitionType.definition.typeParameters);
 				typeParameterList.addAll(Arrays.asList(definitionType.definition.typeParameters));
 				
 				definitionType = definitionType.definition.isStatic() ? null : definitionType.outer;

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

 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 	private final DollarEvaluator dollar;
 	
 	public final List<StoredType> hints;
-	public final Map<TypeParameter, TypeArgument> genericInferenceMap;
+	public final Map<TypeParameter, StoredType> genericInferenceMap;
 	public final Map<String, Function<CodePosition, Expression>> innerVariables = new HashMap<>();
 	
 	public ExpressionScope(BaseScope outer) {
 			BaseScope scope,
 			List<StoredType> hints,
 			DollarEvaluator dollar,
-			Map<TypeParameter, TypeArgument> genericInferenceMap,
+			Map<TypeParameter, StoredType> genericInferenceMap,
 			Map<String, Function<CodePosition, Expression>> innerVariables) {
 		this.outer = scope;
 		this.hints = hints;
 		if (header.typeParameters == null)
 			return this;
 		
-		Map<TypeParameter, TypeArgument> genericInferenceMap = new HashMap<>();
+		Map<TypeParameter, StoredType> genericInferenceMap = new HashMap<>();
 		for (TypeParameter parameter : header.typeParameters)
 			genericInferenceMap.put(parameter, null);
 		

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

 	public boolean isOptional() {
 		return false;
 	}
-
-	@Override
-	public boolean isConst() {
-		return false;
-	}
 	
 	@Override
 	public boolean isValueType() {
 	}
 	
 	@Override
-	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
-		return mapper.registry.getArray(elementType.instance(mapper), dimension).argument(storage);
+	public StoredType instance(GenericMapper mapper, StorageTag storage) {
+		return mapper.registry.getArray(elementType.instance(mapper), dimension).stored(storage);
 	}
 
 	@Override

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

 	}
 	
 	@Override
-	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
+	public StoredType instance(GenericMapper mapper, StorageTag storage) {
 		return mapper.registry.getAssociative(
 				keyType.instance(mapper),
-				valueType.instance(mapper)).argument(storage);
+				valueType.instance(mapper)).stored(storage);
 	}
 	
 	@Override
 	public boolean isOptional() {
 		return false;
 	}
-
-	@Override
-	public boolean isConst() {
-		return false;
-	}
 	
 	@Override
 	public boolean isValueType() {

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

 	
 	public final String name;
 	public final StoredType stored;
-	public final TypeArgument argument;
 	
 	BasicTypeID(String name) {
 		this.name = name;
-		stored = new StoredType(this, ValueStorageTag.INSTANCE);
-		argument = new TypeArgument(this, ValueStorageTag.INSTANCE);
+		stored = new StoredType(this, null);
 	}
 	
 	@Override
 	}
 	
 	@Override
-	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
-		return new TypeArgument(this, storage);
+	public StoredType instance(GenericMapper mapper, StorageTag storage) {
+		return stored(storage);
 	}
 	
 	@Override
 	public boolean isOptional() {
 		return false;
 	}
-
-	@Override
-	public boolean isConst() {
-		return false;
-	}
 	
 	@Override
 	public boolean isValueType() {

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

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

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

 	}
 	
 	@Override
-	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
-		return new TypeArgument(mapper.registry.getFunction(mapper.map(header)), storage);
+	public StoredType instance(GenericMapper mapper, StorageTag storage) {
+		return mapper.registry.getFunction(mapper.map(header)).stored(storage);
 	}
 	
 	@Override
 	public boolean isOptional() {
 		return false;
 	}
-
-	@Override
-	public boolean isConst() {
-		return false;
-	}
 	
 	@Override
 	public boolean isValueType() {

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

 	public boolean isOptional() {
 		return false;
 	}
-
-	@Override
-	public boolean isConst() {
-		return false;
-	}
 	
 	@Override
 	public boolean isValueType() {
 	}
 	
 	@Override
-	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
-		return new TypeArgument(mapper.registry.getGenericMap(value.instance(mapper), key), storage);
+	public StoredType instance(GenericMapper mapper, StorageTag storage) {
+		return mapper.registry.getGenericMap(value.instance(mapper), key).stored(storage);
 	}
 
 	@Override

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

  */
 public class GenericName {
 	public final String name;
-	public final TypeArgument[] arguments;
+	public final StoredType[] arguments;
 	
 	public GenericName(String name) {
-		this(name, TypeArgument.NONE);
+		this(name, StoredType.NONE);
 	}
 	
-	public GenericName(String name, TypeArgument[] arguments) {
+	public GenericName(String name, StoredType[] arguments) {
 		if (arguments == null)
 			throw new NullPointerException("Arguments cannot be null");
 		

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

 		this.parameter = parameter;
 	}
 	
-	public boolean matches(LocalMemberCache cache, TypeArgument type) {
-		if (type.storage != null && parameter.storage != null && !type.storage.equals(parameter.storage))
+	public boolean matches(LocalMemberCache cache, StoredType type) {
+		if (type.getSpecifiedStorage() != null && parameter.storage != null && !type.getActualStorage().equals(parameter.storage))
 			return false;
 		
 		return parameter.matches(cache, type.type);
 	}
 	
 	@Override
-	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
-		return mapper.map(this).argument(StorageTag.union(parameter.storage, storage));
+	public StoredType instance(GenericMapper mapper, StorageTag storage) {
+		StoredType mapped = mapper.map(this);
+		return new StoredType(mapped.type, StorageTag.union(mapped.getSpecifiedStorage(), storage));
 	}
 	
 	@Override
 	public boolean isOptional() {
 		return false;
 	}
-
-	@Override
-	public boolean isConst() {
-		return false;
-	}
 	
 	@Override
 	public boolean isValueType() {

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

 	private final Map<DefinitionTypeID, DefinitionTypeID> definitionTypes = new HashMap<>();
 	private final Map<GenericTypeID, GenericTypeID> genericTypes = new HashMap<>();
 	
-	private final Map<ModifiedTypeID, ModifiedTypeID> modifiedTypes = new HashMap<>();
+	private final Map<OptionalTypeID, OptionalTypeID> optionalTypes = new HashMap<>();
 	
 	public final ZSPackage stdlib;
 	
 	}
 	
 	public DefinitionTypeID getForMyDefinition(HighLevelDefinition definition) {
-		TypeArgument[] typeArguments = TypeArgument.NONE;
+		StoredType[] typeArguments = StoredType.NONE;
 		if (definition.getNumberOfGenericParameters() > 0) {
-			typeArguments = new TypeArgument[definition.getNumberOfGenericParameters()];
+			typeArguments = new StoredType[definition.getNumberOfGenericParameters()];
 			for (int i = 0; i < definition.typeParameters.length; i++)
-				typeArguments[i] = new TypeArgument(getGeneric(definition.typeParameters[i]), definition.typeParameters[i].storage);
+				typeArguments[i] = new StoredType(getGeneric(definition.typeParameters[i]), definition.typeParameters[i].storage);
 		}
 		DefinitionTypeID outer = null;
 		if (definition.outerDefinition != null)
 		return getForDefinition(definition, typeArguments, outer);
 	}
 	
-	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, TypeArgument... typeArguments) {
+	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, StoredType... typeArguments) {
 		return this.getForDefinition(definition, typeArguments, null);
 	}
 	
-	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, TypeArgument[] typeArguments, DefinitionTypeID outer) {
+	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, StoredType[] typeArguments, DefinitionTypeID outer) {
 		DefinitionTypeID id = new DefinitionTypeID(this, definition, typeArguments, definition.isStatic() ? null : outer);
-		
-		if (definitionTypes.containsKey(id)) {
-			return definitionTypes.get(id);
-		} else {
-			definitionTypes.put(id, id);
-			return id;
-		}
+		return internalize(definitionTypes, id);
 	}
 	
 	public TypeID getOptional(TypeID original) {
-		return getModified(ModifiedTypeID.MODIFIER_OPTIONAL, original);
-	}
-	
-	public TypeID getModified(int modifiers, TypeID type) {
-		if (modifiers == 0)
-			return type;
-		if (type instanceof ModifiedTypeID) {
-			ModifiedTypeID modified = (ModifiedTypeID)type;
-			return getModified(modified.modifiers | modifiers, modified.baseType);
-		}
-		
-		ModifiedTypeID result = new ModifiedTypeID(this, modifiers, type);
-		return internalize(modifiedTypes, result);
+		return internalize(optionalTypes, new OptionalTypeID(this, original));
 	}
 	
 	private <T> T internalize(Map<T, T> identityMap, T id) {

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

  * @author Hoofdgebruiker
  */
 public interface ISymbol {
-	public IPartialExpression getExpression(CodePosition position, BaseScope scope, TypeArgument[] typeArguments);
+	public IPartialExpression getExpression(CodePosition position, BaseScope scope, StoredType[] typeArguments);
 	
-	public TypeID getType(CodePosition position, TypeResolutionContext context, TypeArgument[] typeArguments);
+	public TypeID getType(CodePosition position, TypeResolutionContext context, StoredType[] typeArguments);
 }

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

 	}
 
 	@Override
-	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
-		return new TypeArgument(this, storage);
+	public StoredType instance(GenericMapper mapper, StorageTag storage) {
+		return stored(storage);
 	}
 
 	@Override

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

 	public boolean isOptional() {
 		return false;
 	}
-
-	@Override
-	public boolean isConst() {
-		return false;
-	}
 	
 	@Override
 	public boolean isDestructible() {
 	}
 	
 	@Override
-	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
+	public StoredType instance(GenericMapper mapper, StorageTag storage) {
 		StoredType[] instanced = mapper.map(iteratorTypes);
-		return new TypeArgument(mapper.registry.getIterator(instanced), storage);
+		return mapper.registry.getIterator(instanced).stored(storage);
 	}
 
 	@Override

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

  *
  * @author Hoofdgebruiker
  */
-public class ModifiedTypeID implements TypeID {
-	public static final int MODIFIER_OPTIONAL = 1;
-	public static final int MODIFIER_CONST = 2;
-	public static final int MODIFIER_IMMUTABLE = 4;
-	
-	public final int modifiers;
+public class OptionalTypeID implements TypeID {
 	public final TypeID baseType;
 	private final TypeID normalized;
 	private final GlobalTypeRegistry registry;
 	
-	public ModifiedTypeID(GlobalTypeRegistry registry, int modifiers, TypeID baseType) {
-		this.modifiers = modifiers;
+	public OptionalTypeID(GlobalTypeRegistry registry, TypeID baseType) {
 		this.baseType = baseType;
 		this.registry = registry;
 		
-		normalized = baseType.getNormalized() == baseType ? this : registry.getModified(modifiers, baseType.getNormalized());
+		normalized = baseType.getNormalized() == baseType ? this : registry.getOptional(baseType.getNormalized());
 	}
 	
 	@Override
 	}
 	
 	@Override
-	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
-		TypeArgument base = baseType.instance(mapper, storage);
-		return new TypeArgument(mapper.registry.getModified(modifiers, base.type), base.storage);
+	public StoredType instance(GenericMapper mapper, StorageTag storage) {
+		StoredType base = baseType.instance(mapper, storage);
+		return mapper.registry.getOptional(base.type).stored(StorageTag.union(base.getSpecifiedStorage(), storage));
 	}
 	
 	@Override
 	public <R> R accept(TypeVisitor<R> visitor) {
-		return visitor.visitModified(this);
+		return visitor.visitOptional(this);
 	}
 	
 	@Override
 
 	@Override
 	public boolean isOptional() {
-		return (modifiers & MODIFIER_OPTIONAL) > 0;
-	}
-	
-	@Override
-	public boolean isImmutable() {
-		return (modifiers & MODIFIER_IMMUTABLE) > 0;
-	}
-
-	@Override
-	public boolean isConst() {
-		return (modifiers & MODIFIER_CONST) > 0;
+		return true;
 	}
 	
 	@Override
 	
 	@Override
 	public TypeID withoutOptional() {
-		return without(MODIFIER_OPTIONAL);
-	}
-	
-	@Override
-	public TypeID withoutImmutable() {
-		return without(MODIFIER_IMMUTABLE);
-	}
-	
-	@Override
-	public TypeID withoutConst() {
-		return without(MODIFIER_CONST);
-	}
-	
-	private TypeID without(int modifiers) {
-		int newModifiers = this.modifiers & ~modifiers;
-		return newModifiers == 0 ? baseType : registry.getModified(newModifiers, baseType);
+		return baseType;
 	}
 
 	@Override
 	public int hashCode() {
 		int hash = 3;
 		hash = 79 * hash + Objects.hashCode(this.baseType);
-		hash = 79 * hash + modifiers;
 		return hash;
 	}
 
 			return false;
 		if (getClass() != obj.getClass())
 			return false;
-		final ModifiedTypeID other = (ModifiedTypeID) obj;
-		return this.baseType == other.baseType
-				&& this.modifiers == other.modifiers;
+		final OptionalTypeID other = (OptionalTypeID) obj;
+		return this.baseType == other.baseType;
 	}
 	
 	@Override
 	public String toString() {
-		StringBuilder result = new StringBuilder();
-		if ((modifiers & MODIFIER_IMMUTABLE) > 0)
-			result.append("immutable ");
-		if ((modifiers & MODIFIER_CONST) > 0)
-			result.append("const ");
-		result.append(baseType.toString());
-		if ((modifiers & MODIFIER_OPTIONAL) > 0)
-			result.append("?");
-		return result.toString();
+		return baseType.toString() + "?";
 	}
 	
 	@Override
 	public String toString(StorageTag storage) {
 		StringBuilder result = new StringBuilder();
-		if ((modifiers & MODIFIER_IMMUTABLE) > 0)
-			result.append("immutable ");
-		if ((modifiers & MODIFIER_CONST) > 0)
-			result.append("const ");
 		result.append(baseType.toString(storage));
-		if ((modifiers & MODIFIER_OPTIONAL) > 0)
-			result.append("?");
+		result.append("?");
 		return result.toString();
 	}
 }

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
-import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
 			normalized = registry.getRange(baseType.getNormalized());
 		}
 		
-		stored = new StoredType(this, baseType.storage);
+		stored = new StoredType(this, baseType.getSpecifiedStorage());
 	}
 	
 	@Override
 	}
 	
 	@Override
-	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
-		return mapper.registry.getRange(baseType.instance(mapper)).argument(storage);
+	public StoredType instance(GenericMapper mapper, StorageTag storage) {
+		return mapper.registry.getRange(baseType.instance(mapper)).stored(storage);
 	}
 	
 	@Override
 	public boolean isOptional() {
 		return false;
 	}
-
-	@Override
-	public boolean isConst() {
-		return false;
-	}
 	
 	@Override
 	public boolean isValueType() {

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

  */
 package org.openzen.zenscript.codemodel.type;
 
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
  * @author Hoofdgebruiker
  */
 public class StoredType {
+	public static Map<TypeParameter, StoredType> getMapping(TypeParameter[] parameters, StoredType[] arguments) {
+		Map<TypeParameter, StoredType> typeArguments = new HashMap<>();
+		for (int i = 0; i < parameters.length; i++)
+			typeArguments.put(parameters[i], arguments[i]);
+		return typeArguments;
+	}
+	
+	public static Map<TypeParameter, StoredType> getSelfMapping(GlobalTypeRegistry registry, TypeParameter[] parameters) {
+		Map<TypeParameter, StoredType> typeArguments = new HashMap<>();
+		for (TypeParameter parameter : parameters)
+			typeArguments.put(parameter, registry.getGeneric(parameter).stored(parameter.storage));
+		return typeArguments;
+	}
+	
 	public static final StoredType[] NONE = new StoredType[0];
 	
 	public final TypeID type;
-	public final StorageTag storage;
+	private final StorageTag storage;
 	
 	public StoredType(TypeID type, StorageTag storage) {
-		if (storage == null)
-			throw new NullPointerException();
-		
-		if (type.isValueType())
-			storage = ValueStorageTag.INSTANCE;
-		else if (storage == ValueStorageTag.INSTANCE)
+		if (/*!type.isValueType() && */storage == ValueStorageTag.INSTANCE)
 			throw new IllegalArgumentException("storage of a nonvalue type cannot be value");
 		
 		this.type = type;
 		this.storage = storage;
 	}
 	
+	public StorageTag getSpecifiedStorage() {
+		return storage;
+	}
+	
+	public StorageTag getActualStorage() {
+		if (storage != null)
+			return storage;
+		
+		return type.isValueType() ? ValueStorageTag.INSTANCE : AutoStorageTag.INSTANCE;
+	}
+	
 	public StoredType getNormalized() {
 		return type.getNormalized() == type ? this : new StoredType(type, storage);
 	}
 	}
 	
 	public StoredType instance(GenericMapper mapper) {
-		TypeArgument result = type.instance(mapper, storage);
-		return result == type ? this : result.stored();
+		return type.instance(mapper, storage);
 	}
 	
 	public boolean isDestructible() {
-		return type.isDestructible() && storage.isDestructible();
+		return type.isDestructible() && getActualStorage().isDestructible();
 	}
 	
 	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
-		return type.isDestructible(scanning) && storage.isDestructible();
+		return type.isDestructible(scanning) && getActualStorage().isDestructible();
 	}
 	
 	public boolean hasDefaultValue() {
 	}
 	
 	public boolean isConst() {
-		return storage.isConst();
+		return getActualStorage().isConst();
 	}
 	
 	public boolean isImmutable() {
-		return storage.isImmutable();
+		return getActualStorage().isImmutable();
 	}
 	
 	public boolean isBasic(BasicTypeID type) {
 		return new StoredType(type.withoutOptional(), storage);
 	}
 	
-	public StoredType withoutConst() {
-		return new StoredType(type.withoutConst(), storage);
-	}
-	
-	public StoredType withoutImmutable() {
-		return new StoredType(type.withoutImmutable(), storage);
-	}
-	
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
 		return type.hasInferenceBlockingTypeParameters(parameters);
 	}
 	
 	// Infers type parameters for this type so it matches with targetType
 	// returns false if that isn't possible
-	public Map<TypeParameter, TypeArgument> inferTypeParameters(LocalMemberCache cache, TypeArgument targetType) {
+	public Map<TypeParameter, StoredType> inferTypeParameters(LocalMemberCache cache, StoredType targetType) {
 		return type.inferTypeParameters(cache, targetType);
 	}
 	
 		return (DefinitionTypeID)type;
 	}
 	
-	public TypeArgument asArgument() {
-		return new TypeArgument(type, storage);
-	}
-	
 	@Override
 	public int hashCode() {
 		int hash = 5;
 	
 	@Override
 	public String toString() {
-		return type.toString(storage);
+		return storage == null ? type.toString() : type.toString(storage);
 	}
 	
 	public static class MatchingTypeVisitor implements TypeVisitor<Boolean> {
 		private final TypeID type;
-		private final Map<TypeParameter, TypeArgument> mapping;
+		private final Map<TypeParameter, StoredType> mapping;
 		private final LocalMemberCache cache;
 		
-		public MatchingTypeVisitor(LocalMemberCache cache, TypeID type, Map<TypeParameter, TypeArgument> mapping) {
+		public MatchingTypeVisitor(LocalMemberCache cache, TypeID type, Map<TypeParameter, StoredType> mapping) {
 			this.type = type;
 			this.mapping = mapping;
 			this.cache = cache;
 				if (arrayType.dimension != array.dimension)
 					return false;
 				
-				return match(arrayType.elementType, array.elementType.asArgument());
+				return match(arrayType.elementType, array.elementType);
 			} else {
 				return false;
 			}
 		public Boolean visitAssoc(AssocTypeID assoc) {
 			if (type instanceof AssocTypeID) {
 				AssocTypeID assocType = (AssocTypeID) type;
-				return match(assocType.keyType, assoc.keyType.asArgument())
-						&& match(assocType.valueType, assoc.valueType.asArgument());
+				return match(assocType.keyType, assoc.keyType)
+						&& match(assocType.valueType, assoc.valueType);
 			} else {
 				return false;
 			}
 				
 				boolean result = true;
 				for (int i = 0; i < iteratorType.iteratorTypes.length; i++)
-					result = result && match(iterator.iteratorTypes[i], iteratorType.iteratorTypes[i].asArgument());
+					result = result && match(iterator.iteratorTypes[i], iteratorType.iteratorTypes[i]);
 				
 				return result;
 			} else {
 				if (functionType.header.parameters.length != function.header.parameters.length)
 					return false;
 				
-				if (!match(functionType.header.getReturnType(), function.header.getReturnType().asArgument()))
+				if (!match(functionType.header.getReturnType(), function.header.getReturnType()))
 					return false;
 				
 				for (int i = 0; i < function.header.parameters.length; i++) {
-					if (!match(functionType.header.parameters[i].type, function.header.parameters[i].type.asArgument()))
+					if (!match(functionType.header.parameters[i].type, function.header.parameters[i].type))
 						return false;
 				}
 				
 				
 				if (definition.typeArguments != null) {
 					for (int i = 0; i < definitionType.typeArguments.length; i++) {
-						if (!match(definitionType.typeArguments[i].stored(), definition.typeArguments[i]))
+						if (!match(definitionType.typeArguments[i], definition.typeArguments[i]))
 							return false;
 					}
 				}
 		public Boolean visitGeneric(GenericTypeID generic) {
 			if (mapping.containsKey(generic.parameter)) {
 				return mapping.get(generic.parameter) == type;
-			} else if (type == generic || generic.matches(cache, new TypeArgument(type, null))) {
-				mapping.put(generic.parameter, new TypeArgument(type, null));
+			} else if (type == generic || generic.matches(cache, type.stored())) {
+				mapping.put(generic.parameter, type.stored());
 				return true;
 			} else {
 				return false;
 		public Boolean visitRange(RangeTypeID range) {
 			if (type instanceof RangeTypeID) {
 				RangeTypeID rangeType = (RangeTypeID) type;
-				return match(rangeType.baseType, range.baseType.asArgument());
+				return match(rangeType.baseType, range.baseType);
 			} else {
 				return false;
 			}
 		}
 
 		@Override
-		public Boolean visitModified(ModifiedTypeID type) {
-			if (this.type instanceof ModifiedTypeID) {
-				ModifiedTypeID constType = (ModifiedTypeID) this.type;
-				return match(constType.baseType, new TypeArgument(type.baseType, null));
+		public Boolean visitOptional(OptionalTypeID type) {
+			if (this.type instanceof OptionalTypeID) {
+				OptionalTypeID constType = (OptionalTypeID) this.type;
+				return match(constType.baseType, type.baseType.stored());
 			} else {
 				return false;
 			}
 		}
 		
-		private boolean match(StoredType type, TypeArgument pattern) {
+		private boolean match(StoredType type, StoredType pattern) {
 			if (pattern.storage != null && type.storage != pattern.storage)
 				return false;
 			
-			return TypeMatcher.match(cache, type.asArgument(), pattern) != null;
+			return TypeMatcher.match(cache, type, pattern) != null;
 		}
 		
-		private boolean match(TypeID type, TypeArgument pattern) {
-			return TypeMatcher.match(cache, new TypeArgument(type, null), pattern) != null;
+		private boolean match(TypeID type, StoredType pattern) {
+			return TypeMatcher.match(cache, type.stored(), pattern) != null;
 		}
 
 		@Override

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

 	}
 
 	@Override
-	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
-		return argument(storage);
+	public StoredType instance(GenericMapper mapper, StorageTag storage) {
+		return new StoredType(this, storage);
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/TypeArgument.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.type;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zencode.shared.CompileExceptionCode;
-import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
-import org.openzen.zenscript.codemodel.type.storage.SharedStorageTag;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
-import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class TypeArgument {
-	public static Map<TypeParameter, TypeArgument> getMapping(TypeParameter[] parameters, TypeArgument[] arguments) {
-		Map<TypeParameter, TypeArgument> typeArguments = new HashMap<>();
-		for (int i = 0; i < parameters.length; i++)
-			typeArguments.put(parameters[i], arguments[i]);
-		return typeArguments;
-	}
-	
-	public static Map<TypeParameter, TypeArgument> getSelfMapping(GlobalTypeRegistry registry, TypeParameter[] parameters) {
-		Map<TypeParameter, TypeArgument> typeArguments = new HashMap<>();
-		for (TypeParameter parameter : parameters)
-			typeArguments.put(parameter, new TypeArgument(registry.getGeneric(parameter), parameter.storage));
-		return typeArguments;
-	}
-	
-	public static final TypeArgument[] NONE = new TypeArgument[0];
-	
-	public final TypeID type;
-	public final StorageTag storage; // can be null
-	
-	public TypeArgument(TypeID type, StorageTag storage) {
-		this.type = type;
-		this.storage = storage;
-	}
-	
-	public TypeArgument instance(GenericMapper mapper) {
-		return type.instance(mapper, storage);
-	}
-	
-	public TypeArgument instance(CodePosition position, GenericMapper mapper, StorageTag storage) {
-		if (storage != null && this.storage != null && !storage.equals(this.storage))
-			return new TypeArgument(new InvalidTypeID(position, CompileExceptionCode.INCOMPATIBLE_STORAGE_TAG, "Incompatible storage tag"), null);
-		
-		return type.instance(mapper, storage);
-	}
-	
-	public TypeArgument getNormalized() {
-		return type.getNormalized() == type ? this : new TypeArgument(type, storage);
-	}
-	
-	public StoredType stored() {
-		return new StoredType(type, storage == null ? AutoStorageTag.INSTANCE : storage);
-	}
-	
-	public StoredType stored(StorageTag storage) {
-		return new StoredType(type, storage);
-	}
-	
-	public TypeArgument argument(StorageTag storage) {
-		return storage == null ? this : new TypeArgument(type, storage);
-	}
-	
-	public boolean isBasic(BasicTypeID type) {
-		return this.type == type;
-	}
-	
-	@Override
-	public String toString() {
-		if (storage == null)
-			return type.toString();
-		
-		return type.toString() + "`" + storage.toString();
-	}
-
-	@Override
-	public int hashCode() {
-		int hash = 3;
-		hash = 53 * hash + Objects.hashCode(this.type);
-		hash = 53 * hash + Objects.hashCode(this.storage);
-		return hash;
-	}
-
-	@Override
-	public boolean equals(Object obj) {
-		if (this == obj) {
-			return true;
-		}
-		if (obj == null) {
-			return false;
-		}
-		if (getClass() != obj.getClass()) {
-			return false;
-		}
-		final TypeArgument other = (TypeArgument) obj;
-		return Objects.equals(this.type, other.type)
-				&& Objects.equals(this.storage, other.storage);
-	}
-}

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
-import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 		return null;
 	}
 	
-	TypeArgument instance(GenericMapper mapper, StorageTag storage);
+	StoredType instance(GenericMapper mapper, StorageTag storage);
 	
 	TypeID getNormalized();
 	
 	
 	// Infers type parameters for this type so it matches with targetType
 	// returns false if that isn't possible
-	default Map<TypeParameter, TypeArgument> inferTypeParameters(LocalMemberCache cache, TypeArgument targetType) {
-		return TypeMatcher.match(cache, new TypeArgument(this, null), targetType);
+	default Map<TypeParameter, StoredType> inferTypeParameters(LocalMemberCache cache, StoredType targetType) {
+		return TypeMatcher.match(cache, stored(), targetType);
 	}
 	
 	void extractTypeParameters(List<TypeParameter> typeParameters);
 	}
 	
 	default StoredType stored() {
-		return new StoredType(this, AutoStorageTag.INSTANCE);
-	}
-	
-	default TypeArgument argument(StorageTag storage) {
-		return new TypeArgument(this, storage);
+		return new StoredType(this, null);
 	}
 	
 	default boolean isOptional() {
 		return false;
 	}
 	
-	default boolean isConst() {
-		return false;
-	}
-	
-	default boolean isImmutable() {
-		return false;
-	}
-	
 	default boolean isGeneric() {
 		return false;
 	}
 		throw new UnsupportedOperationException("Not an optional type");
 	}
 	
-	default TypeID withoutConst() {
-		throw new UnsupportedOperationException("Not a const type");
-	}
-	
-	default TypeID withoutImmutable() {
-		throw new UnsupportedOperationException("Not an immutable type");
-	}
-	
 	default boolean isVariant() {
 		return false;
 	}

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

  * @author Hoofdgebruiker
  */
 public class TypeMatcher implements TypeVisitorWithContext<TypeMatcher.Matching, Boolean, RuntimeException> {
-	public static Map<TypeParameter, TypeArgument> match(LocalMemberCache cache, TypeArgument type, TypeArgument pattern) {
+	public static Map<TypeParameter, StoredType> match(LocalMemberCache cache, StoredType type, StoredType pattern) {
 		Matching matching = new Matching(cache, type);
 		if (pattern.type.accept(matching, INSTANCE))
 			return matching.mapping;
 	@Override
 	public Boolean visitGeneric(Matching context, GenericTypeID generic) {
 		if (context.mapping.containsKey(generic.parameter)) {
-			TypeArgument argument = context.mapping.get(generic.parameter);
-			return argument.type == context.type && (argument.storage == null || argument.storage == context.type.storage);
+			StoredType argument = context.mapping.get(generic.parameter);
+			return argument.type == context.type && (argument.getSpecifiedStorage() == null || argument.getSpecifiedStorage() == context.type.getSpecifiedStorage());
 		} else if (context.type.type == generic || generic.matches(context.cache, context.type)) {
 			context.mapping.put(generic.parameter, context.type);
 			return true;
 	}
 
 	@Override
-	public Boolean visitModified(Matching context, ModifiedTypeID type) {
-		if (context.type.type instanceof ModifiedTypeID) {
-			ModifiedTypeID modified = (ModifiedTypeID) context.type.type;
-			return match(context, modified.baseType.argument(null), type.baseType.argument(null));
+	public Boolean visitModified(Matching context, OptionalTypeID type) {
+		if (context.type.type instanceof OptionalTypeID) {
+			OptionalTypeID modified = (OptionalTypeID) context.type.type;
+			return match(context, modified.baseType.stored(), type.baseType.stored());
 		} else {
 			return false;
 		}
 	}
 
-	private boolean match(Matching context, TypeArgument type, TypeArgument pattern) {
-		if (pattern.storage != null && !pattern.storage.equals(type.storage))
+	private boolean match(Matching context, StoredType type, StoredType pattern) {
+		if (pattern.getSpecifiedStorage() != null && !pattern.getSpecifiedStorage().equals(type.getSpecifiedStorage()))
 			return false;
 		
 		return pattern.type.accept(context.withType(type), this);
 	}
-	
-	private boolean match(Matching context, StoredType type, StoredType pattern) {
-		return match(context, type.asArgument(), pattern.asArgument());
-	}
 
 	@Override
 	public Boolean visitGenericMap(Matching context, GenericMapTypeID map) {
 		
 	public static final class Matching {
 		public final LocalMemberCache cache;
-		public final TypeArgument type;
-		public final Map<TypeParameter, TypeArgument> mapping;
+		public final StoredType type;
+		public final Map<TypeParameter, StoredType> mapping;
 		
-		public Matching(LocalMemberCache cache, TypeArgument type) {
+		public Matching(LocalMemberCache cache, StoredType type) {
 			this.cache = cache;
 			this.type = type;
 			mapping = new HashMap<>();
 		}
 		
-		private Matching(LocalMemberCache cache, TypeArgument type, Map<TypeParameter, TypeArgument> mapping) {
+		private Matching(LocalMemberCache cache, StoredType type, Map<TypeParameter, StoredType> mapping) {
 			this.cache = cache;
 			this.type = type;
 			this.mapping = mapping;
 		}
 		
-		public Matching withType(TypeArgument type) {
+		public Matching withType(StoredType type) {
 			return new Matching(cache, type, mapping);
 		}
 	}

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

 
 	@Override
 	public Void visitDefinition(Map<TypeParameter, GenericTypeID> context, DefinitionTypeID definition) {
-		for (TypeArgument argument : definition.typeArguments)
+		for (StoredType argument : definition.typeArguments)
 			argument.type.accept(context, this);
 		if (definition.outer != null)
 			visitDefinition(context, definition.outer);
 	}
 
 	@Override
-	public Void visitModified(Map<TypeParameter, GenericTypeID> context, ModifiedTypeID type) {
+	public Void visitModified(Map<TypeParameter, GenericTypeID> context, OptionalTypeID type) {
 		type.baseType.accept(context, this);
 		return null;
 	}

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

 	}
 	
 	@Override
-	public IPartialExpression getExpression(CodePosition position, BaseScope scope, TypeArgument[] typeArguments) {
+	public IPartialExpression getExpression(CodePosition position, BaseScope scope, StoredType[] typeArguments) {
 		return new PartialTypeExpression(position, scope.getTypeRegistry().getForDefinition(definition, typeArguments), typeArguments);
 	}
 
 	@Override
-	public TypeID getType(CodePosition position, TypeResolutionContext context, TypeArgument[] typeArguments) {
+	public TypeID getType(CodePosition position, TypeResolutionContext context, StoredType[] typeArguments) {
 		return context.getTypeRegistry().getForDefinition(definition, typeArguments);
 	}
 }

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

 	
 	public T visitRange(RangeTypeID range);
 	
-	public T visitModified(ModifiedTypeID type);
+	public T visitOptional(OptionalTypeID type);
 	
 	public default T visitInvalid(InvalidTypeID type) {
 		throw new UnsupportedOperationException("Invalid type: " + type.message);

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

 	
 	R visitRange(C context, RangeTypeID range) throws E;
 	
-	R visitModified(C context, ModifiedTypeID type) throws E;
+	R visitModified(C context, OptionalTypeID type) throws E;
 	
 	default R visitInvalid(C context, InvalidTypeID type) throws E {
 		throw new RuntimeException("Invalid type: " + type.message);

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

 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import static org.openzen.zenscript.codemodel.type.BasicTypeID.*;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
+import org.openzen.zenscript.codemodel.type.OptionalTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.TypeVisitorWithContext;
 import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StaticStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
-import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
 			if (expansion.target == null)
 				throw new RuntimeException(expansion.position.toString() + ": Missing expansion target");
 			
-			Map<TypeParameter, TypeArgument> mapping = matchType(type, expansion.target);
+			Map<TypeParameter, StoredType> mapping = matchType(type, expansion.target);
 			if (mapping == null)
 				continue;
 			
 		}
 	}
 	
-	private Map<TypeParameter, TypeArgument> matchType(StoredType type, TypeArgument pattern) {
+	private Map<TypeParameter, StoredType> matchType(StoredType type, StoredType pattern) {
 		return type.inferTypeParameters(cache, pattern);
 	}
 
 	public Void visitString(Void context, StringTypeID string) {
 		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "string", Modifiers.EXPORT, null);
 		
-		constructor(builtin, STRING_CONSTRUCTOR_CHARACTERS, new StoredType(registry.getModified(ModifiedTypeID.MODIFIER_CONST, registry.getArray(CHAR.stored, 1)), BorrowStorageTag.INVOCATION));
+		constructor(builtin, STRING_CONSTRUCTOR_CHARACTERS, new StoredType(registry.getOptional(registry.getArray(CHAR.stored, 1)), BorrowStorageTag.INVOCATION));
 		
 		add(builtin, STRING_ADD_STRING, StringTypeID.BORROW, StringTypeID.UNIQUE);
 		indexGet(builtin, STRING_INDEXGET, USIZE.stored, CHAR.stored);
 		HighLevelDefinition definition = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT);
 		StoredType baseType = array.elementType;
 		int dimension = array.dimension;
-		StorageTag storage = type.storage;
+		StorageTag storage = type.getActualStorage();
 
 		FunctionParameter[] indexGetParameters = new FunctionParameter[dimension];
 		for (int i = 0; i < indexGetParameters.length; i++)
 	@Override
 	public Void visitGenericMap(Void context, GenericMapTypeID map) {
 		TypeParameter functionParameter = new TypeParameter(BUILTIN, "T");
-		Map<TypeParameter, TypeArgument> parameterFilled = Collections.singletonMap(map.key, new TypeArgument(registry.getGeneric(functionParameter), null));
+		Map<TypeParameter, StoredType> parameterFilled = Collections.singletonMap(map.key, registry.getGeneric(functionParameter).stored());
 		StoredType valueType = map.value.instance(new GenericMapper(registry, parameterFilled));
 		
-		FunctionHeader getOptionalHeader = new FunctionHeader(new TypeParameter[] { functionParameter }, registry.getOptional(valueType.type).stored(valueType.storage), null, null, new FunctionParameter[0]);
+		FunctionHeader getOptionalHeader = new FunctionHeader(
+				new TypeParameter[] { functionParameter },
+				registry.getOptional(valueType.type).stored(valueType.getSpecifiedStorage()),
+				null,
+				null,
+				FunctionParameter.NONE);
 		FunctionHeader putHeader = new FunctionHeader(new TypeParameter[] { functionParameter }, VOID.stored, null, null, new FunctionParameter(valueType));
-		FunctionHeader containsHeader = new FunctionHeader(new TypeParameter[] { functionParameter }, BOOL.stored, null, null, new FunctionParameter[0]);
+		FunctionHeader containsHeader = new FunctionHeader(new TypeParameter[] { functionParameter }, BOOL.stored, null, null, FunctionParameter.NONE);
 		
 		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT);
 		constructor(builtin, GENERICMAP_CONSTRUCTOR);
 		HighLevelDefinition definition = definitionType.definition;
 		GenericMapper mapper = null;
 		if (definitionType.hasTypeParameters() || (definitionType.outer != null && definitionType.outer.hasTypeParameters())) {
-			Map<TypeParameter, TypeArgument> mapping = definitionType.getTypeParameterMapping();
+			Map<TypeParameter, StoredType> mapping = definitionType.getTypeParameterMapping();
 			mapper = new GenericMapper(registry, mapping);
 		}
 		
 			for (int i = 0; i < constValues.length; i++)
 				constValues[i] = new EnumConstantExpression(BUILTIN, definitionType, enumConstants.get(i));
 			
-			constant(definition, ENUM_VALUES, "values", new ArrayExpression(BUILTIN, constValues, registry.getArray(definitionType.stored(ValueStorageTag.INSTANCE), 1).stored(StaticStorageTag.INSTANCE)));
+			constant(definition, ENUM_VALUES, "values", new ArrayExpression(BUILTIN, constValues, registry.getArray(definitionType.stored(), 1).stored(StaticStorageTag.INSTANCE)));
 			compare(definition, ENUM_COMPARE, type);
 			
 			if (!members.canCast(StringTypeID.STATIC)) {
 		if (definition instanceof InterfaceDefinition) {
 			InterfaceDefinition interfaceDefinition = (InterfaceDefinition)definition;
 			for (TypeID baseType : interfaceDefinition.baseInterfaces)
-				cache.get(baseType.instance(mapper, type.storage).stored())
+				cache.get(baseType.instance(mapper, type.getSpecifiedStorage()))
 						.copyMembersTo(definitionType.definition.position, members, TypeMemberPriority.INHERITED);
 		}
 		
 		if (definitionType.superType != null) {
-			cache.get(definitionType.superType.stored(type.storage))
+			cache.get(definitionType.superType.stored(type.getSpecifiedStorage()))
 					.copyMembersTo(definitionType.definition.position, members, TypeMemberPriority.INHERITED);
 		} else {
 			getter(definition, OBJECT_HASHCODE, "objectHashCode", INT.stored);
 	}
 
 	@Override
-	public Void visitModified(Void context, ModifiedTypeID modified) {
+	public Void visitModified(Void context, OptionalTypeID modified) {
 		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "modified", Modifiers.EXPORT, null);
 		modified.baseType.accept(context, this);
 		
 		method(builtin, INT_COUNT_LOW_ONES, "countLowOnes", USIZE.stored);
 		method(builtin, INT_COUNT_HIGH_ONES, "countHighOnes", USIZE.stored);
 		
-		StoredType optionalUSize = registry.getOptional(USIZE).stored(ValueStorageTag.INSTANCE);
+		StoredType optionalUSize = registry.getOptional(USIZE).stored();
 		getter(builtin, INT_HIGHEST_ONE_BIT, "highestOneBit", optionalUSize);
 		getter(builtin, INT_LOWEST_ONE_BIT, "lowestOneBit", optionalUSize);
 		getter(builtin, INT_HIGHEST_ZERO_BIT, "highestZeroBit", optionalUSize);
 		method(builtin, UINT_COUNT_LOW_ONES, "countLowOnes", USIZE.stored);
 		method(builtin, UINT_COUNT_HIGH_ONES, "countHighOnes", USIZE.stored);
 		
-		StoredType optionalUSize = registry.getOptional(USIZE).stored(ValueStorageTag.INSTANCE);
+		StoredType optionalUSize = registry.getOptional(USIZE).stored();
 		getter(builtin, UINT_HIGHEST_ONE_BIT, "highestOneBit", optionalUSize);
 		getter(builtin, UINT_LOWEST_ONE_BIT, "lowestOneBit", optionalUSize);
 		getter(builtin, UINT_HIGHEST_ZERO_BIT, "highestZeroBit", optionalUSize);
 		method(builtin, LONG_COUNT_LOW_ONES, "countLowOnes", USIZE.stored);
 		method(builtin, LONG_COUNT_HIGH_ONES, "countHighOnes", USIZE.stored);
 		
-		StoredType optionalUSize = registry.getOptional(USIZE).stored(ValueStorageTag.INSTANCE);
+		StoredType optionalUSize = registry.getOptional(USIZE).stored();
 		getter(builtin, LONG_HIGHEST_ONE_BIT, "highestOneBit", optionalUSize);
 		getter(builtin, LONG_LOWEST_ONE_BIT, "lowestOneBit", optionalUSize);
 		getter(builtin, LONG_HIGHEST_ZERO_BIT, "highestZeroBit", optionalUSize);
 		method(builtin, ULONG_COUNT_LOW_ONES, "countLowOnes", USIZE.stored);
 		method(builtin, ULONG_COUNT_HIGH_ONES, "countHighOnes", USIZE.stored);
 		
-		StoredType optionalUSize = registry.getOptional(USIZE).stored(ValueStorageTag.INSTANCE);
+		StoredType optionalUSize = registry.getOptional(USIZE).stored();
 		getter(builtin, ULONG_HIGHEST_ONE_BIT, "highestOneBit", optionalUSize);
 		getter(builtin, ULONG_LOWEST_ONE_BIT, "lowestOneBit", optionalUSize);
 		getter(builtin, ULONG_HIGHEST_ZERO_BIT, "highestZeroBit", optionalUSize);
 		method(builtin, USIZE_COUNT_LOW_ONES, "countLowOnes", USIZE.stored);
 		method(builtin, USIZE_COUNT_HIGH_ONES, "countHighOnes", USIZE.stored);
 		
-		StoredType optionalUSize = registry.getOptional(USIZE).stored(ValueStorageTag.INSTANCE);
+		StoredType optionalUSize = registry.getOptional(USIZE).stored();
 		getter(builtin, USIZE_HIGHEST_ONE_BIT, "highestOneBit", optionalUSize);
 		getter(builtin, USIZE_LOWEST_ONE_BIT, "lowestOneBit", optionalUSize);
 		getter(builtin, USIZE_HIGHEST_ZERO_BIT, "highestZeroBit", optionalUSize);

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

 import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
 			
 			if (header.typeParameters != null) {
 				for (StoredType resultHint : typeHints) {
-					Map<TypeParameter, TypeArgument> mapping = header.getReturnType().inferTypeParameters(scope.getMemberCache(), resultHint.asArgument());
+					Map<TypeParameter, StoredType> mapping = header.getReturnType().inferTypeParameters(scope.getMemberCache(), resultHint);
 					if (mapping != null) {
 						header = header.withGenericArguments(scope.getTypeRegistry(), scope.getLocalTypeParameters().getInner(scope.getTypeRegistry(), mapping));
 						break;

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

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.InterfaceCastExpression;
 import org.openzen.zenscript.codemodel.expression.InvalidExpression;
-import org.openzen.zenscript.codemodel.expression.MakeConstExpression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.expression.StorageCastExpression;
 import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 		if (superType != null) {
 			if (superType == other)
 				return true;
-			if (cache.get(superType.stored(type.storage)).extendsOrImplements(other))
+			if (cache.get(superType.stored(type.getActualStorage())).extendsOrImplements(other))
 				return true;
 		}
 		
 		for (TypeMember<ImplementationMemberRef> implementation : implementations) {
 			if (implementation.member.implementsType.equals(other)) // TODO: for some reason duplicate types are generated
 				return true;
-			if (cache.get(implementation.member.implementsType.stored(type.storage)).extendsOrImplements(other))
+			if (cache.get(implementation.member.implementsType.stored(type.getActualStorage())).extendsOrImplements(other))
 				return true;
 		}
 		
 		if (superType != null) {
 			if (superType == other)
 				return true;
-			if (cache.get(superType.stored(type.storage)).extendsType(other))
+			if (cache.get(superType.stored(type.getActualStorage())).extendsType(other))
 				return true;
 		}
 		
 		if (type.type == BasicTypeID.NULL && toType.type.isOptional())
 			return true;
 		
-		if (!type.storage.canCastTo(toType.storage) && !toType.storage.canCastFrom(type.storage))
+		if (!type.getActualStorage().canCastTo(toType.getActualStorage()) && !toType.getActualStorage().canCastFrom(type.getActualStorage()))
 			return false;
 		
 		if (toType.isOptional() && canCastImplicit(toType.withoutOptional()))
 	private boolean areEquivalent(StoredType fromType, StoredType toType) {
 		if (fromType == toType)
 			return true;
-		if (!fromType.storage.canCastTo(toType.storage) && !toType.storage.canCastFrom(fromType.storage))
+		if (!fromType.getActualStorage().canCastTo(toType.getActualStorage()) && !toType.getActualStorage().canCastFrom(fromType.getActualStorage()))
 			return false;
 		
 		return fromType.type == toType.type;
 			return value;
 		
 		if (!(toType.type instanceof StringTypeID))
-			System.out.println(position + ": " + value.type.storage + " -> " + toType.storage);
+			System.out.println(position + ": " + value.type.getActualStorage() + " -> " + toType.getActualStorage());
 		
 		return new StorageCastExpression(position, value, toType);
 	}
 		}
 		for (TypeMember<ImplementationMemberRef> implementation : implementations) {
 			if (implementation.member.implementsType.equals(toType.type))
-				return castEquivalent(position, new InterfaceCastExpression(position, value, toType.type.stored(type.storage)), toType);
+				return castEquivalent(position, new InterfaceCastExpression(position, value, toType.type.stored(type.getActualStorage())), toType);
 		}
 		if (extendsType(toType.type))
 			return new SupertypeCastExpression(position, value, toType);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/BorrowStorageTag.java

 	
 	@Override
 	public String toString() {
-		return "borrow";
+		return this == THIS ? "borrow:this" : "borrow";
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/MutableStorageTag.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.type.storage;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class MutableStorageTag implements StorageTag {
+	public static final MutableStorageTag INVOCATION = new MutableStorageTag();
+	public static final MutableStorageTag THIS = new MutableStorageTag();
+	
+	private MutableStorageTag() {} // TODO: scoped borrow
+
+	@Override
+	public StorageType getType() {
+		return BorrowStorageType.INSTANCE;
+	}
+	
+	@Override
+	public String toString() {
+		return this == THIS ? "mutable:this" : "mutable";
+	}
+
+	@Override
+	public boolean canCastTo(StorageTag other) {
+		return this == other;
+	}
+
+	@Override
+	public boolean canCastFrom(StorageTag other) {
+		return true;
+	}
+
+	@Override
+	public boolean isDestructible() {
+		return false;
+	}
+	
+	@Override
+	public boolean isConst() {
+		return true;
+	}
+	
+	@Override
+	public boolean isImmutable() {
+		return true;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/MutableStorageType.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.type.storage;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileExceptionCode;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class MutableStorageType implements StorageType {
+	public static final MutableStorageType INSTANCE = new MutableStorageType();
+
+	private MutableStorageType() {}
+
+	@Override
+	public String getName() {
+		return "mutable";
+	}
+
+	@Override
+	public StorageTag instance(CodePosition position, String[] arguments) {
+		if (arguments.length > 0) {
+			if (arguments.length == 1 && arguments[0].equals("this"))
+				return MutableStorageTag.THIS;
+			
+			return new InvalidStorageTag(position, CompileExceptionCode.INVALID_STORAGE_TYPE_ARGUMENTS, "mutable storage type doesn't take arguments");
+		}
+		
+		return MutableStorageTag.INVOCATION;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/StorageTag.java

 		if (major == AutoStorageTag.INSTANCE || major == null)
 			return minor;
 		if (!minor.equals(major))
-			throw new IllegalArgumentException("Could not unite storage types"); // TODO: proper reporting
+			throw new IllegalArgumentException("Could not unite storage types: " + minor + " and " + major); // TODO: proper reporting
 		
 		return major;
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/StorageType.java

 		return new StorageType[] {
 			AutoStorageType.INSTANCE,
 			BorrowStorageType.INSTANCE,
+			MutableStorageType.INSTANCE,
 			SharedStorageType.INSTANCE,
 			StaticStorageType.INSTANCE,
 			UniqueStorageType.INSTANCE

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/ValueStorageTag.java

 	public boolean isImmutable() {
 		return false;
 	}
+	
+	@Override
+	public String toString() {
+		return "value";
+	}
 }

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

 	}
 
 	@Override
-	public Void visitModified(StoredType context, ModifiedTypeID type) {
+	public Void visitModified(StoredType context, OptionalTypeID type) {
 		//NO-OP
 		return null;
 	}

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

 		expression.value.accept(this);
 		
 		if (expression.type.isDestructible()) { // only destructible types matter here; nondestructible types never need conversion
-			StorageTag fromTag = expression.value.type.storage;
-			StorageTag toTag = expression.type.storage;
+			StorageTag fromTag = expression.value.type.getActualStorage();
+			StorageTag toTag = expression.type.getActualStorage();
 			if (JavaTypeUtils.isShared(fromTag) && toTag == BorrowStorageTag.INVOCATION) {
 				// Shared<T>.get()
 				javaWriter.invokeVirtual(SHARED_GET);

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

 import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
+import org.openzen.zenscript.codemodel.type.OptionalTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
 	}
 
 	@Override
-	public String visitModified(StoredType context, ModifiedTypeID type) {
+	public String visitModified(StoredType context, OptionalTypeID type) {
 		StringBuilder result = new StringBuilder();
-		if (type.isConst())
-			result.append("Const");
-		if (type.isImmutable())
-			result.append("Immutable");
 		if (type.isOptional())
 			result.append("Optional");
 		

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

     }
 
     @Override
-    public String visitModified(ModifiedTypeID modified) {
-		if (modified.isOptional())
-			return modified.withoutOptional().accept(forOptional);
-		
-		return modified.baseType.accept(this);
+    public String visitOptional(OptionalTypeID modified) {
+		return modified.withoutOptional().accept(forOptional);
     }
 
 	@Override

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

 
 		if (definition.typeArguments.length > 0) {
 			builder.append("<");
-			for (TypeArgument typeParameter : definition.typeArguments) {
+			for (StoredType typeParameter : definition.typeArguments) {
 				builder.append(typeParameter.type.accept(null, this));
 			}
 			builder.append(">");
 	}
 
 	@Override
-	public String visitModified(StoredType context, ModifiedTypeID type) {
+	public String visitModified(StoredType context, OptionalTypeID type) {
 		return type.baseType.accept(context, this);
 	}
 }

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

 import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
+import org.openzen.zenscript.codemodel.type.OptionalTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
 		}
 
 		@Override
-		public JavaTypeInfo visitModified(StoredType context, ModifiedTypeID type) {
+		public JavaTypeInfo visitModified(StoredType context, OptionalTypeID type) {
 			return type.baseType.accept(null, this);
 		}
 	}

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

     }
 
     @Override
-    public String visitModified(StoredType context, ModifiedTypeID modified) {
+    public String visitModified(StoredType context, OptionalTypeID modified) {
 		if (modified.isOptional())
 			return modified.withoutOptional().accept(context, forOptional);
 		

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

 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
+import org.openzen.zenscript.codemodel.type.OptionalTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 	}
 
 	@Override
-	public String visitModified(StoredType context, ModifiedTypeID type) {
+	public String visitModified(StoredType context, OptionalTypeID type) {
 		StringBuilder result = new StringBuilder();
-		if (type.isConst())
-			result.append("Const");
 		if (type.isOptional())
 			result.append("Optional");
-		if (type.isImmutable())
-			result.append("Immutable");
 		result.append(type.baseType.accept(context, this));
 		return result.toString();
 	}

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

 	private JavaTypeUtils() {}
 	
 	public static boolean isShared(StoredType type) {
-		return type.type.isDestructible() && isShared(type.storage);
+		return type.type.isDestructible() && isShared(type.getActualStorage());
 	}
 	
 	public static boolean isShared(StorageTag storage) {

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

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
+import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.formattershared.ExpressionString;
 import org.openzen.zenscript.formattershared.StatementFormattingTarget;
 import org.openzen.zenscript.javasource.scope.JavaSourceStatementScope;
 			result.append("<");
 			
 			int index = 0;
-			for (TypeArgument typeArgument : arguments.typeArguments) {
+			for (StoredType typeArgument : arguments.typeArguments) {
 				if (index > 0)
 					result.append(", ");
 				result.append(scope.type(typeArgument));
 			result.append("<");
 			
 			int index = 0;
-			for (TypeArgument typeArgument : arguments.typeArguments) {
+			for (StoredType typeArgument : arguments.typeArguments) {
 				if (index > 0)
 					result.append(", ");
 				result.append(scope.type(typeArgument));

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

 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
+import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.compiler.CompileScope;
 import org.openzen.zenscript.compiler.SemanticModule;
 	
 	private void compileMembers(JavaSourceFileScope scope, HighLevelDefinition definition) {
 		if (definition.hasTag(JavaNativeClass.class)) {
-			TypeArgument[] typeParameters = new TypeArgument[definition.getNumberOfGenericParameters()];
+			StoredType[] typeParameters = new StoredType[definition.getNumberOfGenericParameters()];
 			for (int i = 0; i < typeParameters.length; i++)
-				typeParameters[i] = new TypeArgument(scope.semanticScope.getTypeRegistry().getGeneric(definition.typeParameters[i]), definition.typeParameters[i].storage);
+				typeParameters[i] = scope.semanticScope.getTypeRegistry().getGeneric(definition.typeParameters[i]).stored(definition.typeParameters[i].storage);
 			TypeID targetType = scope.semanticScope.getTypeRegistry().getForDefinition(definition, typeParameters);
 			
 			JavaExpansionMemberCompiler memberCompiler = new JavaExpansionMemberCompiler(settings, targetType, definition.typeParameters, indent + settings.indent, output, scope, definition);

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

 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 	public ExpressionString visitStorageCast(StorageCastExpression expression) {
 		ExpressionString value = expression.accept(this);
 		if (expression.value.type.isDestructible()) {
-			StorageTag fromTag = expression.value.type.storage;
-			StorageTag toTag = expression.type.storage;
+			StorageTag fromTag = expression.value.type.getActualStorage();
+			StorageTag toTag = expression.type.getActualStorage();
 			if (JavaTypeUtils.isShared(fromTag)) {
 				// Shared<T>.get()
 				return value.unaryPostfix(JavaOperator.CALL, ".get()");
 		return expression.value.accept(this);
 	}
 	
-	private String formatTypeArguments(TypeArgument[] types) {
+	private String formatTypeArguments(StoredType[] types) {
 		if (types == null || types.length == 0)
 			return "";
 		
 		output.append(method).append("(");
 		boolean first = true;
 		if (expression.arguments.typeArguments != null) {
-			for (TypeArgument typeArgument : expression.arguments.typeArguments) {
+			for (StoredType typeArgument : expression.arguments.typeArguments) {
 				if (!first)
 					output.append(", ");
 				

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

 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
+import org.openzen.zenscript.codemodel.type.OptionalTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 		}
 
 		@Override
-		public ArrayKind visitModified(ModifiedTypeID type) {
+		public ArrayKind visitOptional(OptionalTypeID type) {
 			return ArrayKind.OBJECT;
 		}
 	}

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

 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
+import org.openzen.zenscript.codemodel.type.OptionalTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 	}
 
 	@Override
-	public String visitModified(ModifiedTypeID optional) {
-		if (optional.isOptional() && optional.withoutOptional() == BasicTypeID.USIZE)
+	public String visitOptional(OptionalTypeID optional) {
+		if (optional.withoutOptional() == BasicTypeID.USIZE)
 			return "int"; // usize? is an int
 		
 		return optional.baseType.accept(new JavaSourceObjectTypeVisitor(importer, context));

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/scope/JavaSourceStatementScope.java

 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.statement.VariableID;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.formattershared.ExpressionString;
 import org.openzen.zenscript.formattershared.StatementFormattingTarget;
 		return fileScope.type(type);
 	}
 	
-	public String type(TypeArgument type) {
-		return type.storage == null ? type(type.type) : type(type.stored());
-	}
-	
 	public String type(TypeID type) {
 		return fileScope.type(type);
 	}

ModuleDeserializer/src/main/java/org/openzen/zenscript/moduledeserializer/CodeReader.java

 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
+import org.openzen.zenscript.codemodel.type.OptionalTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.codemodel.type.TypeID;
 			case TypeEncoding.TYPE_OPTIONAL:
 				return registry.getOptional(deserializeTypeID(context));
 			case TypeEncoding.TYPE_CONST:
-				return registry.getModified(ModifiedTypeID.MODIFIER_CONST, deserializeTypeID(context));
+				return registry.getModified(OptionalTypeID.MODIFIER_CONST, deserializeTypeID(context));
 			case TypeEncoding.TYPE_IMMUTABLE:
-				return registry.getModified(ModifiedTypeID.MODIFIER_IMMUTABLE, deserializeTypeID(context));
+				return registry.getModified(OptionalTypeID.MODIFIER_IMMUTABLE, deserializeTypeID(context));
 			default:
 				throw new IllegalArgumentException("Unknown type: " + type);
 		}
 			}
 			case ExpressionEncoding.TYPE_MAKE_CONST: {
 				Expression value = deserializeExpression(context);
-				StoredType constType = registry.getModified(ModifiedTypeID.MODIFIER_CONST, value.type.type).stored(value.type.storage);
+				StoredType constType = registry.getModified(OptionalTypeID.MODIFIER_CONST, value.type.type).stored(value.type.getActualStorage());
 				return new MakeConstExpression(position, value, constType);
 			}
 			case ExpressionEncoding.TYPE_MAP: {
 			}
 			case ExpressionEncoding.TYPE_WRAP_OPTIONAL: {
 				Expression value = deserializeExpression(context);
-				StoredType optionalType = registry.getOptional(value.type.type).stored(value.type.storage);
+				StoredType optionalType = registry.getOptional(value.type.type).stored(value.type.getActualStorage());
 				return new WrapOptionalExpression(position, value, optionalType);
 			}
 			default:

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/encoder/TypeSerializer.java

 import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
+import org.openzen.zenscript.codemodel.type.OptionalTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
 	}
 
 	@Override
-	public Void visitModified(TypeContext context, ModifiedTypeID type) {
+	public Void visitModified(TypeContext context, OptionalTypeID type) {
 		if (type.isOptional()) {
 			output.writeUInt(TypeEncoding.TYPE_OPTIONAL);
 			type.withoutOptional().accept(context, this);

Parser/src/main/java/org/openzen/zenscript/parser/ParsedAnnotation.java

 import org.openzen.zenscript.parser.type.IParsedType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.annotations.ParameterAnnotation;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
+import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
 		try {
 			AnnotationDefinition annotationType = type.compileAnnotation(scope);
 			ExpressionScope evalScope = annotationType.getScopeForMember(member, scope);
-			TypeArgument[] types = type.compileTypeArguments(scope);
+			StoredType[] types = type.compileTypeArguments(scope);
 			CallArguments cArguments = arguments.compileCall(position, evalScope, types, annotationType.getInitializers(scope));
 			return annotationType.createForMember(position, cArguments);
 		} catch (CompileException ex) {
 		
 		try {
 			ExpressionScope evalScope = annotationType.getScopeForType(definition, scope);
-			TypeArgument[] types = type.compileTypeArguments(scope);
+			StoredType[] types = type.compileTypeArguments(scope);
 			CallArguments cArguments = arguments.compileCall(position, evalScope, types, annotationType.getInitializers(scope));
 			return annotationType.createForDefinition(position, cArguments);
 		} catch (CompileException ex) {
 		
 		try {
 			ExpressionScope evalScope = annotationType.getScopeForStatement(statement, scope);
-			TypeArgument[] types = type.compileTypeArguments(scope);
+			StoredType[] types = type.compileTypeArguments(scope);
 			CallArguments cArguments = arguments.compileCall(position, evalScope, types, annotationType.getInitializers(scope));
 			return annotationType.createForStatement(position, cArguments);
 		} catch (CompileException ex) {
 		
 		try {
 			ExpressionScope evalScope = annotationType.getScopeForParameter(header, parameter, scope);
-			TypeArgument[] types = type.compileTypeArguments(scope);
+			StoredType[] types = type.compileTypeArguments(scope);
 			CallArguments cArguments = arguments.compileCall(position, evalScope, types, annotationType.getInitializers(scope));
 			return annotationType.createForParameter(position, cArguments);
 		} catch (CompileException ex) {

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedEnum.java

 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
+import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
 	public void compile(BaseScope scope) throws CompileException {
 		super.compile(scope);
 		
-		DefinitionTypeID type = scope.getTypeRegistry().getForDefinition(compiled, TypeArgument.NONE);
+		DefinitionTypeID type = scope.getTypeRegistry().getForDefinition(compiled, StoredType.NONE);
 		ExpressionScope evalScope = new ExpressionScope(scope);
 		for (ParsedEnumConstant constant : enumValues) {
 			constant.compileCode(type, evalScope);

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedEnumConstant.java

 	
 	public void compileCode(DefinitionTypeID type, ExpressionScope scope) throws CompileException {
 		ParsedCallArguments arguments = new ParsedCallArguments(null, this.arguments);
-		compiled.constructor = (NewExpression)ParsedNewExpression.compile(position, type.stored(ValueStorageTag.INSTANCE), arguments, scope);
+		compiled.constructor = (NewExpression)ParsedNewExpression.compile(position, type.stored(), arguments, scope);
 		
 		if (value != null)
 			compiled.value = value.compile(scope).eval();

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedExpansion.java

 	@Override
 	public void linkTypesLocal(TypeResolutionContext context) {
 		ParsedTypeParameter.compile(context, compiled.typeParameters, this.parameters);
-		compiled.target = target.compileArgument(context);
+		compiled.target = target.compile(context);
 		if (compiled.target == null)
 			throw new RuntimeException(position + ": Could not compile expansion target: " + target);
 		

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

 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.type.IParsedType;
 
 	public CallArguments compileCall(
 			CodePosition position, 
 			ExpressionScope scope,
-			TypeArgument[] genericParameters,
+			StoredType[] genericParameters,
 			TypeMemberGroup member) throws CompileException
 	{
 		List<FunctionHeader> possibleHeaders = member.getMethodMembers().stream()
 	public CallArguments compileCall(
 			CodePosition position,
 			ExpressionScope scope,
-			TypeArgument[] typeArguments,
+			StoredType[] typeArguments,
 			List<FunctionHeader> candidateFunctions) throws CompileException
 	{
 		if (this.typeArguments != null) {
-			typeArguments = new TypeArgument[this.typeArguments.size()];
+			typeArguments = new StoredType[this.typeArguments.size()];
 			for (int i = 0; i < this.typeArguments.size(); i++)
-				typeArguments[i] = this.typeArguments.get(i).compileArgument(scope);
+				typeArguments[i] = this.typeArguments.get(i).compile(scope);
 		}
 		
 		List<FunctionHeader> candidates = new ArrayList<>();
 			cArguments[i] = cArgument.eval();
 		}
 		
-		TypeArgument[] typeArguments2 = typeArguments;
+		StoredType[] typeArguments2 = typeArguments;
 		if (typeArguments2 == null || typeArguments2.length == 0) {
 			for (FunctionHeader candidate : candidates) {
 				if (candidate.typeParameters != null) {
-					typeArguments2 = new TypeArgument[candidate.typeParameters.length];
+					typeArguments2 = new StoredType[candidate.typeParameters.length];
 					for (int i = 0; i < typeArguments2.length; i++) {
 						if (innerScope.genericInferenceMap.get(candidate.typeParameters[i]) == null)
-							typeArguments2[i] = new TypeArgument(new InvalidTypeID(position, CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE, "Could not infer type parameter " + candidate.typeParameters[i].name), null);
+							typeArguments2[i] = new InvalidTypeID(position, CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE, "Could not infer type parameter " + candidate.typeParameters[i].name).stored();
 						else
 							typeArguments2[i] = innerScope.genericInferenceMap.get(candidate.typeParameters[i]);
 					}
 	public CallArguments compileCall(
 			CodePosition position,
 			ExpressionScope scope,
-			TypeArgument[] typeArguments,
+			StoredType[] typeArguments,
 			FunctionHeader function) throws CompileException
 	{
 		ExpressionScope innerScope = scope.forCall(function);
 			cArguments[i] = cArgument.eval();
 		}
 		
-		TypeArgument[] typeArguments2 = typeArguments;
+		StoredType[] typeArguments2 = typeArguments;
 		if (typeArguments2 == null) {
 			if (function.typeParameters != null) {
-				typeArguments2 = new TypeArgument[function.typeParameters.length];
+				typeArguments2 = new StoredType[function.typeParameters.length];
 				for (int i = 0; i < typeArguments2.length; i++) {
 					if (innerScope.genericInferenceMap.get(function.typeParameters[i]) == null)
 						throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE, "Could not infer type parameter " + function.typeParameters[i].name);
 			IPartialExpression cArgument = arguments.get(i).compile(scope);
 			cArguments[i] = cArgument.eval();
 		}
-		return new CallArguments(TypeArgument.NONE, cArguments);
+		return new CallArguments(StoredType.NONE, cArguments);
 	}
 	
-	private boolean isCompatibleWith(BaseScope scope, FunctionHeader header, TypeArgument[] typeArguments) {
+	private boolean isCompatibleWith(BaseScope scope, FunctionHeader header, StoredType[] typeArguments) {
 		if (arguments.size() != header.parameters.length)
 			return false;
 		

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

 		
 		TypeMembers resultTypeMembers = scope.getTypeMembers(resultType);
 		resultType = resultTypeMembers.union(cRight.type);
-		cLeft = cLeft.castImplicit(position, scope, resultType.isOptional() ? resultType : scope.getTypeRegistry().getOptional(resultType.type).stored(resultType.storage));
+		cLeft = cLeft.castImplicit(position, scope, resultType.isOptional() ? resultType : scope.getTypeRegistry().getOptional(resultType.type).stored(resultType.getSpecifiedStorage()));
 		cRight = cRight.castImplicit(position, scope, resultType);
 		
 		return new CoalesceExpression(position, cLeft, cRight);

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

 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
 				if (method != null) {
 					try {
 						ParsedCallArguments parsedArguments = new ParsedCallArguments(Collections.emptyList(), Collections.singletonList(new ParsedExpressionFloat(position, value)));
-						CallArguments arguments = parsedArguments.compileCall(position, scope, TypeArgument.NONE, method.getHeader());
+						CallArguments arguments = parsedArguments.compileCall(position, scope, StoredType.NONE, method.getHeader());
 						method.callStatic(position, hint.type, method.getHeader(), arguments, scope);
 					} catch (CompileException ex) {
 						return new InvalidExpression(hint, ex);

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

 import org.openzen.zenscript.codemodel.scope.StatementScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 						return new InvalidExpression(position, hint, CompileExceptionCode.MULTIPLE_MATCHING_HINTS, "Ambiguity trying to resolve function types, can't decide for the type");
 					
 					header = functionHint.header.forLambda(definedHeader);
-					storage = hint.storage;
+					storage = hint.getActualStorage();
 				}
 			}
 		}
 		if (!scope.genericInferenceMap.isEmpty()) {
 			// perform type parameter inference
 			StoredType returnType = statements.getReturnType();
-			Map<TypeParameter, TypeArgument> inferredTypes = returnType.type.inferTypeParameters(scope.getMemberCache(), genericHeader.getReturnType().asArgument());
+			Map<TypeParameter, StoredType> inferredTypes = returnType.type.inferTypeParameters(scope.getMemberCache(), genericHeader.getReturnType());
 			if (inferredTypes == null)
 				throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE, "Could not infer generic type parameters");
 			

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

 import org.openzen.zenscript.codemodel.type.member.TypeMemberGroup;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 
 /**
  *
 		}
 
 		@Override
-		public TypeArgument[] getTypeArguments() {
+		public StoredType[] getTypeArguments() {
 			return null;
 		}
 	}

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

 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
 				if (method != null) {
 					try {
 						ParsedCallArguments parsedArguments = new ParsedCallArguments(Collections.emptyList(), Collections.singletonList(new ParsedExpressionInt(position, negative, value, "")));
-						CallArguments arguments = parsedArguments.compileCall(position, scope, TypeArgument.NONE, method.getHeader());
+						CallArguments arguments = parsedArguments.compileCall(position, scope, StoredType.NONE, method.getHeader());
 						method.callStatic(position, hint.type, method.getHeader(), arguments, scope);
 					} catch (CompileException ex) {
 						return new InvalidExpression(hint, ex);

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

 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
+import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.parser.type.IParsedType;
 
 	@Override
 	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		IPartialExpression cValue = value.compile(scope.withoutHints());
-		TypeArgument[] typeArguments = IParsedType.compileArguments(genericParameters, scope);
+		StoredType[] typeArguments = IParsedType.compileTypes(genericParameters, scope);
 		IPartialExpression member = cValue.getMember(
 				position,
 				scope,

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

 		Expression to = this.to.compile(scope.withHints(toHints)).eval();
 		
 		StoredType baseType = scope.getTypeMembers(from.type).union(to.type);
-		return new RangeExpression(position, scope.getTypeRegistry().getRange(baseType).stored(baseType.storage), from, to);
+		return new RangeExpression(position, scope.getTypeRegistry().getRange(baseType).stored(baseType.getSpecifiedStorage()), from, to);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionParameter;
 
 	@Override
 	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
-		TypeArgument[] typeArguments = IParsedType.compileArguments(this.typeArguments, scope);
+		StoredType[] typeArguments = IParsedType.compileTypes(this.typeArguments, scope);
 		IPartialExpression result = scope.get(position, new GenericName(name, typeArguments));
 		if (result == null) {
 			for (StoredType hint : scope.hints) {

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

 		HighLevelDefinition result = scope.getTypeRegistry().stdlib.getDefinition("Result");
 		if (cValue.thrownType != null) {
 			// this function throws
-			DefinitionTypeID resultType = scope.getTypeRegistry().getForDefinition(result, cValue.type.asArgument(), cValue.thrownType.asArgument());
-			return new TryConvertExpression(position, resultType.stored(cValue.type.storage), cValue);
+			DefinitionTypeID resultType = scope.getTypeRegistry().getForDefinition(result, cValue.type, cValue.thrownType);
+			return new TryConvertExpression(position, resultType.stored(cValue.type.getActualStorage()), cValue);
 		} else {
 			throw new CompileException(position, CompileExceptionCode.TRY_CONVERT_ILLEGAL_TARGET, "try? can only be used on expressions that throw");
 		}

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

 				return new TryRethrowAsExceptionExpression(position, cSource.type, cSource, cSource.thrownType);
 			} else {
 				// rethrow as result
-				StoredType resultType = scope.getTypeRegistry().getForDefinition(result, cSource.type.asArgument(), cSource.thrownType.asArgument()).stored(cSource.thrownType.storage);
+				StoredType resultType = scope.getTypeRegistry().getForDefinition(result, cSource.type, cSource.thrownType).stored(cSource.thrownType.getSpecifiedStorage());
 				return new TryRethrowAsResultExpression(position, resultType, cSource);
 			}
 		} else {
 			if (cSource.type.type instanceof DefinitionTypeID) {
 				DefinitionTypeID sourceType = (DefinitionTypeID)cSource.type.type;
 				if (sourceType.definition == result) {
-					return new TryRethrowAsResultExpression(position, sourceType.typeArguments[0].stored(), cSource);
+					return new TryRethrowAsResultExpression(position, sourceType.typeArguments[0], cSource);
 				}
 			}
 			

Parser/src/main/java/org/openzen/zenscript/parser/member/ParsedSetter.java

 	
 	private void inferHeaders(BaseScope scope) throws CompileException {
 		if ((implementation != null && !Modifiers.isPrivate(modifiers))) {
-			fillOverride(scope, implementation.getCompiled().type.stored(scope.getThisType().storage));
+			fillOverride(scope, implementation.getCompiled().type.stored(scope.getThisType().getSpecifiedStorage()));
 			compiled.modifiers |= Modifiers.PUBLIC;
 		} else if (implementation == null && Modifiers.isOverride(modifiers)) {
 			if (definition.getSuperType() == null)
 				throw new CompileException(position, CompileExceptionCode.OVERRIDE_WITHOUT_BASE, "Override specified without base type");
 			
-			fillOverride(scope, definition.getSuperType().stored(scope.getThisType().storage));
+			fillOverride(scope, definition.getSuperType().stored(scope.getThisType().getSpecifiedStorage()));
 		}
 		
 		if (compiled == null)

Parser/src/main/java/org/openzen/zenscript/parser/type/IParsedType.java

 import org.openzen.zenscript.lexer.ZSTokenType;
 import static org.openzen.zenscript.lexer.ZSTokenType.*;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 import org.openzen.zenscript.parser.definitions.ParsedTypeParameter;
 	
 	public static IParsedType tryParse(ZSTokenParser tokens) throws ParseException {
 		CodePosition position = tokens.getPosition();
-		int modifiers = 0;
-		while (true) {
-			if (tokens.optional(ZSTokenType.K_CONST) != null) {
-				modifiers |= ModifiedTypeID.MODIFIER_CONST;
-			} else if (tokens.optional(ZSTokenType.K_IMMUTABLE) != null) {
-				modifiers |= ModifiedTypeID.MODIFIER_IMMUTABLE;
-			} else {
-				break;
-			}
-		}
 		
 		IParsedType result;
 		switch (tokens.peek().type) {
 			case K_STRING: {
 				tokens.next();
 				ParsedStorageTag storage = ParsedStorageTag.parse(tokens);
-				result = new ParsedString(position, modifiers, storage);
+				result = new ParsedString(position, storage);
 				break;
 			}
 			case K_FUNCTION: {
 						tokens.required(T_GREATER, "> expected");
 						tokens.required(ZSTokenType.T_SQCLOSE, "] expected");
 						ParsedStorageTag storage = ParsedStorageTag.parse(tokens);
-						result = new ParsedTypeGenericMap(position, parameter, result, modifiers, storage);
+						result = new ParsedTypeGenericMap(position, parameter, result, storage);
 					} else {
 						IParsedType keyType = parse(tokens);
 						tokens.required(ZSTokenType.T_SQCLOSE, "] expected");
 					break;
 				case T_QUEST:
 					tokens.next();
-					result = result.withOptional();
+					result = new ParsedOptionalType(result);
 					break;
 				default:
 					break outer;
 			}
 		}
 		
-		if (modifiers > 0)
-			result = result.withModifiers(modifiers);
-		
 		return result;
 	}
 	
 		return result;
 	}
 	
-	public static TypeArgument[] compileArguments(List<IParsedType> typeParameters, TypeResolutionContext context) {
-		TypeArgument[] result = TypeArgument.NONE;
+	public static StoredType[] compileTypes(List<IParsedType> typeParameters, TypeResolutionContext context) {
+		StoredType[] result = StoredType.NONE;
 		if (typeParameters != null && typeParameters.size() > 0) {
-			result = new TypeArgument[typeParameters.size()];
+			result = new StoredType[typeParameters.size()];
 			for (int i = 0; i < typeParameters.size(); i++) {
-				result[i] = typeParameters.get(i).compileArgument(context);
+				result[i] = typeParameters.get(i).compile(context);
 			}
 		}
 		return result;
 	}
 	
-	public IParsedType withOptional();
-	
-	public IParsedType withModifiers(int modifiers);
-	
 	public StoredType compile(TypeResolutionContext context);
 	
 	public TypeID compileUnstored(TypeResolutionContext context);
 	
-	public TypeArgument compileArgument(TypeResolutionContext context);
-	
 	public default AnnotationDefinition compileAnnotation(BaseScope scope) {
 		return null;
 	}
 	
-	public default TypeArgument[] compileTypeArguments(BaseScope scope) {
-		return TypeArgument.NONE;
+	public default StoredType[] compileTypeArguments(BaseScope scope) {
+		return StoredType.NONE;
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedFunctionType.java

 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 import org.openzen.zenscript.codemodel.type.TypeID;
-import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
 
 /**
  *
  */
 public class ParsedFunctionType implements IParsedType {
 	private final CodePosition position;
-	private final int modifiers;
 	private final ParsedFunctionHeader header;
 	private final ParsedStorageTag storage;
 	
 	public ParsedFunctionType(CodePosition position, ParsedFunctionHeader header, ParsedStorageTag storage) {
 		this.position = position;
 		this.header = header;
-		this.modifiers = 0;
 		this.storage = storage;
 	}
-	
-	private ParsedFunctionType(CodePosition position, ParsedFunctionHeader header, int modifiers, ParsedStorageTag storageTag) {
-		this.position = position;
-		this.header = header;
-		this.modifiers = modifiers;
-		this.storage = storageTag;
-	}
-	
-	@Override
-	public IParsedType withOptional() {
-		return new ParsedFunctionType(position, header, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL, storage);
-	}
-
-	@Override
-	public IParsedType withModifiers(int modifiers) {
-		return new ParsedFunctionType(position, header, modifiers | this.modifiers, storage);
-	}
 
 	@Override
 	public StoredType compile(TypeResolutionContext context) {
-		StorageTag storage = this.storage == ParsedStorageTag.NULL ? AutoStorageTag.INSTANCE : this.storage.resolve(position, context);
-		return context.getTypeRegistry().getModified(modifiers, context.getTypeRegistry().getFunction(header.compile(context))).stored(storage);
+		StorageTag storage = this.storage.resolve(position, context);
+		return context.getTypeRegistry().getFunction(header.compile(context)).stored(storage);
 	}
 	
 	@Override
 		if (storage != ParsedStorageTag.NULL)
 			return new InvalidTypeID(position, CompileExceptionCode.STORAGE_NOT_SUPPORTED, "Storage tag not supported here");
 		
-		return context.getTypeRegistry().getModified(modifiers, context.getTypeRegistry().getFunction(header.compile(context)));
-	}
-
-	@Override
-	public TypeArgument compileArgument(TypeResolutionContext context) {
-		StorageTag storage = this.storage == ParsedStorageTag.NULL ? null : this.storage.resolve(position, context);
-		return new TypeArgument(context.getTypeRegistry().getModified(modifiers, context.getTypeRegistry().getFunction(header.compile(context))), storage);
+		return context.getTypeRegistry().getFunction(header.compile(context));
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedNamedType.java

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.TypeID;
-import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
-import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
  */
 public class ParsedNamedType implements IParsedType {
 	private final CodePosition position;
-	private final int modifiers;
 	public final List<ParsedNamePart> name;
 	private final ParsedStorageTag storage;
 	
 	public ParsedNamedType(CodePosition position, List<ParsedNamePart> name, ParsedStorageTag storage) {
 		this.position = position;
-		this.modifiers = 0;
-		this.name = name;
-		this.storage = storage;
-	}
-	
-	private ParsedNamedType(CodePosition position, int modifiers, List<ParsedNamePart> name, ParsedStorageTag storage) {
-		this.position = position;
-		this.modifiers = modifiers;
 		this.name = name;
 		this.storage = storage;
 	}
 		for (ParsedNamePart namePart : name)
 			genericNames.add(namePart.compile(context));
 		
-		TypeID baseType = context.getType(position, genericNames);
-		if (baseType == null)
-			return new InvalidTypeID(position, CompileExceptionCode.NO_SUCH_TYPE, "Type not found: " + toString()).stored(ValueStorageTag.INSTANCE);
-		
-		TypeID result = context.getTypeRegistry().getModified(modifiers, baseType);
+		TypeID result = context.getType(position, genericNames);
 		if (result == null)
-			return new InvalidTypeID(position, CompileExceptionCode.NO_SUCH_TYPE, "Type not found: " + toString()).stored(ValueStorageTag.INSTANCE);
+			return new InvalidTypeID(position, CompileExceptionCode.NO_SUCH_TYPE, "Type not found: " + toString()).stored();
 		
-		StorageTag storage;
-		if (this.storage == ParsedStorageTag.NULL) {
-			storage = AutoStorageTag.INSTANCE;
-		} else {
-			storage = this.storage.resolve(position, context);
-		}
-		return result.stored(storage);
+		return result.stored(storage.resolve(position, context));
 	}
 	
 	@Override
 		return compile(context).type;
 	}
 	
-	@Override
-	public TypeArgument compileArgument(TypeResolutionContext context) {
-		if (name.size() == 1 && name.get(0).name.equals("Iterator"))
-			return toIterator(context).asArgument();
-		
-		List<GenericName> genericNames = new ArrayList<>();
-		for (ParsedNamePart namePart : name)
-			genericNames.add(namePart.compile(context));
-		
-		TypeID baseType = context.getType(position, genericNames);
-		if (baseType == null)
-			return new TypeArgument(new InvalidTypeID(position, CompileExceptionCode.NO_SUCH_TYPE, "Type not found: " + toString()), null);
-		
-		TypeID result = context.getTypeRegistry().getModified(modifiers, baseType);
-		if (result == null)
-			return new TypeArgument(new InvalidTypeID(position, CompileExceptionCode.NO_SUCH_TYPE, "Type not found: " + toString()), null);
-		
-		StorageTag storage;
-		if (this.storage == ParsedStorageTag.NULL) {
-			storage = null;
-		} else {
-			storage = this.storage.resolve(position, context);
-		}
-		return new TypeArgument(result, storage);
-	}
-	
-	@Override
-	public IParsedType withOptional() {
-		return new ParsedNamedType(position, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL, name, storage);
-	}
-	
-	@Override
-	public IParsedType withModifiers(int modifiers) {
-		return new ParsedNamedType(position, this.modifiers | modifiers, name, storage);
-	}
-	
 	@Override
 	public String toString() {
 		StringBuilder nameTotal = new StringBuilder();
 	}
 	
 	@Override
-	public TypeArgument[] compileTypeArguments(BaseScope scope) {
+	public StoredType[] compileTypeArguments(BaseScope scope) {
 		ParsedNamePart last = name.get(name.size() - 1);
-		return IParsedType.compileArguments(last.typeArguments, scope);
+		return IParsedType.compileTypes(last.typeArguments, scope);
 	}
 	
 	private StoredType toIterator(TypeResolutionContext context) {
 		for (int i = 0; i < genericTypes.size(); i++)
 			iteratorTypes[i] = genericTypes.get(i).compile(context);
 
-		StorageTag storage = this.storage.resolve(position, context);
 		TypeID type = context.getTypeRegistry().getIterator(iteratorTypes);
-		if (storage == null)
-			storage = AutoStorageTag.INSTANCE;
-		return context.getTypeRegistry().getModified(modifiers, type).stored(storage);
+		return type.stored(storage.resolve(position, context));
 	}
 	
 	public static class ParsedNamePart {
 		}
 		
 		private GenericName compile(TypeResolutionContext context) {
-			return new GenericName(name, IParsedType.compileArguments(typeArguments, context));
+			return new GenericName(name, IParsedType.compileTypes(typeArguments, context));
 		}
 		
 		@Override

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedOptionalBasicType.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.parser.type;
-
-import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
-import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
-import org.openzen.zenscript.codemodel.type.TypeID;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class ParsedOptionalBasicType implements IParsedType {
-	private final ParsedTypeBasic type;
-	
-	public ParsedOptionalBasicType(ParsedTypeBasic type) {
-		this.type = type;
-	}
-
-	@Override
-	public IParsedType withOptional() {
-		return this;
-	}
-
-	@Override
-	public IParsedType withModifiers(int modifiers) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-	}
-
-	@Override
-	public StoredType compile(TypeResolutionContext context) {
-		StoredType base = type.compile(context);
-		return context.getTypeRegistry().getModified(ModifiedTypeID.MODIFIER_OPTIONAL, base.type).stored(base.storage);
-	}
-
-	@Override
-	public TypeID compileUnstored(TypeResolutionContext context) {
-		return context.getTypeRegistry().getModified(ModifiedTypeID.MODIFIER_OPTIONAL, type.compileUnstored(context));
-	}
-
-	@Override
-	public TypeArgument compileArgument(TypeResolutionContext context) {
-		TypeArgument base = type.compileArgument(context);
-		return new TypeArgument(context.getTypeRegistry().getModified(ModifiedTypeID.MODIFIER_OPTIONAL, base.type), base.storage);
-	}
-}

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedOptionalType.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.parser.type;
+
+import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
+import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ParsedOptionalType implements IParsedType {
+	private final IParsedType type;
+	
+	public ParsedOptionalType(IParsedType type) {
+		this.type = type;
+	}
+
+	@Override
+	public StoredType compile(TypeResolutionContext context) {
+		StoredType base = type.compile(context);
+		return new StoredType(context.getTypeRegistry().getOptional(base.type), base.getSpecifiedStorage());
+	}
+
+	@Override
+	public TypeID compileUnstored(TypeResolutionContext context) {
+		return context.getTypeRegistry().getOptional(type.compileUnstored(context));
+	}
+}

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedString.java

 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.TypeID;
-import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
 
 /**
  *
  */
 public class ParsedString implements IParsedType {
 	private final CodePosition position;
-	private final int modifiers;
 	private final ParsedStorageTag storage;
 	
-	public ParsedString(CodePosition position, int modifiers, ParsedStorageTag storage) {
+	public ParsedString(CodePosition position, ParsedStorageTag storage) {
 		this.position = position;
-		this.modifiers = modifiers;
 		this.storage = storage;
 	}
 
-	@Override
-	public IParsedType withOptional() {
-		return new ParsedString(position, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL, storage);
-	}
-
-	@Override
-	public IParsedType withModifiers(int modifiers) {
-		return new ParsedString(position, this.modifiers | modifiers, storage);
-	}
-
 	@Override
 	public StoredType compile(TypeResolutionContext context) {
-		return context.getTypeRegistry()
-				.getModified(modifiers, StringTypeID.INSTANCE)
-				.stored(storage == ParsedStorageTag.NULL ? AutoStorageTag.INSTANCE : storage.resolve(position, context));
+		return StringTypeID.INSTANCE.stored(storage.resolve(position, context));
 	}
 
 	@Override
 		
 		return StringTypeID.INSTANCE;
 	}
-
-	@Override
-	public TypeArgument compileArgument(TypeResolutionContext context) {
-		return new TypeArgument(context.getTypeRegistry()
-				.getModified(modifiers, StringTypeID.INSTANCE), storage.resolve(position, context));
-	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedTypeArray.java

 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.TypeID;
-import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
 	private final CodePosition position;
 	public final IParsedType baseType;
 	public final int dimension;
-	public final int modifiers;
 	public final ParsedStorageTag storage;
 	
 	public ParsedTypeArray(CodePosition position, IParsedType baseType, int dimension, ParsedStorageTag storage) {
 		this.position = position;
 		this.baseType = baseType;
 		this.dimension = dimension;
-		this.modifiers = 0;
 		this.storage = storage;
 	}
 
-	private ParsedTypeArray(CodePosition position, IParsedType baseType, int dimension, int modifiers, ParsedStorageTag storage) {
-		if (storage == null)
-			throw new NullPointerException();
-		
-		this.position = position;
-		this.baseType = baseType;
-		this.dimension = dimension;
-		this.modifiers = modifiers;
-		this.storage = storage;
-	}
-	
-	@Override
-	public IParsedType withOptional() {
-		return new ParsedTypeArray(position, baseType, dimension, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL, storage);
-	}
-
-	@Override
-	public IParsedType withModifiers(int modifiers) {
-		return new ParsedTypeArray(position, baseType, dimension, this.modifiers | modifiers, storage);
-	}
-
 	@Override
 	public StoredType compile(TypeResolutionContext context) {
 		StoredType baseType = this.baseType.compile(context);
 		StorageTag storage = this.storage.resolve(position, context);
 		GlobalTypeRegistry registry = context.getTypeRegistry();
-		return registry.getModified(modifiers, registry.getArray(baseType, dimension)).stored(storage == null ? AutoStorageTag.INSTANCE : storage);
+		return registry.getArray(baseType, dimension).stored(storage);
 	}
 	
 	@Override
 		StoredType baseType = this.baseType.compile(context);
 		StorageTag storage = this.storage.resolve(position, context);
 		GlobalTypeRegistry registry = context.getTypeRegistry();
-		return registry.getModified(modifiers, registry.getArray(baseType, dimension));
-	}
-
-	@Override
-	public TypeArgument compileArgument(TypeResolutionContext context) {
-		StoredType baseType = this.baseType.compile(context);
-		StorageTag storage = this.storage.resolve(position, context);
-		GlobalTypeRegistry registry = context.getTypeRegistry();
-		return new TypeArgument(registry.getModified(modifiers, registry.getArray(baseType, dimension)), storage);
+		return registry.getArray(baseType, dimension);
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedTypeAssociative.java

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.TypeID;
-import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
 	private final CodePosition position;
 	public final IParsedType key;
 	public final IParsedType value;
-	public final int modifiers;
 	private final ParsedStorageTag storage;
 	
 	public ParsedTypeAssociative(CodePosition position, IParsedType key, IParsedType value, ParsedStorageTag storage) {
 		this.position = position;
 		this.key = key;
 		this.value = value;
-		this.modifiers = 0;
 		this.storage = storage;
 	}
 
-	private ParsedTypeAssociative(CodePosition position, IParsedType key, IParsedType value, int modifiers, ParsedStorageTag storage) {
-		this.position = position;
-		this.key = key;
-		this.value = value;
-		this.modifiers = modifiers;
-		this.storage = storage;
-	}
-	
-	@Override
-	public IParsedType withOptional() {
-		return new ParsedTypeAssociative(position, key, value, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL, storage);
-	}
-
-	@Override
-	public IParsedType withModifiers(int modifiers) {
-		return new ParsedTypeAssociative(position, key, value, this.modifiers | modifiers, storage);
-	}
-
 	@Override
 	public StoredType compile(TypeResolutionContext context) {
 		StorageTag storage = this.storage.resolve(position, context);
 		StoredType key = this.key.compile(context);
 		StoredType value = this.value.compile(context);
-		GlobalTypeRegistry registry = context.getTypeRegistry();
-		return registry.getModified(modifiers, context.getTypeRegistry().getAssociative(key, value)).stored(storage == null ? AutoStorageTag.INSTANCE : storage);
+		return context.getTypeRegistry().getAssociative(key, value).stored(storage);
 	}
 
 	@Override
 		StorageTag storage = this.storage.resolve(position, context);
 		StoredType key = this.key.compile(context);
 		StoredType value = this.value.compile(context);
-		GlobalTypeRegistry registry = context.getTypeRegistry();
-		return registry.getModified(modifiers, context.getTypeRegistry().getAssociative(key, value));
-	}
-
-	@Override
-	public TypeArgument compileArgument(TypeResolutionContext context) {
-		StorageTag storage = this.storage.resolve(position, context);
-		StoredType key = this.key.compile(context);
-		StoredType value = this.value.compile(context);
-		GlobalTypeRegistry registry = context.getTypeRegistry();
-		return new TypeArgument(registry.getModified(modifiers, context.getTypeRegistry().getAssociative(key, value)), storage);
+		return context.getTypeRegistry().getAssociative(key, value);
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedTypeBasic.java

 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
 	public TypeID compileUnstored(TypeResolutionContext context) {
 		return type;
 	}
-	
-	@Override
-	public TypeArgument compileArgument(TypeResolutionContext context) {
-		return type.argument;
-	}
-
-	@Override
-	public IParsedType withOptional() {
-		return new ParsedOptionalBasicType(this);
-	}
-
-	@Override
-	public IParsedType withModifiers(int modifiers) {
-		throw new UnsupportedOperationException();
-	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedTypeGenericMap.java

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.TypeID;
-import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.parser.definitions.ParsedTypeParameter;
 
 	private final CodePosition position;
 	private final ParsedTypeParameter key;
 	private final IParsedType value;
-	private final int modifiers;
 	private final ParsedStorageTag storage;
 	
-	public ParsedTypeGenericMap(CodePosition position, ParsedTypeParameter key, IParsedType value, int modifiers, ParsedStorageTag storage) {
+	public ParsedTypeGenericMap(CodePosition position, ParsedTypeParameter key, IParsedType value, ParsedStorageTag storage) {
 		this.position = position;
 		this.key = key;
 		this.value = value;
-		this.modifiers = modifiers;
 		this.storage = storage;
 	}
 
-	@Override
-	public IParsedType withOptional() {
-		return new ParsedTypeGenericMap(position, key, value, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL, storage);
-	}
-
-	@Override
-	public IParsedType withModifiers(int modifiers) {
-		return new ParsedTypeGenericMap(position, key, value, modifiers | this.modifiers, storage);
-	}
-
 	@Override
 	public StoredType compile(TypeResolutionContext context) {
 		TypeParameter cKey = key.compiled;
 		
 		GlobalTypeRegistry registry = context.getTypeRegistry();
 		StorageTag storage = this.storage.resolve(position, context);
-		return registry.getModified(modifiers, registry.getGenericMap(valueType, cKey)).stored(storage == null ? AutoStorageTag.INSTANCE : storage);
+		return registry.getGenericMap(valueType, cKey).stored(storage);
 	}
 
 	@Override
 		
 		GlobalTypeRegistry registry = context.getTypeRegistry();
 		StorageTag storage = this.storage.resolve(position, context);
-		return registry.getModified(modifiers, registry.getGenericMap(valueType, cKey));
-	}
-
-	@Override
-	public TypeArgument compileArgument(TypeResolutionContext context) {
-		TypeParameter cKey = key.compiled;
-		StoredType valueType = this.value.compile(new GenericMapScope(context, cKey));
-		
-		GlobalTypeRegistry registry = context.getTypeRegistry();
-		StorageTag storage = this.storage.resolve(position, context);
-		return new TypeArgument(registry.getModified(modifiers, registry.getGenericMap(valueType, cKey)), storage);
+		return registry.getGenericMap(valueType, cKey);
 	}
 	
 	private class GenericMapScope implements TypeResolutionContext {

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedTypeRange.java

 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
 	private final CodePosition position;
 	private final IParsedType from;
 	private final IParsedType to;
-	private final int modifiers;
 	
 	public ParsedTypeRange(CodePosition position, IParsedType from, IParsedType to) {
 		this.position = position;
 		this.from = from;
 		this.to = to;
-		this.modifiers = 0;
-	}
-	
-	private ParsedTypeRange(CodePosition position, IParsedType from, IParsedType to, int modifiers) {
-		this.position = position;
-		this.from = from;
-		this.to = to;
-		this.modifiers = modifiers;
-	}
-
-	@Override
-	public IParsedType withOptional() {
-		return new ParsedTypeRange(position, from, to, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL);
-	}
-
-	@Override
-	public IParsedType withModifiers(int modifiers) {
-		return new ParsedTypeRange(position, from, to, this.modifiers | modifiers);
 	}
 	
 	@Override
 		StoredType from = this.from.compile(context);
 		StoredType to = this.to.compile(context);
 		if (!from.equals(to))
-			return new InvalidTypeID(position, CompileExceptionCode.NO_SUCH_TYPE, "from and to in a range must be the same type").stored(from.storage);
+			return new InvalidTypeID(position, CompileExceptionCode.NO_SUCH_TYPE, "from and to in a range must be the same type").stored(from.getSpecifiedStorage());
 		
-		return context.getTypeRegistry().getModified(modifiers, context.getTypeRegistry().getRange(from)).stored(from.storage);
+		return context.getTypeRegistry().getRange(from).stored(from.getSpecifiedStorage());
 	}
 	
 	@Override
 		if (!from.equals(to))
 			return new InvalidTypeID(position, CompileExceptionCode.NO_SUCH_TYPE, "from and to in a range must be the same type");
 		
-		return context.getTypeRegistry().getModified(modifiers, context.getTypeRegistry().getRange(from));
-	}
-	
-	@Override
-	public TypeArgument compileArgument(TypeResolutionContext context) {
-		StoredType from = this.from.compile(context);
-		StoredType to = this.to.compile(context);
-		if (!from.equals(to))
-			return new TypeArgument(new InvalidTypeID(position, CompileExceptionCode.NO_SUCH_TYPE, "from and to in a range must be the same type"), null);
-		
-		return new TypeArgument(context.getTypeRegistry().getModified(modifiers, context.getTypeRegistry().getRange(from)), from.storage);
+		return context.getTypeRegistry().getRange(from);
 	}
 }

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/GlobalRegistry.java

 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 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.StringTypeID;
-import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaField;
 	private class PrintlnSymbol implements ISymbol {
 
 		@Override
-		public IPartialExpression getExpression(CodePosition position, BaseScope scope, TypeArgument[] typeArguments) {
+		public IPartialExpression getExpression(CodePosition position, BaseScope scope, StoredType[] typeArguments) {
 			return new PartialMemberGroupExpression(
 					position,
 					scope,
 		}
 
 		@Override
-		public TypeID getType(CodePosition position, TypeResolutionContext context, TypeArgument[] typeArguments) {
+		public TypeID getType(CodePosition position, TypeResolutionContext context, StoredType[] typeArguments) {
 			return null; // not a type
 		}
 	}

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

 	public Void visitStorageCast(StorageCastExpression expression) {
 		if (expression.value.type.type != expression.type.type)
 			validator.logError(ValidationLogEntry.Code.INVALID_STORAGE_CAST, expression.position, "Invalid storage cast");
-		if (!expression.value.type.storage.canCastTo(expression.type.storage) && !expression.type.storage.canCastFrom(expression.value.type.storage))
+		if (!expression.value.type.getActualStorage().canCastTo(expression.type.getActualStorage()) && !expression.type.getActualStorage().canCastFrom(expression.value.type.getActualStorage()))
 			validator.logError(ValidationLogEntry.Code.INVALID_STORAGE_CAST, expression.position, "Invalid storage cast");
 		
 		expression.value.accept(this);

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

 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
+import org.openzen.zenscript.codemodel.type.OptionalTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 	}
 
 	@Override
-	public Void visitModified(ModifiedTypeID type) {
-		validator.logError(ValidationLogEntry.Code.SUPERCLASS_NOT_A_CLASS, position, "Superclass cannot be a modified type");
+	public Void visitOptional(OptionalTypeID type) {
+		validator.logError(ValidationLogEntry.Code.SUPERCLASS_NOT_A_CLASS, position, "Superclass cannot be an optional type");
 		return null;
 	}