Continue work on storage tags. WIP on compile plugins.

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

 				case CAST: {
 					StringBuilder result = new StringBuilder();
 					result.append(" as ");
-					result.append(expression.arguments.typeArguments[0].accept(typeFormatter));
+					result.append(typeFormatter.format(expression.arguments.typeArguments[0]));
 					return new ExpressionString(result.toString(), ZenScriptOperator.CAST);
 				}
 				default:

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.TypeID;
+import org.openzen.zenscript.codemodel.type.TypeArgument;
 
 /**
  *
 			result.append("<");
 			
 			int index = 0;
-			for (TypeID typeArgument : arguments.typeArguments) {
+			for (TypeArgument typeArgument : arguments.typeArguments) {
 				if (index > 0)
 					result.append(", ");
-				result.append(typeArgument.accept(typeFormatter));
+				result.append(typeFormatter.format(typeArgument));
 				index++;
 			}
 			result.append(">");

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

 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();
 	}
 		result.append(importedName);
 		result.append("<");
 		int index = 0;
-		for (TypeID typeParameter : definition.typeArguments) {
+		for (TypeArgument typeParameter : definition.typeArguments) {
 			if (index > 0)
 				result.append(", ");
 			
-			result.append(typeParameter.accept(this));
+			result.append(format(typeParameter));
 		}
 		result.append(">");
 		return result.toString();

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.TypeID;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
 		return result.toString();
 	}
 	
-	public TypeID[] inferTypes(LocalMemberCache cache, CallArguments arguments, List<StoredType> resultHint) {
+	public TypeArgument[] inferTypes(LocalMemberCache cache, CallArguments arguments, List<StoredType> resultHint) {
 		if (arguments.arguments.length != this.parameters.length)
 			return null;
 		
-		Map<TypeParameter, TypeID> mapping = new HashMap<>();
+		Map<TypeParameter, TypeArgument> mapping = new HashMap<>();
 		if (!resultHint.isEmpty()) {
 			for (StoredType hint : resultHint) {
-				Map<TypeParameter, TypeID> temp = returnType.inferTypeParameters(cache, hint);
+				Map<TypeParameter, TypeArgument> temp = returnType.inferTypeParameters(cache, hint.asArgument());
 				if (temp != null) {
 					mapping = temp;
 					break;
 		
 		// TODO: lambda header inference
 		for (int i = 0; i < parameters.length; i++) {
-			Map<TypeParameter, TypeID> forParameter = parameters[i].type.inferTypeParameters(cache, arguments.arguments[i].type);
+			Map<TypeParameter, TypeArgument> forParameter = parameters[i].type.inferTypeParameters(cache, arguments.arguments[i].type.asArgument());
 			if (forParameter == null)
 				return null;
 			
 		if (mapping.size() > typeParameters.length)
 			return null;
 		
-		TypeID[] result = new TypeID[typeParameters.length];
+		TypeArgument[] result = new TypeArgument[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, TypeID> typeParameters = new HashMap<>();
-			for (int i = 0; i < this.typeParameters.length; i++) {
-				typeParameters.put(this.typeParameters[i], arguments.typeArguments[i]);
-			}
+			Map<TypeParameter, TypeArgument> typeParameters = TypeArgument.getMapping(this.typeParameters, arguments.typeArguments);
 			return withGenericArguments(
 					registry,
 					new GenericMapper(registry, typeParameters));
 	}
 	
 	public FunctionHeader withGenericArguments(GlobalTypeRegistry registry, GenericMapper mapper) {
-		if (typeParameters.length > 0) {
-			Map<TypeParameter, TypeID> innerMap = new HashMap<>();
-			for (TypeParameter parameter : typeParameters)
-				innerMap.put(parameter, mapper.registry.getGeneric(parameter));
-			
-			mapper = mapper.getInner(registry, innerMap);
-		}
+		if (typeParameters.length > 0)
+			mapper = mapper.getInner(registry, TypeArgument.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, TypeID[] arguments, GenericMapper typeParameterMapping) {
+	public FunctionHeader fillGenericArguments(GlobalTypeRegistry registry, TypeArgument[] arguments, GenericMapper typeParameterMapping) {
 		if (arguments == null || arguments.length == 0)
 			return this;
 		
-		Map<TypeParameter, TypeID> typeArguments = new HashMap<>();
-		for (int i = 0; i < typeParameters.length; i++)
-			typeArguments.put(typeParameters[i], arguments[i]);
+		Map<TypeParameter, TypeArgument> typeArguments = TypeArgument.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 java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.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, TypeID> mapping;
+	private final Map<TypeParameter, TypeArgument> mapping;
 	
-	public GenericMapper(GlobalTypeRegistry registry, Map<TypeParameter, TypeID> mapping) {
+	public GenericMapper(GlobalTypeRegistry registry, Map<TypeParameter, TypeArgument> mapping) {
 		this.registry = registry;
 		this.mapping = mapping;
 	}
 	
-	public Map<TypeParameter, TypeID> getMapping() {
+	public Map<TypeParameter, TypeArgument> getMapping() {
 		return mapping;
 	}
 	
-	public TypeID map(TypeID original) {
-		return mapping.isEmpty() ? original : original.instanceUnstored(this);
+	public TypeArgument map(CodePosition position, TypeArgument original) {
+		return mapping.isEmpty() ? original : original.instance(position, this, original.storage);
 	}
 	
 	public StoredType[] map(StoredType[] original) {
 		return mapped;
 	}
 	
-	public TypeID map(GenericTypeID type) {
+	public TypeArgument map(GenericTypeID type) {
 		if (!mapping.containsKey(type.parameter))
 			throw new IllegalStateException("No mapping found for type " + type);
 		
-		return mapping.containsKey(type.parameter) ? mapping.get(type.parameter) : type;
+		return mapping.containsKey(type.parameter) ? mapping.get(type.parameter) : new TypeArgument(type, null);
 	}
 	
 	public FunctionHeader map(FunctionHeader original) {
 		return mapping.isEmpty() ? original : original.withGenericArguments(registry, this);
 	}
 	
-	public GenericMapper getInner(GlobalTypeRegistry registry, Map<TypeParameter, TypeID> mapping) {
-		Map<TypeParameter, TypeID> resultMap = new HashMap<>(this.mapping);
+	public GenericMapper getInner(GlobalTypeRegistry registry, Map<TypeParameter, TypeArgument> mapping) {
+		Map<TypeParameter, TypeArgument> resultMap = new HashMap<>(this.mapping);
 		resultMap.putAll(mapping);
 		return new GenericMapper(registry, resultMap);
 	}
 	
 	public GenericMapper getInner(GlobalTypeRegistry registry, TypeParameter[] parameters) {
-		Map<TypeParameter, TypeID> resultMap = new HashMap<>(this.mapping);
+		Map<TypeParameter, TypeArgument> resultMap = new HashMap<>(this.mapping);
 		for (TypeParameter parameter : parameters)
-			resultMap.put(parameter, registry.getGeneric(parameter));
+			resultMap.put(parameter, new TypeArgument(registry.getGeneric(parameter), null));
 		return new GenericMapper(registry, resultMap);
 	}
 	
 		StringBuilder result = new StringBuilder();
 		result.append('{');
 		boolean first = true;
-		for (Map.Entry<TypeParameter, TypeID> entry : mapping.entrySet()) {
+		for (Map.Entry<TypeParameter, TypeArgument> entry : mapping.entrySet()) {
 			if (first) {
 				first = false;
 			} else {

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

 	public List<FunctionHeader> getInitializers(BaseScope scope) {
 		return Collections.singletonList(new FunctionHeader(
 				BasicTypeID.VOID.stored,
-				scope.getType(CodePosition.BUILTIN, enforcementLevelName).stored(ValueStorageTag.INSTANCE),
+				scope.getType(CodePosition.BUILTIN, enforcementLevelName).stored(),
 				BasicTypeID.BOOL.stored,
 				StringTypeID.UNIQUE));
 	}

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

 			return null;
 		
 		TypeID self = getTypeRegistry().getForMyDefinition(type.load());
-		return self.stored(self.isValueType() ? ValueStorageTag.INSTANCE : BorrowStorageTag.THIS);
+		return self.stored(BorrowStorageTag.THIS);
 	}
 }

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

 package org.openzen.zenscript.codemodel.context;
 
 import java.util.Arrays;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 	}
 	
 	public GenericMapper getMapper() {
-		Map<TypeParameter, TypeID> mapper = new HashMap<>();
-		for (TypeParameter parameter : typeParameters)
-			mapper.put(parameter, moduleContext.registry.getGeneric(parameter));
+		Map<TypeParameter, TypeArgument> mapper = TypeArgument.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.TypeID;
+import org.openzen.zenscript.codemodel.type.TypeArgument;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ExpansionDefinition extends HighLevelDefinition {
-	public TypeID target;
+	public TypeArgument 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.storage.UniqueStorageTag;
-import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.codemodel.type.TypeArgument;
 
 /**
  *
 public class CallArguments {
 	public static final CallArguments EMPTY = new CallArguments(new Expression[0]);
 	
-	public final TypeID[] typeArguments;
+	public final TypeArgument[] typeArguments;
 	public final Expression[] arguments;
 	
 	public CallArguments(Expression... arguments) {
-		this.typeArguments = TypeID.NONE;
+		this.typeArguments = TypeArgument.NONE;
 		this.arguments = arguments;
 	}
 	
-	public CallArguments(TypeID[] typeArguments, Expression[] arguments) {
+	public CallArguments(TypeArgument[] typeArguments, Expression[] arguments) {
 		if (typeArguments == null)
-			typeArguments = TypeID.NONE;
+			typeArguments = TypeArgument.NONE;
 		if (arguments == null)
 			throw new IllegalArgumentException("Arguments cannot be null!");
 		
 		this.arguments = arguments;
 	}
 	
-	public CallArguments(TypeID... dummy) {
-		this.typeArguments = TypeID.NONE;
+	public CallArguments(TypeArgument... dummy) {
+		this.typeArguments = TypeArgument.NONE;
 		this.arguments = new Expression[dummy.length];
 		for (int i = 0; i < dummy.length; i++)
-			arguments[i] = new DummyExpression(dummy[i].stored(UniqueStorageTag.INSTANCE));
+			arguments[i] = new DummyExpression(dummy[i].stored());
 	}
 	
 	public int getNumberOfTypeArguments() {

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

 	public Expression normalize(TypeScope scope) {
 		return new CallStaticExpression(
 				position,
-				target.getNormalizedUnstored(),
+				target.getNormalized(),
 				member,
 				instancedHeader.normalize(scope.getTypeRegistry()),
 				arguments.normalize(position, scope, instancedHeader));

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

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

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.TypeID;
+import org.openzen.zenscript.codemodel.type.TypeArgument;
 import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 
 /**
 	}
 	
 	@Override
-	public TypeID[] getGenericCallTypes() {
+	public TypeArgument[] getTypeArguments() {
 		return null;
 	}
 	

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

 
 	@Override
 	public Expression normalize(TypeScope scope) {
-		return new IsExpression(position, value.normalize(scope), isType.getNormalizedUnstored());
+		return new IsExpression(position, value.normalize(scope), isType.getNormalized());
 	}
 }

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

 
 	@Override
 	public TypeParameterBound instance(GenericMapper mapper) {
-		TypeID translated = type.instanceUnstored(mapper);
+		TypeID translated = type.instance(mapper, null).type;
 		if (translated == type)
 			return this;
 		

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

 
 	@Override
 	public TypeParameterBound instance(GenericMapper mapper) {
-		return new ParameterTypeBound(position, type.instanceUnstored(mapper));
+		return new ParameterTypeBound(position, type.instance(mapper, null).type);
 	}
 
 	@Override

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

 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.Taggable;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	
 	public final CodePosition position;
 	public final String name;
+	public StorageTag storage = null;
 	public final List<TypeParameterBound> bounds = new ArrayList<>();
 	
 	public TypeParameter(CodePosition position, String name) {
 		return true;
 	}
 	
-	public TypeParameter withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, TypeID> arguments) {
-		// TODO: think about this...
-		//List<GenericParameterBound> bounds = new ArrayList<>();
-		//for (GenericParameterBound bound : this.bounds)
-		//	bounds.add(bound.withGenericArguments(registry, arguments));
-		//return new TypeParameter(name, bounds);
-		return this;
-	}
-	
 	public String getCanonical() {
 		StringBuilder result = new StringBuilder();
 		result.append(name);

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

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.TypeID;
+import org.openzen.zenscript.codemodel.type.TypeArgument;
 
 /**
  *
  */
 public class InnerDefinition {
 	public final HighLevelDefinition definition;
-	public final Map<TypeParameter, TypeID> outerTypeArguments;
+	public final Map<TypeParameter, TypeArgument> outerTypeArguments;
 	
 	public InnerDefinition(HighLevelDefinition definition) {
 		this.definition = definition;
 		this.outerTypeArguments = Collections.emptyMap();
 	}
 	
-	public InnerDefinition(HighLevelDefinition definition, Map<TypeParameter, TypeID> outerTypeArguments) {
+	public InnerDefinition(HighLevelDefinition definition, Map<TypeParameter, TypeArgument> outerTypeArguments) {
 		this.definition = definition;
 		this.outerTypeArguments = outerTypeArguments;
 	}
 	
-	public DefinitionTypeID instance(GlobalTypeRegistry registry, TypeID[] typeArguments, DefinitionTypeID outer) {
+	public DefinitionTypeID instance(GlobalTypeRegistry registry, TypeArgument[] 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;
 	
-	TypeID[] getGenericCallTypes();
+	TypeArgument[] 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.TypeID;
+import org.openzen.zenscript.codemodel.type.TypeArgument;
 
 /**
  *
 	private final CodePosition position;
 	private final String name;
 	private final IPartialExpression resolution;
-	private final TypeID[] typeParameters;
+	private final TypeArgument[] typeArguments;
 	
-	public PartialGlobalExpression(CodePosition position, String name, IPartialExpression resolution, TypeID[] typeParameters) {
+	public PartialGlobalExpression(CodePosition position, String name, IPartialExpression resolution, TypeArgument[] typeArguments) {
 		this.position = position;
 		this.name = name;
 		this.resolution = resolution;
-		this.typeParameters = typeParameters;
+		this.typeArguments = typeArguments;
 	}
 	
 	@Override
 	}
 
 	@Override
-	public TypeID[] getGenericCallTypes() {
-		return typeParameters;
+	public TypeArgument[] 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.TypeID;
+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 TypeID[] typeArguments;
+	private final TypeArgument[] typeArguments;
 	private final boolean allowStaticUsage;
 	private final TypeScope scope;
 	
 			TypeScope scope,
 			Expression target,
 			TypeMemberGroup group,
-			TypeID[] typeArguments,
+			TypeArgument[] typeArguments,
 			boolean allowStaticMembers)
 	{
 		this.position = position;
 			Expression target,
 			String name,
 			FunctionalMemberRef member,
-			TypeID[] typeArguments,
+			TypeArgument[] typeArguments,
 			boolean allowStaticMembers)
 	{
 		this.position = position;
 	}
 
 	@Override
-	public TypeID[] getGenericCallTypes() {
+	public TypeArgument[] 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.TypeID;
+import org.openzen.zenscript.codemodel.type.TypeArgument;
 
 /**
  *
 	}
 
 	@Override
-	public TypeID[] getGenericCallTypes() {
+	public TypeArgument[] 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, TypeID[] typeArguments) {
+	public static PartialStaticMemberGroupExpression forMethod(CodePosition position, TypeScope scope, String name, TypeID target, FunctionalMemberRef method, TypeArgument[] 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 TypeID[] typeArguments;
+	private final TypeArgument[] typeArguments;
 	
-	public PartialStaticMemberGroupExpression(CodePosition position, TypeScope scope, TypeID target, TypeMemberGroup group, TypeID[] typeArguments) {
+	public PartialStaticMemberGroupExpression(CodePosition position, TypeScope scope, TypeID target, TypeMemberGroup group, TypeArgument[] typeArguments) {
 		this.position = position;
 		this.scope = scope;
 		this.group = group;
 	}
 
 	@Override
-	public TypeID[] getGenericCallTypes() {
+	public TypeArgument[] 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 TypeID[] typeParameters;
+	private final TypeArgument[] typeArguments;
 	
-	public PartialTypeExpression(CodePosition position, TypeID type, TypeID[] typeParameters) {
+	public PartialTypeExpression(CodePosition position, TypeID type, TypeArgument[] typeArguments) {
 		this.position = position;
 		this.type = type.stored(StaticExpressionStorageTag.INSTANCE);
-		this.typeParameters = typeParameters;
+		this.typeArguments = typeArguments;
 	}
 
 	@Override
 
 	@Override
 	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException {
-		if (arguments.getNumberOfTypeArguments() == 0 && (typeParameters != null && typeParameters.length > 0))
-			arguments = new CallArguments(typeParameters, arguments.arguments);
+		if (arguments.getNumberOfTypeArguments() == 0 && (typeArguments != null && typeArguments.length > 0))
+			arguments = new CallArguments(typeArguments, arguments.arguments);
 		
 		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).callStatic(position, type.type, scope, arguments);
 	}
 
 	@Override
-	public TypeID[] getGenericCallTypes() {
-		return typeParameters;
+	public TypeArgument[] getTypeArguments() {
+		return typeArguments;
 	}
 	
 	@Override

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 TypeID[] getGenericCallTypes() {
-		return TypeID.NONE;
+	public TypeArgument[] getTypeArguments() {
+		return TypeArgument.NONE;
 	}
 }

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

  */
 package org.openzen.zenscript.codemodel.scope;
 
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 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;
 	private final HighLevelDefinition definition;
 	private final StoredType type;
 	private final TypeMembers members;
-	private final Map<String, TypeParameter> genericParameters = new HashMap<>();
+	private final TypeParameter[] typeParameters;
 	private final Map<String, Supplier<HighLevelDefinition>> innerTypes = new HashMap<>();
 	private final GenericMapper typeParameterMap;
 	
 		this.outer = outer;
 		this.definition = definition;
 		
-		Map<TypeParameter, TypeID> typeParameters = new HashMap<>();
+		Map<TypeParameter, TypeArgument> typeParameters = new HashMap<>();
 		if (definition instanceof ExpansionDefinition) {
 			ExpansionDefinition expansion = (ExpansionDefinition)definition;
-			type = expansion.target.stored(expansion.target.isValueType() ? ValueStorageTag.INSTANCE : BorrowStorageTag.THIS);
-			
-			for (TypeParameter parameter : expansion.typeParameters) {
-				genericParameters.put(parameter.name, parameter);
-				typeParameters.put(parameter, outer.getTypeRegistry().getGeneric(parameter));
-			}
+			type = expansion.target.storage == null
+					? expansion.target.stored(BorrowStorageTag.THIS)
+					: expansion.target.stored();
+			this.typeParameters = expansion.typeParameters;
+			typeParameters = TypeArgument.getSelfMapping(outer.getTypeRegistry(), expansion.typeParameters);
 		} else {
 			DefinitionTypeID definitionType = outer.getTypeRegistry().getForMyDefinition(definition);
-			type = definitionType.stored(definitionType.isValueType() ? ValueStorageTag.INSTANCE : BorrowStorageTag.THIS);
+			type = definitionType.stored(BorrowStorageTag.THIS);
 			
+			List<TypeParameter> typeParameterList = new ArrayList<>();
 			while (definitionType != null) {
-				for (TypeParameter parameter : definitionType.definition.typeParameters) {
-					genericParameters.put(parameter.name, parameter);
-					typeParameters.put(parameter, outer.getTypeRegistry().getGeneric(parameter));
-				}
+				typeParameters = TypeArgument.getSelfMapping(outer.getTypeRegistry(), definitionType.definition.typeParameters);
+				typeParameterList.addAll(Arrays.asList(definitionType.definition.typeParameters));
+				
 				definitionType = definitionType.definition.isStatic() ? null : definitionType.outer;
 			}
+			this.typeParameters = typeParameterList.toArray(new TypeParameter[typeParameterList.size()]);
 		}
 		
 		members = withMembers ? outer.getMemberCache().get(type) : null;
 		} else if (innerTypes.containsKey(name.name)) {
 			return new PartialTypeExpression(position, getTypeRegistry().getForDefinition(innerTypes.get(name).get(), name.arguments), name.arguments);
 		}
-		if (genericParameters.containsKey(name.name) && !name.hasArguments())
-			return new PartialTypeExpression(position, getTypeRegistry().getGeneric(genericParameters.get(name.name)), name.arguments);
+		if (!name.hasArguments()) {
+			for (TypeParameter parameter : typeParameters)
+				if (parameter.name.equals(name.name))
+					return new PartialTypeExpression(position, getTypeRegistry().getGeneric(parameter), name.arguments);
+		}
 		
 		return outer.get(position, name);
 	}
 				result = getTypeMembers(result.stored(StaticExpressionStorageTag.INSTANCE)).getInnerType(position, name.get(i));
 			}
 			return result;
-		} else if (genericParameters.containsKey(name.get(0).name) && name.size() == 1 && !name.get(0).hasArguments()) {
-			return getTypeRegistry().getGeneric(genericParameters.get(name.get(0).name));
-		} else if (innerTypes.containsKey(name.get(0).name)) {
+		} 
+		
+		if (name.size() == 1 && !name.get(0).hasArguments())
+			for (TypeParameter parameter : typeParameters)
+				if (parameter.name.equals(name.get(0).name))
+					return getTypeRegistry().getGeneric(parameter);
+		
+		if (innerTypes.containsKey(name.get(0).name)) {
 			TypeID result = getTypeRegistry().getForDefinition(innerTypes.get(name.get(0).name).get(), name.get(0).arguments);
 			for (int i = 1; i < name.size(); i++) {
 				result = getTypeMembers(result.stored(StaticExpressionStorageTag.INSTANCE)).getInnerType(position, name.get(i));

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, TypeID> genericInferenceMap;
+	public final Map<TypeParameter, TypeArgument> genericInferenceMap;
 	public final Map<String, Function<CodePosition, Expression>> innerVariables = new HashMap<>();
 	
 	public ExpressionScope(BaseScope outer) {
 			BaseScope scope,
 			List<StoredType> hints,
 			DollarEvaluator dollar,
-			Map<TypeParameter, TypeID> genericInferenceMap,
+			Map<TypeParameter, TypeArgument> genericInferenceMap,
 			Map<String, Function<CodePosition, Expression>> innerVariables) {
 		this.outer = scope;
 		this.hints = hints;
 		if (header.typeParameters == null)
 			return this;
 		
-		Map<TypeParameter, TypeID> genericInferenceMap = new HashMap<>();
+		Map<TypeParameter, TypeArgument> genericInferenceMap = new HashMap<>();
 		for (TypeParameter parameter : header.typeParameters)
 			genericInferenceMap.put(parameter, null);
 		

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	}
 	
 	@Override
-	public ArrayTypeID getNormalizedUnstored() {
+	public ArrayTypeID getNormalized() {
 		return normalized;
 	}
 	
 	}
 	
 	@Override
-	public ArrayTypeID instanceUnstored(GenericMapper mapper) {
-		return mapper.registry.getArray(elementType.instance(mapper), dimension);
+	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
+		return mapper.registry.getArray(elementType.instance(mapper), dimension).argument(storage);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	}
 	
 	@Override
-	public AssocTypeID instanceUnstored(GenericMapper mapper) {
+	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
 		return mapper.registry.getAssociative(
 				keyType.instance(mapper),
-				valueType.instance(mapper));
+				valueType.instance(mapper)).argument(storage);
 	}
 	
 	@Override
-	public AssocTypeID getNormalizedUnstored() {
+	public AssocTypeID getNormalized() {
 		return normalized;
 	}
 	

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
 	
 	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);
 	}
 	
 	@Override
-	public BasicTypeID getNormalizedUnstored() {
+	public BasicTypeID getNormalized() {
 		return this;
 	}
 	
 	@Override
-	public BasicTypeID instanceUnstored(GenericMapper mapper) {
-		return this;
+	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
+		return new TypeArgument(this, storage);
 	}
 	
 	@Override

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

 import org.openzen.zenscript.codemodel.definition.StructDefinition;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 		if (definition.typeParameters != null && definition.typeParameters.length > 0)
 			throw new IllegalArgumentException("Definition has type arguments!");
 		
-		return new DefinitionTypeID(registry, definition, TypeID.NONE);
+		return new DefinitionTypeID(registry, definition, TypeArgument.NONE);
 	}
 	
 	public final HighLevelDefinition definition;
-	public final TypeID[] typeArguments;
+	public final TypeArgument[] typeArguments;
 	public final DefinitionTypeID outer;
 	private TypeID normalized;
 	
 	public TypeID superType;
 	
-	public DefinitionTypeID(GlobalTypeRegistry typeRegistry, HighLevelDefinition definition, TypeID[] typeArguments) {
+	public DefinitionTypeID(GlobalTypeRegistry typeRegistry, HighLevelDefinition definition, TypeArgument[] typeArguments) {
 		this(typeRegistry, definition, typeArguments, null);
 	}
 	
 	// For inner classes of generic outer classes
-	public DefinitionTypeID(GlobalTypeRegistry typeRegistry, HighLevelDefinition definition, TypeID[] typeArguments, DefinitionTypeID outer) {
+	public DefinitionTypeID(GlobalTypeRegistry typeRegistry, HighLevelDefinition definition, TypeArgument[] 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 (TypeID typeParameter : typeArguments)
-			if (typeParameter.getNormalizedUnstored() != typeParameter)
+		for (TypeArgument typeArgument : typeArguments)
+			if (!typeArgument.getNormalized().equals(typeArgument))
 				return true;
-		if (outer != null && outer.getNormalizedUnstored() != outer)
+		if (outer != null && !outer.getNormalized().equals(outer))
 			return true;
 		
 		return false;
 			if (alias.type == null)
 				throw new IllegalStateException("Alias type not yet initialized!");
 			
-			Map<TypeParameter, TypeID> typeMapping = new HashMap<>();
+			Map<TypeParameter, TypeArgument> typeMapping = new HashMap<>();
 			for (int i = 0; i < definition.typeParameters.length; i++)
-				typeMapping.put(definition.typeParameters[i], typeArguments[i].getNormalizedUnstored());
+				typeMapping.put(definition.typeParameters[i], typeArguments[i].getNormalized());
 			GenericMapper mapper = new GenericMapper(typeRegistry, typeMapping);
-			TypeID result = alias.type.instanceUnstored(mapper).getNormalizedUnstored();
+			TypeID result = alias.type.instance(mapper, null).type.getNormalized();
 			return result;
 		}
 		
-		TypeID[] normalizedTypeParameters = new TypeID[typeArguments.length];
+		TypeArgument[] normalizedTypeParameters = new TypeArgument[typeArguments.length];
 		for (int i = 0; i < normalizedTypeParameters.length; i++)
-			normalizedTypeParameters[i] = typeArguments[i].getNormalizedUnstored();
+			normalizedTypeParameters[i] = typeArguments[i].getNormalized();
 		
-		return typeRegistry.getForDefinition(definition, normalizedTypeParameters, outer == null ? null : (DefinitionTypeID)outer.getNormalizedUnstored());
+		return typeRegistry.getForDefinition(definition, normalizedTypeParameters, outer == null ? null : (DefinitionTypeID)outer.getNormalized());
 	}
 	
 	public boolean hasTypeParameters() {
 		return typeArguments.length > 0;
 	}
 	
-	public Map<TypeParameter, TypeID> getTypeParameterMapping() {
-		Map<TypeParameter, TypeID> mapping = new HashMap<>();
+	public Map<TypeParameter, TypeArgument> getTypeParameterMapping() {
+		Map<TypeParameter, TypeArgument> mapping = new HashMap<>();
 		DefinitionTypeID current = this;
 		do {
 			if (current.typeArguments != null) {
 	
 	public DefinitionTypeID(HighLevelDefinition definition) {
 		this.definition = definition;
-		this.typeArguments = TypeID.NONE;
+		this.typeArguments = TypeArgument.NONE;
 		this.superType = definition.getSuperType();
 		this.outer = null;
 	}
 	
 	@Override
-	public TypeID getNormalizedUnstored() {
+	public TypeID getNormalized() {
 		return normalized;
 	}
 	
 	@Override
-	public DefinitionTypeID instanceUnstored(GenericMapper mapper) {
+	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
 		if (!hasTypeParameters() && outer == null)
-			return this;
+			return argument(storage);
 		if (mapper.getMapping().isEmpty())
-			return this;
+			return argument(storage);
 		if (mapper.registry == null)
 			throw new NullPointerException();
 		
-		TypeID[] instancedArguments = TypeID.NONE;
+		TypeArgument[] instancedArguments = TypeArgument.NONE;
 		if (hasTypeParameters()) {
-			instancedArguments = new TypeID[typeArguments.length];
+			instancedArguments = new TypeArgument[typeArguments.length];
 			for (int i = 0; i < typeArguments.length; i++)
-				instancedArguments[i] = typeArguments[i].instanceUnstored(mapper);
+				instancedArguments[i] = typeArguments[i].instance(mapper);
 		}
 		
-		DefinitionTypeID instancedOuter = outer == null ? null : outer.instanceUnstored(mapper);
-		return mapper.registry.getForDefinition(definition, instancedArguments, instancedOuter);
+		DefinitionTypeID instancedOuter = outer == null ? null : (DefinitionTypeID)outer.instance(mapper, storage).type;
+		return mapper.registry.getForDefinition(definition, instancedArguments, instancedOuter).argument(storage);
 	}
 	
 	@Override
 	public TypeID getSuperType(GlobalTypeRegistry registry) {
-		return definition.getSuperType() == null ? null : definition.getSuperType().instanceUnstored(new GenericMapper(registry, getTypeParameterMapping()));
+		return definition.getSuperType() == null ? null : definition.getSuperType().instance(new GenericMapper(registry, getTypeParameterMapping()), null).type;
 	}
 	
 	@Override
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
 		if (hasTypeParameters()) {
-			for (TypeID typeParameter : typeArguments)
-				if (typeParameter.hasInferenceBlockingTypeParameters(parameters))
+			for (TypeArgument typeArgument : typeArguments)
+				if (typeArgument.type.hasInferenceBlockingTypeParameters(parameters))
 					return true;
 		}
 		
 
 	@Override
 	public void extractTypeParameters(List<TypeParameter> typeParameters) {
-		for (TypeID type : this.typeArguments)
-			type.extractTypeParameters(typeParameters);
+		for (TypeArgument type : this.typeArguments)
+			type.type.extractTypeParameters(typeParameters);
 	}
 
 	public DefinitionTypeID getInnerType(GenericName name, GlobalTypeRegistry registry) {

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

 	}
 	
 	@Override
-	public FunctionTypeID getNormalizedUnstored() {
+	public FunctionTypeID getNormalized() {
 		return normalized;
 	}
 	
 	@Override
-	public TypeID instanceUnstored(GenericMapper mapper) {
-		return mapper.registry.getFunction(mapper.map(header));
+	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
+		return new TypeArgument(mapper.registry.getFunction(mapper.map(header)), storage);
 	}
 	
 	@Override

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	}
 	
 	@Override
-	public GenericMapTypeID getNormalizedUnstored() {
+	public GenericMapTypeID getNormalized() {
 		return normalized;
 	}
 
 	}
 	
 	@Override
-	public TypeID instanceUnstored(GenericMapper mapper) {
-		return mapper.registry.getGenericMap(value.instance(mapper), key);
+	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
+		return new TypeArgument(mapper.registry.getGenericMap(value.instance(mapper), key), storage);
 	}
 
 	@Override

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

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

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 		this.parameter = parameter;
 	}
 	
-	public boolean matches(LocalMemberCache cache, TypeID type) {
-		return parameter.matches(cache, type);
+	public boolean matches(LocalMemberCache cache, TypeArgument type) {
+		if (type.storage != null && parameter.storage != null && !type.storage.equals(parameter.storage))
+			return false;
+		
+		return parameter.matches(cache, type.type);
 	}
 	
 	@Override
-	public GenericTypeID getNormalizedUnstored() {
+	public GenericTypeID getNormalized() {
 		return this;
 	}
 	
 	@Override
-	public TypeID instanceUnstored(GenericMapper mapper) {
-		return mapper.map(this);
+	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
+		return mapper.map(this).argument(StorageTag.union(parameter.storage, storage));
 	}
 	
 	@Override

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

 	}
 	
 	public DefinitionTypeID getForMyDefinition(HighLevelDefinition definition) {
-		TypeID[] typeArguments = TypeID.NONE;
+		TypeArgument[] typeArguments = TypeArgument.NONE;
 		if (definition.getNumberOfGenericParameters() > 0) {
-			typeArguments = new TypeID[definition.getNumberOfGenericParameters()];
+			typeArguments = new TypeArgument[definition.getNumberOfGenericParameters()];
 			for (int i = 0; i < definition.typeParameters.length; i++)
-				typeArguments[i] = getGeneric(definition.typeParameters[i]);
+				typeArguments[i] = new TypeArgument(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, TypeID... typeArguments) {
+	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, TypeArgument... typeArguments) {
 		return this.getForDefinition(definition, typeArguments, null);
 	}
 	
-	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, TypeID[] typeArguments, DefinitionTypeID outer) {
+	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, TypeArgument[] typeArguments, DefinitionTypeID outer) {
 		DefinitionTypeID id = new DefinitionTypeID(this, definition, typeArguments, definition.isStatic() ? null : outer);
 		
 		if (definitionTypes.containsKey(id)) {

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

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

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	}
 
 	@Override
-	public InvalidTypeID instanceUnstored(GenericMapper mapper) {
-		return this;
+	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
+		return new TypeArgument(this, storage);
 	}
 
 	@Override
 	}
 
 	@Override
-	public TypeID getNormalizedUnstored() {
+	public TypeID getNormalized() {
 		return this;
 	}
 	

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	}
 	
 	@Override
-	public IteratorTypeID getNormalizedUnstored() {
+	public IteratorTypeID getNormalized() {
 		return normalized;
 	}
 	
 	}
 	
 	@Override
-	public TypeID instanceUnstored(GenericMapper mapper) {
+	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
 		StoredType[] instanced = mapper.map(iteratorTypes);
-		return mapper.registry.getIterator(instanced);
+		return new TypeArgument(mapper.registry.getIterator(instanced), storage);
 	}
 
 	@Override

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

 		this.baseType = baseType;
 		this.registry = registry;
 		
-		normalized = baseType.getNormalizedUnstored() == baseType ? this : registry.getModified(modifiers, baseType.getNormalizedUnstored());
+		normalized = baseType.getNormalized() == baseType ? this : registry.getModified(modifiers, baseType.getNormalized());
 	}
 	
 	@Override
-	public TypeID getNormalizedUnstored() {
+	public TypeID getNormalized() {
 		return normalized;
 	}
 	
 	@Override
-	public TypeID instanceUnstored(GenericMapper mapper) {
-		return mapper.registry.getModified(modifiers, baseType.instanceUnstored(mapper));
+	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
+		TypeArgument base = baseType.instance(mapper, storage);
+		return new TypeArgument(mapper.registry.getModified(modifiers, base.type), base.storage);
 	}
 	
 	@Override

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
 			normalized = registry.getRange(baseType.getNormalized());
 		}
 		
-		stored = new StoredType(this, ValueStorageTag.INSTANCE);
+		stored = new StoredType(this, baseType.storage);
 	}
 	
 	@Override
-	public RangeTypeID getNormalizedUnstored() {
+	public RangeTypeID getNormalized() {
 		return normalized;
 	}
 	
 	@Override
-	public TypeID instanceUnstored(GenericMapper mapper) {
-		return mapper.registry.getRange(baseType.instance(mapper));
+	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
+		return mapper.registry.getRange(baseType.instance(mapper)).argument(storage);
 	}
 	
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/StoredType.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.StaticExpressionStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 	public final StorageTag storage;
 	
 	public StoredType(TypeID type, StorageTag storage) {
-		if (type.isValueType() && storage != ValueStorageTag.INSTANCE && storage != StaticExpressionStorageTag.INSTANCE)
-			throw new IllegalArgumentException("storage of a value type must be value");
-		if (!type.isValueType() && storage == ValueStorageTag.INSTANCE)
+		if (storage == null)
+			throw new NullPointerException();
+		
+		if (type.isValueType())
+			storage = ValueStorageTag.INSTANCE;
+		else if (storage == ValueStorageTag.INSTANCE)
 			throw new IllegalArgumentException("storage of a nonvalue type cannot be value");
 		
 		this.type = type;
 	}
 	
 	public StoredType getNormalized() {
-		return type.getNormalizedUnstored() == type ? this : new StoredType(type, storage);
+		return type.getNormalized() == type ? this : new StoredType(type, storage);
 	}
 	
 	public StoredType getSuperType(GlobalTypeRegistry registry) {
 	}
 	
 	public StoredType instance(GenericMapper mapper) {
-		TypeID result = mapper.map(type);
-		return result == type ? this : new StoredType(result, result.isValueType() ? ValueStorageTag.INSTANCE : storage);
+		TypeArgument result = type.instance(mapper, storage);
+		return result == type ? this : result.stored();
 	}
 	
 	public boolean isDestructible() {
 	}
 	
 	public boolean isConst() {
-		return type.isConst();
+		return storage.isConst();
 	}
 	
 	public boolean isImmutable() {
-		return type.isImmutable();
+		return storage.isImmutable();
 	}
 	
 	public boolean isBasic(BasicTypeID type) {
 	
 	// Infers type parameters for this type so it matches with targetType
 	// returns false if that isn't possible
-	public Map<TypeParameter, TypeID> inferTypeParameters(LocalMemberCache cache, StoredType targetType) {
-		return type.inferTypeParameters(cache, targetType.type);
+	public Map<TypeParameter, TypeArgument> inferTypeParameters(LocalMemberCache cache, TypeArgument targetType) {
+		return type.inferTypeParameters(cache, targetType);
 	}
 	
 	public boolean isVariant() {
 		return (DefinitionTypeID)type;
 	}
 	
+	public TypeArgument asArgument() {
+		return new TypeArgument(type, storage);
+	}
+	
 	@Override
 	public int hashCode() {
 		int hash = 5;
 	
 	public static class MatchingTypeVisitor implements TypeVisitor<Boolean> {
 		private final TypeID type;
-		private final Map<TypeParameter, TypeID> mapping;
+		private final Map<TypeParameter, TypeArgument> mapping;
 		private final LocalMemberCache cache;
 		
-		public MatchingTypeVisitor(LocalMemberCache cache, TypeID type, Map<TypeParameter, TypeID> mapping) {
+		public MatchingTypeVisitor(LocalMemberCache cache, TypeID type, Map<TypeParameter, TypeArgument> mapping) {
 			this.type = type;
 			this.mapping = mapping;
 			this.cache = cache;
 				if (arrayType.dimension != array.dimension)
 					return false;
 				
-				return match(arrayType.elementType, array.elementType);
+				return match(arrayType.elementType, array.elementType.asArgument());
 			} else {
 				return false;
 			}
 		public Boolean visitAssoc(AssocTypeID assoc) {
 			if (type instanceof AssocTypeID) {
 				AssocTypeID assocType = (AssocTypeID) type;
-				return match(assocType.keyType, assoc.keyType)
-						&& match(assocType.valueType, assoc.valueType);
+				return match(assocType.keyType, assoc.keyType.asArgument())
+						&& match(assocType.valueType, assoc.valueType.asArgument());
 			} else {
 				return false;
 			}
 				
 				boolean result = true;
 				for (int i = 0; i < iteratorType.iteratorTypes.length; i++)
-					result = result && match(iterator.iteratorTypes[i], iteratorType.iteratorTypes[i]);
+					result = result && match(iterator.iteratorTypes[i], iteratorType.iteratorTypes[i].asArgument());
 				
 				return result;
 			} else {
 				if (functionType.header.parameters.length != function.header.parameters.length)
 					return false;
 				
-				if (!match(functionType.header.getReturnType(), function.header.getReturnType()))
+				if (!match(functionType.header.getReturnType(), function.header.getReturnType().asArgument()))
 					return false;
 				
 				for (int i = 0; i < function.header.parameters.length; i++) {
-					if (!match(functionType.header.parameters[i].type, function.header.parameters[i].type))
+					if (!match(functionType.header.parameters[i].type, function.header.parameters[i].type.asArgument()))
 						return false;
 				}
 				
 				
 				if (definition.typeArguments != null) {
 					for (int i = 0; i < definitionType.typeArguments.length; i++) {
-						if (!match(definitionType.typeArguments[i], definition.typeArguments[i]))
+						if (!match(definitionType.typeArguments[i].stored(), 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, type)) {
-				mapping.put(generic.parameter, type);
+			} else if (type == generic || generic.matches(cache, new TypeArgument(type, null))) {
+				mapping.put(generic.parameter, new TypeArgument(type, null));
 				return true;
 			} else {
 				return false;
 		public Boolean visitRange(RangeTypeID range) {
 			if (type instanceof RangeTypeID) {
 				RangeTypeID rangeType = (RangeTypeID) type;
-				return match(rangeType.baseType, range.baseType);
+				return match(rangeType.baseType, range.baseType.asArgument());
 			} else {
 				return false;
 			}
 		public Boolean visitModified(ModifiedTypeID type) {
 			if (this.type instanceof ModifiedTypeID) {
 				ModifiedTypeID constType = (ModifiedTypeID) this.type;
-				return match(constType.baseType, type.baseType);
+				return match(constType.baseType, new TypeArgument(type.baseType, null));
 			} else {
 				return false;
 			}
 		}
 		
-		private boolean match(StoredType type, StoredType pattern) {
-			if (type.storage != pattern.storage)
+		private boolean match(StoredType type, TypeArgument pattern) {
+			if (pattern.storage != null && type.storage != pattern.storage)
 				return false;
 			
-			return TypeMatcher.match(cache, type.type, pattern.type) != null;
+			return TypeMatcher.match(cache, type.asArgument(), pattern) != null;
 		}
 		
-		private boolean match(TypeID type, TypeID pattern) {
-			return TypeMatcher.match(cache, type, pattern) != null;
+		private boolean match(TypeID type, TypeArgument pattern) {
+			return TypeMatcher.match(cache, new TypeArgument(type, null), pattern) != null;
 		}
 
 		@Override

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.storage.AnyStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.SharedStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StaticStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 
 /**
 public class StringTypeID implements TypeID {
 	public static final StringTypeID INSTANCE = new StringTypeID();
 	
-	public static final StoredType ANY = new StoredType(INSTANCE, AnyStorageTag.INSTANCE);
+	public static final StoredType AUTO = new StoredType(INSTANCE, AutoStorageTag.INSTANCE);
 	public static final StoredType STATIC = new StoredType(INSTANCE, StaticStorageTag.INSTANCE);
 	public static final StoredType UNIQUE = new StoredType(INSTANCE, UniqueStorageTag.INSTANCE);
 	public static final StoredType BORROW = new StoredType(INSTANCE, BorrowStorageTag.INVOCATION);
 	private StringTypeID() {}
 	
 	@Override
-	public TypeID getNormalizedUnstored() {
+	public TypeID getNormalized() {
 		return INSTANCE;
 	}
 	
 	}
 
 	@Override
-	public TypeID instanceUnstored(GenericMapper mapper) {
-		return this;
+	public TypeArgument instance(GenericMapper mapper, StorageTag storage) {
+		return argument(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;
 	}
 	
-	TypeID instanceUnstored(GenericMapper mapper);
+	TypeArgument instance(GenericMapper mapper, StorageTag storage);
 	
-	TypeID getNormalizedUnstored();
+	TypeID getNormalized();
 	
 	boolean isDestructible();
 	
 	
 	// Infers type parameters for this type so it matches with targetType
 	// returns false if that isn't possible
-	default Map<TypeParameter, TypeID> inferTypeParameters(LocalMemberCache cache, TypeID targetType) {
-		return TypeMatcher.match(cache, this, targetType);
+	default Map<TypeParameter, TypeArgument> inferTypeParameters(LocalMemberCache cache, TypeArgument targetType) {
+		return TypeMatcher.match(cache, new TypeArgument(this, null), targetType);
 	}
 	
 	void extractTypeParameters(List<TypeParameter> typeParameters);
 		return new StoredType(this, storage);
 	}
 	
+	default StoredType stored() {
+		return new StoredType(this, AutoStorageTag.INSTANCE);
+	}
+	
+	default TypeArgument argument(StorageTag storage) {
+		return new TypeArgument(this, storage);
+	}
+	
 	default boolean isOptional() {
 		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, TypeID> match(LocalMemberCache cache, TypeID type, TypeID pattern) {
+	public static Map<TypeParameter, TypeArgument> match(LocalMemberCache cache, TypeArgument type, TypeArgument pattern) {
 		Matching matching = new Matching(cache, type);
-		if (pattern.accept(matching, INSTANCE))
+		if (pattern.type.accept(matching, INSTANCE))
 			return matching.mapping;
 		
 		return null;
 	
 	@Override
 	public Boolean visitBasic(Matching context, BasicTypeID basic) {
-		return basic == context.type;
+		return context.type.isBasic(basic);
 	}
 
 	@Override
 	public Boolean visitString(Matching context, StringTypeID string) {
-		return string == context.type;
+		return context.type.type == StringTypeID.INSTANCE;
 	}
 
 	@Override
 	public Boolean visitArray(Matching context, ArrayTypeID array) {
-		if (context.type instanceof ArrayTypeID) {
-			ArrayTypeID arrayType = (ArrayTypeID) context.type;
+		if (context.type.type instanceof ArrayTypeID) {
+			ArrayTypeID arrayType = (ArrayTypeID) context.type.type;
 			if (arrayType.dimension != array.dimension)
 				return false;
 
 
 	@Override
 	public Boolean visitAssoc(Matching context, AssocTypeID assoc) {
-		if (context.type instanceof AssocTypeID) {
-			AssocTypeID assocType = (AssocTypeID) context.type;
+		if (context.type.type instanceof AssocTypeID) {
+			AssocTypeID assocType = (AssocTypeID) context.type.type;
 			return match(context, assocType.keyType, assoc.keyType)
 					&& match(context, assocType.valueType, assoc.valueType);
 		} else {
 
 	@Override
 	public Boolean visitIterator(Matching context, IteratorTypeID iterator) {
-		if (context.type instanceof IteratorTypeID) {
-			IteratorTypeID iteratorType = (IteratorTypeID) context.type;
+		if (context.type.type instanceof IteratorTypeID) {
+			IteratorTypeID iteratorType = (IteratorTypeID) context.type.type;
 			if (iteratorType.iteratorTypes.length != iterator.iteratorTypes.length)
 				return false;
 
 
 	@Override
 	public Boolean visitFunction(Matching context, FunctionTypeID function) {
-		if (context.type instanceof FunctionTypeID) {
-			FunctionTypeID functionType = (FunctionTypeID) context.type;
+		if (context.type.type instanceof FunctionTypeID) {
+			FunctionTypeID functionType = (FunctionTypeID) context.type.type;
 			if (functionType.header.parameters.length != function.header.parameters.length)
 				return false;
 
 
 	@Override
 	public Boolean visitDefinition(Matching context, DefinitionTypeID definition) {
-		if (context.type instanceof DefinitionTypeID) {
-			DefinitionTypeID definitionType = (DefinitionTypeID) context.type;
+		if (context.type.type instanceof DefinitionTypeID) {
+			DefinitionTypeID definitionType = (DefinitionTypeID) context.type.type;
 			if (definitionType.definition != definition.definition)
 				return false;
 
 	@Override
 	public Boolean visitGeneric(Matching context, GenericTypeID generic) {
 		if (context.mapping.containsKey(generic.parameter)) {
-			return context.mapping.get(generic.parameter) == context.type;
-		} else if (context.type == generic || generic.matches(context.cache, context.type)) {
+			TypeArgument argument = context.mapping.get(generic.parameter);
+			return argument.type == context.type && (argument.storage == null || argument.storage == context.type.storage);
+		} else if (context.type.type == generic || generic.matches(context.cache, context.type)) {
 			context.mapping.put(generic.parameter, context.type);
 			return true;
 		} else {
 
 	@Override
 	public Boolean visitRange(Matching context, RangeTypeID range) {
-		if (context.type instanceof RangeTypeID) {
-			RangeTypeID rangeType = (RangeTypeID) context.type;
+		if (context.type.type instanceof RangeTypeID) {
+			RangeTypeID rangeType = (RangeTypeID) context.type.type;
 			return match(context, rangeType.baseType, range.baseType);
 		} else {
 			return false;
 
 	@Override
 	public Boolean visitModified(Matching context, ModifiedTypeID type) {
-		if (context.type instanceof ModifiedTypeID) {
-			ModifiedTypeID modified = (ModifiedTypeID) context.type;
-			return match(context, modified.baseType, type.baseType);
+		if (context.type.type instanceof ModifiedTypeID) {
+			ModifiedTypeID modified = (ModifiedTypeID) context.type.type;
+			return match(context, modified.baseType.argument(null), type.baseType.argument(null));
 		} else {
 			return false;
 		}
 	}
 
-	private boolean match(Matching context, TypeID type, TypeID pattern) {
-		return pattern.accept(context.withType(type), this);
-	}
-
-	private boolean match(Matching context, StoredType type, StoredType pattern) {
-		if (type.storage != pattern.storage)
+	private boolean match(Matching context, TypeArgument type, TypeArgument pattern) {
+		if (pattern.storage != null && !pattern.storage.equals(type.storage))
 			return false;
 		
-		return pattern.type.accept(context.withType(type.type), this);
+		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) {
-		return map == context.type; // TODO: improve this
+		return map == context.type.type; // TODO: improve this
 	}
 		
 	public static final class Matching {
 		public final LocalMemberCache cache;
-		public final TypeID type;
-		public final Map<TypeParameter, TypeID> mapping;
+		public final TypeArgument type;
+		public final Map<TypeParameter, TypeArgument> mapping;
 		
-		public Matching(LocalMemberCache cache, TypeID type) {
+		public Matching(LocalMemberCache cache, TypeArgument type) {
 			this.cache = cache;
 			this.type = type;
 			mapping = new HashMap<>();
 		}
 		
-		private Matching(LocalMemberCache cache, TypeID type, Map<TypeParameter, TypeID> mapping) {
+		private Matching(LocalMemberCache cache, TypeArgument type, Map<TypeParameter, TypeArgument> mapping) {
 			this.cache = cache;
 			this.type = type;
 			this.mapping = mapping;
 		}
 		
-		public Matching withType(TypeID type) {
+		public Matching withType(TypeArgument type) {
 			return new Matching(cache, type, mapping);
 		}
 	}

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

  *
  * @author Hoofdgebruiker
  */
-public class TypeParameterCollector implements TypeVisitorWithContext<Map<TypeParameter, TypeID>, Void, RuntimeException> {
-	private final Map<TypeParameter, TypeID> map;
+public class TypeParameterCollector implements TypeVisitorWithContext<Map<TypeParameter, GenericTypeID>, Void, RuntimeException> {
+	private final Map<TypeParameter, GenericTypeID> map;
 	
-	public TypeParameterCollector(Map<TypeParameter, TypeID> map) {
+	public TypeParameterCollector(Map<TypeParameter, GenericTypeID> map) {
 		this.map = map;
 	}
 
 	@Override
-	public Void visitBasic(Map<TypeParameter, TypeID> context, BasicTypeID basic) {
+	public Void visitBasic(Map<TypeParameter, GenericTypeID> context, BasicTypeID basic) {
 		return null;
 	}
 	
 	@Override
-	public Void visitString(Map<TypeParameter, TypeID> context, StringTypeID string) {
+	public Void visitString(Map<TypeParameter, GenericTypeID> context, StringTypeID string) {
 		return null;
 	}
 
 	@Override
-	public Void visitArray(Map<TypeParameter, TypeID> context, ArrayTypeID array) {
+	public Void visitArray(Map<TypeParameter, GenericTypeID> context, ArrayTypeID array) {
 		array.elementType.type.accept(context, this);
 		return null;
 	}
 
 	@Override
-	public Void visitAssoc(Map<TypeParameter, TypeID> context, AssocTypeID assoc) {
+	public Void visitAssoc(Map<TypeParameter, GenericTypeID> context, AssocTypeID assoc) {
 		assoc.keyType.type.accept(context, this);
 		assoc.valueType.type.accept(context, this);
 		return null;
 	}
 
 	@Override
-	public Void visitGenericMap(Map<TypeParameter, TypeID> context, GenericMapTypeID map) {
+	public Void visitGenericMap(Map<TypeParameter, GenericTypeID> context, GenericMapTypeID map) {
 		return null;
 	}
 
 	@Override
-	public Void visitIterator(Map<TypeParameter, TypeID> context, IteratorTypeID iterator) {
+	public Void visitIterator(Map<TypeParameter, GenericTypeID> context, IteratorTypeID iterator) {
 		for (StoredType type : iterator.iteratorTypes)
 			type.type.accept(context, this);
 		return null;
 	}
 
 	@Override
-	public Void visitFunction(Map<TypeParameter, TypeID> context, FunctionTypeID function) {
+	public Void visitFunction(Map<TypeParameter, GenericTypeID> context, FunctionTypeID function) {
 		function.header.getReturnType().type.accept(context, this);
 		for (FunctionParameter parameter : function.header.parameters)
 			parameter.type.type.accept(context, this);
 	}
 
 	@Override
-	public Void visitDefinition(Map<TypeParameter, TypeID> context, DefinitionTypeID definition) {
-		for (TypeID argument : definition.typeArguments)
-			argument.accept(context, this);
+	public Void visitDefinition(Map<TypeParameter, GenericTypeID> context, DefinitionTypeID definition) {
+		for (TypeArgument argument : definition.typeArguments)
+			argument.type.accept(context, this);
 		if (definition.outer != null)
 			visitDefinition(context, definition.outer);
 		return null;
 	}
 
 	@Override
-	public Void visitGeneric(Map<TypeParameter, TypeID> context, GenericTypeID generic) {
+	public Void visitGeneric(Map<TypeParameter, GenericTypeID> context, GenericTypeID generic) {
 		map.put(generic.parameter, generic);
 		return null;
 	}
 
 	@Override
-	public Void visitRange(Map<TypeParameter, TypeID> context, RangeTypeID range) {
+	public Void visitRange(Map<TypeParameter, GenericTypeID> context, RangeTypeID range) {
 		range.baseType.type.accept(context, this);
 		return null;
 	}
 
 	@Override
-	public Void visitModified(Map<TypeParameter, TypeID> context, ModifiedTypeID type) {
+	public Void visitModified(Map<TypeParameter, GenericTypeID> context, ModifiedTypeID 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, TypeID[] typeArguments) {
+	public IPartialExpression getExpression(CodePosition position, BaseScope scope, TypeArgument[] typeArguments) {
 		return new PartialTypeExpression(position, scope.getTypeRegistry().getForDefinition(definition, typeArguments), typeArguments);
 	}
 
 	@Override
-	public TypeID getType(CodePosition position, TypeResolutionContext context, TypeID[] typeArguments) {
+	public TypeID getType(CodePosition position, TypeResolutionContext context, TypeArgument[] typeArguments) {
 		return context.getTypeRegistry().getForDefinition(definition, typeArguments);
 	}
 }

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

 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;
 			if (expansion.target == null)
 				throw new RuntimeException(expansion.position.toString() + ": Missing expansion target");
 			
-			Map<TypeParameter, TypeID> mapping = matchType(type.type, expansion.target);
+			Map<TypeParameter, TypeArgument> mapping = matchType(type, expansion.target);
 			if (mapping == null)
 				continue;
 			
 		}
 	}
 	
-	private Map<TypeParameter, TypeID> matchType(TypeID type, TypeID pattern) {
+	private Map<TypeParameter, TypeArgument> matchType(StoredType type, TypeArgument pattern) {
 		return type.inferTypeParameters(cache, pattern);
 	}
 
 	@Override
 	public Void visitGenericMap(Void context, GenericMapTypeID map) {
 		TypeParameter functionParameter = new TypeParameter(BUILTIN, "T");
-		Map<TypeParameter, TypeID> parameterFilled = Collections.singletonMap(map.key, registry.getGeneric(functionParameter));
+		Map<TypeParameter, TypeArgument> parameterFilled = Collections.singletonMap(map.key, new TypeArgument(registry.getGeneric(functionParameter), null));
 		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]);
 		HighLevelDefinition definition = definitionType.definition;
 		GenericMapper mapper = null;
 		if (definitionType.hasTypeParameters() || (definitionType.outer != null && definitionType.outer.hasTypeParameters())) {
-			Map<TypeParameter, TypeID> mapping = definitionType.getTypeParameterMapping();
+			Map<TypeParameter, TypeArgument> mapping = definitionType.getTypeParameterMapping();
 			mapper = new GenericMapper(registry, mapping);
 		}
 		
 		if (definition instanceof InterfaceDefinition) {
 			InterfaceDefinition interfaceDefinition = (InterfaceDefinition)definition;
 			for (TypeID baseType : interfaceDefinition.baseInterfaces)
-				cache.get(baseType.instanceUnstored(mapper).stored(type.storage))
+				cache.get(baseType.instance(mapper, type.storage).stored())
 						.copyMembersTo(definitionType.definition.position, members, TypeMemberPriority.INHERITED);
 		}
 		

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, TypeID> mapping = header.getReturnType().inferTypeParameters(scope.getMemberCache(), resultHint);
+					Map<TypeParameter, TypeArgument> mapping = header.getReturnType().inferTypeParameters(scope.getMemberCache(), resultHint.asArgument());
 					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

 	}
 	
 	public boolean extendsOrImplements(TypeID other) {
-		other = other.getNormalizedUnstored();
+		other = other.getNormalized();
 		TypeID superType = type.type.getSuperType(cache.getRegistry());
 		if (superType != null) {
 			if (superType == other)
 	}
 	
 	public boolean extendsType(TypeID other) {
-		other = other.getNormalizedUnstored();
+		other = other.getNormalized();
 		TypeID superType = type.type.getSuperType(cache.getRegistry());
 		if (superType != null) {
 			if (superType == other)
 		
 		if (toType.isOptional() && canCastImplicit(toType.withoutOptional()))
 			return true;
-		if (toType.isConst() && canCastImplicit(toType.withoutConst()))
-			return true;
 		if (type.isOptional() && areEquivalent(type.withoutOptional(), toType))
 			return true;
 		
 			return new NullExpression(position, toType);
 		if (toType.isOptional() && canCastImplicit(toType.withoutOptional()))
 			return castEquivalent(position, new WrapOptionalExpression(position, castImplicit(position, value, toType.withoutOptional(), implicit), toType), toType);
-		if (toType.isConst() && canCastImplicit(toType.withoutConst()))
-			return castEquivalent(position, new MakeConstExpression(position, castImplicit(position, value, toType.withoutConst(), implicit), toType), toType);
 		if (type.isOptional() && areEquivalent(type.withoutOptional(), toType))
 			return castEquivalent(position, new CheckNullExpression(position, value), toType);
 		

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/AnyStorageTag.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/AutoStorageTag.java

  *
  * @author Hoofdgebruiker
  */
-public class AnyStorageTag implements StorageTag {
-	public static final AnyStorageTag INSTANCE = new AnyStorageTag();
+public class AutoStorageTag implements StorageTag {
+	public static final AutoStorageTag INSTANCE = new AutoStorageTag();
 	
-	private AnyStorageTag() {}
+	private AutoStorageTag() {}
 
 	@Override
 	public StorageType getType() {
-		return AnyStorageType.INSTANCE;
+		return AutoStorageType.INSTANCE;
 	}
 	
 	@Override
 	public String toString() {
-		return "any";
+		return "auto";
 	}
 
 	@Override
 	public boolean canCastTo(StorageTag other) {
-		return other == BorrowStorageTag.INVOCATION;
+		return other == BorrowStorageTag.INVOCATION || other == BorrowStorageTag.THIS;
 	}
 
 	@Override
 	public boolean canCastFrom(StorageTag other) {
-		return true;
+		return other == this || other == UniqueStorageTag.INSTANCE || other == StaticStorageTag.INSTANCE;
 	}
 
 	@Override
 	public boolean isDestructible() {
 		return true;
 	}
+	
+	@Override
+	public boolean isConst() {
+		return false;
+	}
+	
+	@Override
+	public boolean isImmutable() {
+		return false;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/AnyStorageType.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/AutoStorageType.java

  *
  * @author Hoofdgebruiker
  */
-public class AnyStorageType implements StorageType {
-	public static final AnyStorageType INSTANCE = new AnyStorageType();
+public class AutoStorageType implements StorageType {
+	public static final AutoStorageType INSTANCE = new AutoStorageType();
 	
-	private AnyStorageType() {}
+	private AutoStorageType() {}
 
 	@Override
 	public String getName() {
 		if (arguments.length > 0)
 			return new InvalidStorageTag(position, CompileExceptionCode.INVALID_STORAGE_TYPE_ARGUMENTS, "any storage type doesn't take arguments");
 		
-		return AnyStorageTag.INSTANCE;
+		return AutoStorageTag.INSTANCE;
 	}
 }

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

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

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

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

 	public boolean isDestructible() {
 		return false;
 	}
+	
+	@Override
+	public boolean isConst() {
+		return false;
+	}
+	
+	@Override
+	public boolean isImmutable() {
+		return false;
+	}
 }

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

 	public boolean isDestructible() {
 		return false;
 	}
+	
+	@Override
+	public boolean isConst() {
+		return false;
+	}
+	
+	@Override
+	public boolean isImmutable() {
+		return false;
+	}
 }

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

 	public boolean isDestructible() {
 		return false;
 	}
+	
+	@Override
+	public boolean isConst() {
+		return false;
+	}
+	
+	@Override
+	public boolean isImmutable() {
+		return false;
+	}
 }

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

 	boolean canCastFrom(StorageTag other);
 	
 	boolean isDestructible();
+	
+	boolean isConst();
+	
+	boolean isImmutable();
+	
+	static StorageTag union(StorageTag minor, StorageTag major) {
+		if (minor == AutoStorageTag.INSTANCE || minor == null)
+			return major;
+		if (major == AutoStorageTag.INSTANCE || major == null)
+			return minor;
+		if (!minor.equals(major))
+			throw new IllegalArgumentException("Could not unite storage types"); // TODO: proper reporting
+		
+		return major;
+	}
 }

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

 public interface StorageType {
 	public static StorageType[] getStandard() {
 		return new StorageType[] {
-			AnyStorageType.INSTANCE,
+			AutoStorageType.INSTANCE,
 			BorrowStorageType.INSTANCE,
 			SharedStorageType.INSTANCE,
 			StaticStorageType.INSTANCE,

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

 	public boolean isDestructible() {
 		return true;
 	}
+	
+	@Override
+	public boolean isConst() {
+		return false;
+	}
+	
+	@Override
+	public boolean isImmutable() {
+		return false;
+	}
 }

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

 
 	@Override
 	public boolean canCastTo(StorageTag other) {
-		return other == this;
+		return true;
 	}
 
 	@Override
 	public boolean canCastFrom(StorageTag other) {
-		return other == this;
+		return true;
 	}
 
 	@Override
 	public boolean isDestructible() {
 		return false;
 	}
+	
+	@Override
+	public boolean isConst() {
+		return false;
+	}
+	
+	@Override
+	public boolean isImmutable() {
+		return false;
+	}
 }

CompilerShared/src/main/java/org/openzen/zenscript/compiler/BuiltinCompilePlugin.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.compiler;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
+import org.openzen.zenscript.codemodel.annotations.NativeAnnotationDefinition;
+import org.openzen.zenscript.codemodel.annotations.PreconditionAnnotationDefinition;
+import org.openzen.zenscript.codemodel.type.storage.StorageType;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class BuiltinCompilePlugin implements CompilePlugin {
+	public static final BuiltinCompilePlugin BUILTIN = new BuiltinCompilePlugin();
+	
+	private final List<AnnotationDefinition> annotations;
+	private final List<StorageType> storageTypes;
+	
+	private BuiltinCompilePlugin() {
+		annotations = Arrays.asList(
+				NativeAnnotationDefinition.INSTANCE,
+				PreconditionAnnotationDefinition.INSTANCE
+		);
+		
+		storageTypes = Arrays.asList(StorageType.getStandard());
+	}
+
+	@Override
+	public List<ZenCodeCompiler> getCompilers() {
+		return Collections.emptyList();
+	}
+
+	@Override
+	public List<AnnotationDefinition> getAnnotations() {
+		return annotations;
+	}
+
+	@Override
+	public List<StorageType> getStorageTypes() {
+		return storageTypes;
+	}
+}

CompilerShared/src/main/java/org/openzen/zenscript/compiler/CompilePlugin.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.compiler;
+
+import java.util.List;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
+import org.openzen.zenscript.codemodel.type.storage.StorageType;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface CompilePlugin {
+	List<ZenCodeCompiler> getCompilers();
+	
+	List<AnnotationDefinition> getAnnotations();
+	
+	List<StorageType> getStorageTypes();
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/editor/SourceEditor.java

 					return KEYWORD;
 					
 				case K_VOID:
-				case K_ANY:
 				case K_BOOL:
 				case K_BYTE:
 				case K_SBYTE:

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaBytecodeContext.java

 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.SharedStorageTag;
 import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
 import org.openzen.zenscript.javashared.JavaContext;
 import org.openzen.zenscript.javashared.JavaSyntheticClassGenerator;
 import org.openzen.zenscript.javashared.JavaTypeDescriptorVisitor;
 import org.openzen.zenscript.javashared.JavaTypeInternalNameVisitor;
+import org.openzen.zenscript.javashared.JavaTypeUtils;
 
 /**
  *
 	
 	@Override
 	public String getDescriptor(StoredType type) {
-		if (type.storage == SharedStorageTag.INSTANCE && type.isDestructible())
+		if (JavaTypeUtils.isShared(type))
 			return "Lzsynthetic/Shared";
 		
 		return type.type.accept(descriptorVisitor);

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

 import java.io.IOException;
 import java.lang.reflect.Modifier;
 import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
-import org.openzen.zenscript.codemodel.type.storage.SharedStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaField;
 import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaTypeUtils;
 import org.openzen.zenscript.javashared.JavaVariantOption;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 		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;
-			if (fromTag == SharedStorageTag.INSTANCE && toTag == BorrowStorageTag.INVOCATION) {
+			if (JavaTypeUtils.isShared(fromTag) && toTag == BorrowStorageTag.INVOCATION) {
 				// Shared<T>.get()
 				javaWriter.invokeVirtual(SHARED_GET);
-			} else if (fromTag == UniqueStorageTag.INSTANCE && toTag == SharedStorageTag.INSTANCE) {
+			} else if (fromTag == UniqueStorageTag.INSTANCE && JavaTypeUtils.isShared(toTag)) {
 				// new Shared<T>(value)
 				javaWriter.newObject("zsynthetic/Shared");
 				javaWriter.dup();

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

 		if (definition.typeArguments.length > 0) {
 			result.append("With");
 			for (int i = 0; i < definition.typeArguments.length; i++) {
-				result.append(definition.typeArguments[i].accept(null, this));
+				result.append(definition.typeArguments[i].type.accept(null, this));
 			}
 		}
 		return result.toString();

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

 import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
 import org.openzen.zenscript.codemodel.type.*;
-import org.openzen.zenscript.codemodel.type.storage.SharedStorageTag;
 
 public class JavaTypeDescriptorVisitor implements TypeVisitor<String> {
 	private final JavaTypeDescriptorVisitor forOptional;
 	}
 	
 	public String process(StoredType type) {
-		if (type.isDestructible() && type.storage == SharedStorageTag.INSTANCE)
+		if (JavaTypeUtils.isShared(type))
 			return "L" + JavaClass.SHARED.internalName + ";";
 		
 		return type.type.accept(this);

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

 
 		if (definition.typeArguments.length > 0) {
 			builder.append("<");
-			for (TypeID typeParameter : definition.typeArguments) {
-				builder.append(typeParameter.accept(null, this));
+			for (TypeArgument typeParameter : definition.typeArguments) {
+				builder.append(typeParameter.type.accept(null, this));
 			}
 			builder.append(">");
 		}

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaTypeUtils.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.javashared;
+
+import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.SharedStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaTypeUtils {
+	private JavaTypeUtils() {}
+	
+	public static boolean isShared(StoredType type) {
+		return type.type.isDestructible() && isShared(type.storage);
+	}
+	
+	public static boolean isShared(StorageTag storage) {
+		return storage == SharedStorageTag.INSTANCE || storage == AutoStorageTag.INSTANCE;
+	}
+}

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.TypeID;
+import org.openzen.zenscript.codemodel.type.TypeArgument;
 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 (TypeID typeArgument : arguments.typeArguments) {
+			for (TypeArgument typeArgument : arguments.typeArguments) {
 				if (index > 0)
 					result.append(", ");
 				result.append(scope.type(typeArgument));
 			result.append("<");
 			
 			int index = 0;
-			for (TypeID typeArgument : arguments.typeArguments) {
+			for (TypeArgument 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.TypeID;
 import org.openzen.zenscript.compiler.CompileScope;
 import org.openzen.zenscript.compiler.SemanticModule;
 		output.append(" {\n");
 		output.append(indent).append(settings.indent).append("private ").append(cls.getName()).append("() {}\n");
 		
-		JavaExpansionMemberCompiler memberCompiler = new JavaExpansionMemberCompiler(settings, definition.target, definition.typeParameters, "\t", output, scope, definition);
+		JavaExpansionMemberCompiler memberCompiler = new JavaExpansionMemberCompiler(settings, definition.target.type, definition.typeParameters, "\t", output, scope, definition);
 		for (IDefinitionMember member : definition.members)
 			member.accept(memberCompiler);
 		memberCompiler.finish();
 	private void compileExpansions() {
 		for (ExpansionDefinition definition : expansions) {
 			JavaSourceFileScope scope = createScope(definition);
-			JavaExpansionMemberCompiler memberCompiler = new JavaExpansionMemberCompiler(settings, definition.target, definition.typeParameters, indent + settings.indent, output, scope, definition);
+			JavaExpansionMemberCompiler memberCompiler = new JavaExpansionMemberCompiler(settings, definition.target.type, definition.typeParameters, indent + settings.indent, output, scope, definition);
 			for (IDefinitionMember member : definition.members)
 				member.accept(memberCompiler);
 			memberCompiler.finish();
 	
 	private void compileMembers(JavaSourceFileScope scope, HighLevelDefinition definition) {
 		if (definition.hasTag(JavaNativeClass.class)) {
-			TypeID[] typeParameters = new TypeID[definition.getNumberOfGenericParameters()];
+			TypeArgument[] typeParameters = new TypeArgument[definition.getNumberOfGenericParameters()];
 			for (int i = 0; i < typeParameters.length; i++)
-				typeParameters[i] = scope.semanticScope.getTypeRegistry().getGeneric(definition.typeParameters[i]);
+				typeParameters[i] = new TypeArgument(scope.semanticScope.getTypeRegistry().getGeneric(definition.typeParameters[i]), 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.TypeID;
+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.SharedStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 import org.openzen.zenscript.formattershared.ExpressionString;
 import org.openzen.zenscript.javashared.JavaNativeTranslator;
 import org.openzen.zenscript.javashared.JavaMethod;
 import org.openzen.zenscript.javashared.JavaSynthesizedFunctionInstance;
+import org.openzen.zenscript.javashared.JavaTypeUtils;
 import org.openzen.zenscript.javashared.JavaVariantOption;
 
 /**
 		if (expression.value.type.isDestructible()) {
 			StorageTag fromTag = expression.value.type.storage;
 			StorageTag toTag = expression.type.storage;
-			if (fromTag == SharedStorageTag.INSTANCE) {
+			if (JavaTypeUtils.isShared(fromTag)) {
 				// Shared<T>.get()
 				return value.unaryPostfix(JavaOperator.CALL, ".get()");
-			} else if (fromTag == UniqueStorageTag.INSTANCE && toTag == SharedStorageTag.INSTANCE) {
+			} else if (fromTag == UniqueStorageTag.INSTANCE && JavaTypeUtils.isShared(toTag)) {
 				// new Shared<T>(value)
 				return new ExpressionString("new " + scope.type(JavaClass.SHARED) + "<>(" + value.value + ")", JavaOperator.NEW);
 			}
 		return expression.value.accept(this);
 	}
 	
-	private String formatTypeArguments(TypeID[] types) {
+	private String formatTypeArguments(TypeArgument[] types) {
 		if (types == null || types.length == 0)
 			return "";
 		
 			if (i > 0)
 				output.append(", ");
 			
-			output.append(types[i].accept(scope.fileScope.objectTypeVisitor));
+			output.append(types[i].type.accept(scope.fileScope.objectTypeVisitor));
 		}
 		output.append(">");
 		return output.toString();
 		output.append(method).append("(");
 		boolean first = true;
 		if (expression.arguments.typeArguments != null) {
-			for (TypeID typeArgument : expression.arguments.typeArguments) {
+			for (TypeArgument typeArgument : expression.arguments.typeArguments) {
 				if (!first)
 					output.append(", ");
 				
-				if (typeArgument instanceof GenericTypeID) {
-					output.append("typeOf").append(((GenericTypeID) typeArgument).parameter.name);
+				if (typeArgument.type instanceof GenericTypeID) {
+					output.append("typeOf").append(((GenericTypeID) typeArgument.type).parameter.name);
 				} else {
 					output.append(scope.type(typeArgument));
 					output.append(".class");

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

 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaSynthesizedFunctionInstance;
 import org.openzen.zenscript.codemodel.type.TypeVisitor;
-import org.openzen.zenscript.codemodel.type.storage.SharedStorageTag;
+import org.openzen.zenscript.javashared.JavaTypeUtils;
 
 /**
  *
 	}
 	
 	public String process(StoredType type) {
-		if (type.isDestructible() && type.storage == SharedStorageTag.INSTANCE)
+		if (JavaTypeUtils.isShared(type))
 			return importer.importType(JavaClass.SHARED) + "<" + type.type.accept(this) + ">";
 		
 		return type.type.accept(this);
 			for (int i = 0; i < type.typeArguments.length; i++) {
 				if (i > 0)
 					output.append(", ");
-				output.append(type.typeArguments[i].accept(objectTypeVisitor));
+				output.append(type.typeArguments[i].type.accept(objectTypeVisitor));
 			}
 			output.append(">");
 		}

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

 import org.openzen.zenscript.codemodel.annotations.NativeAnnotationDefinition;
 import org.openzen.zenscript.codemodel.annotations.PreconditionAnnotationDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.codemodel.type.storage.AnyStorageType;
+import org.openzen.zenscript.codemodel.type.storage.AutoStorageType;
 import org.openzen.zenscript.codemodel.type.storage.BorrowStorageType;
 import org.openzen.zenscript.codemodel.type.storage.SharedStorageType;
 import org.openzen.zenscript.codemodel.type.storage.StaticStorageType;

Parser/src/main/java/org/openzen/zenscript/lexer/ZSTokenType.java

 	T_WHITESPACE_CARRIAGE_RETURN(true, "\r", "\r"),
 	T_IDENTIFIER("@?[a-zA-Z_][a-zA-Z_0-9]*"),
 	T_LOCAL_IDENTIFIER("$[a-zA-Z_][a-zA-Z_0-9]*"),
-	T_FLOAT("\\-?(0|[1-9][0-9]*)\\.[0-9]+([eE][\\+\\-]?[0-9]+)?[a-zA-Z_]"),
+	T_FLOAT("\\-?(0|[1-9][0-9]*)\\.[0-9]+([eE][\\+\\-]?[0-9]+)?[a-zA-Z_]*"),
 	T_INT("\\-?(0|[1-9][0-9_]*)[a-zA-Z_]*"),
-	T_PREFIXED_INT("\\-?(0b|0x|0o|0B|0X|0O)(0|[1-9a-fA-F][0-9a-fA-F_]*)(u|U|l|L|ul|UL)?"),
-	T_STRING_SQ("\"([^\"\\\\\\n]|\\\\([\'\"\\\\/bfnrt&]|u[0-9a-fA-F]{4}))*\""),
-	T_STRING_DQ("\'([^\'\\\\\\n]|\\\\([\'\"\\\\/bfnrt&]|u[0-9a-fA-F]{4}))*\'"),
+	T_PREFIXED_INT("\\-?(0b|0x|0o|0B|0X|0O)(0|[1-9a-fA-F][0-9a-fA-F_]*)[a-zA-Z_]*"),
+	T_STRING_DQ("\"([^\"\\\\\\n]|\\\\([\'\"\\\\/bfnrt&]|u[0-9a-fA-F]{4}))*\""),
+	T_STRING_DQ_WYSIWYG("@\"[^\"]\""),
+	T_STRING_SQ("\'([^\'\\\\\\n]|\\\\([\'\"\\\\/bfnrt&]|u[0-9a-fA-F]{4}))*\'"),
+	T_STRING_SQ_WYSIWYG("@\'[^\']\'"),
 	T_AOPEN("\\{", "{"),
 	T_ACLOSE("\\}", "}"),
 	T_SQOPEN("\\[", "["),
 	T_XORASSIGN("\\^=", "^="),
 	T_XOR("\\^", "^"),
 	T_COALESCE("\\?\\?", "??"),
+	T_OPTCALL("\\?\\.", "?."),
 	T_QUEST("\\?", "?"),
 	T_COLON(":", ":"),
 	T_BROPEN("\\(", "("),
 	K_SET(true, "set"),
 	
 	K_VOID(true, "void"),
-	K_ANY(true, "any"),
 	K_BOOL(true, "bool"),
 	K_BYTE(true, "byte"),
 	K_SBYTE(true, "sbyte"),

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;
 
 /**
  *
 		try {
 			AnnotationDefinition annotationType = type.compileAnnotation(scope);
 			ExpressionScope evalScope = annotationType.getScopeForMember(member, scope);
-			TypeID[] types = type.compileTypeArguments(scope);
+			TypeArgument[] 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);
-			TypeID[] types = type.compileTypeArguments(scope);
+			TypeArgument[] 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);
-			TypeID[] types = type.compileTypeArguments(scope);
+			TypeArgument[] 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);
-			TypeID[] types = type.compileTypeArguments(scope);
+			TypeArgument[] 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/ParsedFile.java

 	}
 	
 	public boolean hasErrors() {
-		return false;
+		return errors.size() > 0;
 	}
 	
-	public void printErrors() {
-		
+	public List<ParseException> getErrors() {
+		return errors;
 	}
 	
 	public void listDefinitions(PackageDefinitions definitions) {

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.TypeID;
+import org.openzen.zenscript.codemodel.type.TypeArgument;
 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, TypeID.NONE);
+		DefinitionTypeID type = scope.getTypeRegistry().getForDefinition(compiled, TypeArgument.NONE);
 		ExpressionScope evalScope = new ExpressionScope(scope);
 		for (ParsedEnumConstant constant : enumValues) {
 			constant.compileCode(type, evalScope);

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.compileUnstored(context);
+		compiled.target = target.compileArgument(context);
 		if (compiled.target == null)
 			throw new RuntimeException(position + ": Could not compile expansion target: " + target);
 		

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

 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.type.IParsedType;
+import org.openzen.zenscript.parser.type.ParsedStorageTag;
 
 /**
  *
 	public static ParsedTypeParameter parse(ZSTokenParser tokens) throws ParseException {
 		CodePosition position = tokens.getPosition();
 		ZSToken name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected");
+		ParsedStorageTag storage = ParsedStorageTag.parse(tokens);
 		List<ParsedGenericBound> bounds = new ArrayList<>();
 		while (tokens.optional(ZSTokenType.T_COLON) != null) {
 			if (tokens.optional(ZSTokenType.K_SUPER) != null) {
 				bounds.add(new ParsedTypeBound(tokens.getPosition(), IParsedType.parse(tokens)));
 			}
 		}
-		return new ParsedTypeParameter(position, name.content, bounds);
+		return new ParsedTypeParameter(position, name.content, storage, bounds);
 	}
 	
 	public static List<ParsedTypeParameter> parseAll(ZSTokenParser tokens) throws ParseException {
 		for (int i = 0; i < compiled.length; i++) {
 			for (ParsedGenericBound bound : parameters.get(i).bounds)
 				compiled[i].addBound(bound.compile(context));
+			
+			compiled[i].storage = parameters.get(i).storage == null ? null : parameters.get(i).storage.resolve(parameters.get(i).position, context);
 		}
 	}
 	
 	
 	public final CodePosition position;
 	public final String name;
+	public final ParsedStorageTag storage;
 	public final List<ParsedGenericBound> bounds;
 	
 	public final TypeParameter compiled;
 	
-	public ParsedTypeParameter(CodePosition position, String name, List<ParsedGenericBound> bounds) {
+	public ParsedTypeParameter(CodePosition position, String name, ParsedStorageTag storage, List<ParsedGenericBound> bounds) {
 		this.position = position;
 		this.name = name;
+		this.storage = storage;
 		this.bounds = bounds;
 		
 		compiled = new TypeParameter(position, name);

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

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

 
 		IPartialExpression cReceiver = receiver.compile(scope.withoutHints());
 		List<FunctionHeader> headers = cReceiver.getPossibleFunctionHeaders(scope, scope.hints, arguments.arguments.size());
-		CallArguments callArguments = arguments.compileCall(position, scope, cReceiver.getGenericCallTypes(), headers);
+		CallArguments callArguments = arguments.compileCall(position, scope, cReceiver.getTypeArguments(), headers);
 		return cReceiver.call(position, scope, scope.hints, callArguments);
 	}
 	

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.TypeID;
+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, TypeID.NONE, method.getHeader());
+						CallArguments arguments = parsedArguments.compileCall(position, scope, TypeArgument.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.TypeID;
-import org.openzen.zenscript.codemodel.type.storage.SharedStorageTag;
+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;
 import org.openzen.zenscript.parser.statements.ParsedFunctionBody;
 	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		FunctionHeader definedHeader = header.compile(scope);
 		FunctionHeader header = definedHeader;
-		StorageTag storage = SharedStorageTag.INSTANCE;
+		StorageTag storage = AutoStorageTag.INSTANCE;
 		for (StoredType hint : scope.hints) {
 			if (hint.getNormalized().type instanceof FunctionTypeID) {
 				FunctionTypeID functionHint = (FunctionTypeID) hint.getNormalized().type;
 		if (!scope.genericInferenceMap.isEmpty()) {
 			// perform type parameter inference
 			StoredType returnType = statements.getReturnType();
-			Map<TypeParameter, TypeID> inferredTypes = returnType.type.inferTypeParameters(scope.getMemberCache(), genericHeader.getReturnType().type);
+			Map<TypeParameter, TypeArgument> inferredTypes = returnType.type.inferTypeParameters(scope.getMemberCache(), genericHeader.getReturnType().asArgument());
 			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.TypeID;
+import org.openzen.zenscript.codemodel.type.TypeArgument;
 
 /**
  *
 		}
 
 		@Override
-		public TypeID[] getGenericCallTypes() {
+		public TypeArgument[] 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.TypeID;
+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, TypeID.NONE, method.getHeader());
+						CallArguments arguments = parsedArguments.compileCall(position, scope, TypeArgument.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.TypeID;
+import org.openzen.zenscript.codemodel.type.TypeArgument;
 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());
-		TypeID[] typeParameters = IParsedType.compileList(genericParameters, scope);
+		TypeArgument[] typeArguments = IParsedType.compileArguments(genericParameters, scope);
 		IPartialExpression member = cValue.getMember(
 				position,
 				scope,
 				scope.hints,
-				new GenericName(this.member, typeParameters));
+				new GenericName(this.member, typeArguments));
 		if (member == null) {
 			TypeMembers members = scope.getTypeMembers(cValue.eval().type);
 			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Member not found: " + this.member);

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.TypeID;
+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;
 import org.openzen.zenscript.parser.type.IParsedType;
-import org.openzen.zenscript.parser.type.ParsedStorageTag;
 import org.openzen.zenscript.parser.type.ParsedTypeBasic;
 
 /**
  */
 public class ParsedExpressionVariable extends ParsedExpression {
 	public final String name;
-	private final List<IParsedType> genericParameters;
+	private final List<IParsedType> typeArguments;
 	
-	public ParsedExpressionVariable(CodePosition position, String name, List<IParsedType> genericParameters) {
+	public ParsedExpressionVariable(CodePosition position, String name, List<IParsedType> typeArguments) {
 		super(position);
 
 		this.name = name;
-		this.genericParameters = genericParameters;
+		this.typeArguments = typeArguments;
 	}
 
 	@Override
 	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
-		TypeID[] genericArguments = TypeID.NONE;
-		if (genericParameters != null) {
-			genericArguments = new TypeID[genericParameters.size()];
-			for (int i = 0; i < genericParameters.size(); i++) {
-				genericArguments[i] = genericParameters.get(i).compileUnstored(scope);
-			}
-		}
-		
-		IPartialExpression result = scope.get(position, new GenericName(name, genericArguments));
+		TypeArgument[] typeArguments = IParsedType.compileArguments(this.typeArguments, scope);
+		IPartialExpression result = scope.get(position, new GenericName(name, typeArguments));
 		if (result == null) {
 			for (StoredType hint : scope.hints) {
 				TypeMembers members = scope.getTypeMembers(hint);

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.type, cValue.thrownType.type);
+			DefinitionTypeID resultType = scope.getTypeRegistry().getForDefinition(result, cValue.type.asArgument(), cValue.thrownType.asArgument());
 			return new TryConvertExpression(position, resultType.stored(cValue.type.storage), 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

 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
 				return new TryRethrowAsExceptionExpression(position, cSource.type, cSource, cSource.thrownType);
 			} else {
 				// rethrow as result
-				StoredType resultType = scope.getTypeRegistry().getForDefinition(result, cSource.type.type, cSource.thrownType.type).stored(cSource.thrownType.storage);
+				StoredType resultType = scope.getTypeRegistry().getForDefinition(result, cSource.type.asArgument(), cSource.thrownType.asArgument()).stored(cSource.thrownType.storage);
 				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(sourceType.typeArguments[0].isValueType() ? ValueStorageTag.INSTANCE : cSource.type.storage), cSource);
+					return new TryRethrowAsResultExpression(position, sourceType.typeArguments[0].stored(), cSource);
 				}
 			}
 			

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

 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;
 		return result;
 	}
 	
+	public static TypeArgument[] compileArguments(List<IParsedType> typeParameters, TypeResolutionContext context) {
+		TypeArgument[] result = TypeArgument.NONE;
+		if (typeParameters != null && typeParameters.size() > 0) {
+			result = new TypeArgument[typeParameters.size()];
+			for (int i = 0; i < typeParameters.size(); i++) {
+				result[i] = typeParameters.get(i).compileArgument(context);
+			}
+		}
+		return result;
+	}
+	
 	public IParsedType withOptional();
 	
 	public IParsedType withModifiers(int modifiers);
 	
 	public TypeID compileUnstored(TypeResolutionContext context);
 	
+	public TypeArgument compileArgument(TypeResolutionContext context);
+	
 	public default AnnotationDefinition compileAnnotation(BaseScope scope) {
 		return null;
 	}
 	
-	public default TypeID[] compileTypeArguments(BaseScope scope) {
-		return TypeID.NONE;
+	public default TypeArgument[] compileTypeArguments(BaseScope scope) {
+		return TypeArgument.NONE;
 	}
 }

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

 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.storage.SharedStorageTag;
+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;
 
 /**
  *
 
 	@Override
 	public StoredType compile(TypeResolutionContext context) {
-		StorageTag storage = this.storage == null ? SharedStorageTag.INSTANCE : this.storage.resolve(position, 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);
 	}
 	
 		
 		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);
+	}
 }

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

 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.SharedStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
-import org.openzen.zenscript.codemodel.type.storage.ValueStorageType;
 
 /**
  *
 		
 		StorageTag storage;
 		if (this.storage == ParsedStorageTag.NULL) {
-			storage = result.isValueType() ? ValueStorageTag.INSTANCE : SharedStorageTag.INSTANCE;
+			storage = AutoStorageTag.INSTANCE;
 		} else {
 			storage = this.storage.resolve(position, context);
 		}
 		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 TypeID[] compileTypeArguments(BaseScope scope) {
+	public TypeArgument[] compileTypeArguments(BaseScope scope) {
 		ParsedNamePart last = name.get(name.size() - 1);
-		return IParsedType.compileListUnstored(last.typeArguments, scope);
+		return IParsedType.compileArguments(last.typeArguments, scope);
 	}
 	
 	private StoredType toIterator(TypeResolutionContext 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);
 	}
 	
 		}
 		
 		private GenericName compile(TypeResolutionContext context) {
-			return new GenericName(name, IParsedType.compileListUnstored(typeArguments, context));
+			return new GenericName(name, IParsedType.compileArguments(typeArguments, context));
 		}
 		
 		@Override

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

 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;
 
 /**
 	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/ParsedStorageTag.java

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
-import org.openzen.zenscript.codemodel.type.storage.SharedStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 	
 	public StorageTag resolve(CodePosition position, TypeResolutionContext context) {
 		if (this == NULL)
-			return SharedStorageTag.INSTANCE;
+			return null;
 		
 		return context.getStorageTag(position, name, arguments);
 	}