WIP on storage tags

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

 import org.openzen.zenscript.codemodel.expression.SetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
+import org.openzen.zenscript.codemodel.expression.StorageCastExpression;
 import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
 import org.openzen.zenscript.codemodel.expression.ThrowExpression;
 				ZenScriptOperator.ASSIGN);
 	}
 	
+	@Override
+	public ExpressionString visitStorageCast(StorageCastExpression expression) {
+		return expression.value.accept(this);
+	}
+	
 	@Override
 	public ExpressionString visitSupertypeCast(SupertypeCastExpression expression) {
 		return expression.value.accept(this);

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
 import stdlib.Chars;
 import org.openzen.zenscript.codemodel.type.TypeVisitor;
 
 	public String visitBasic(BasicTypeID basic) {
 		return basic.name;
 	}
+	
+	@Override
+	public String visitString(StringTypeID string) {
+		if (string.storage == null)
+			return "string";
+		else
+			return "string`" + string.storage.toString();
+	}
 
 	@Override
 	public String visitArray(ArrayTypeID array) {
 		String element = array.elementType.accept(this);
+		String result;
 		if (array.dimension == 1) {
-			return element + "[]";
+			result = element + "[]";
 		} else {
-			return element + "[" + Chars.times(',', array.dimension - 1) + "]";
+			result = element + "[" + Chars.times(',', array.dimension - 1) + "]";
 		}
+		if (array.storage == null)
+			return result;
+		
+		return result + '`' + array.storage.toString();
 	}
 
 	@Override
 	public String visitAssoc(AssocTypeID assoc) {
-		return assoc.valueType.accept(this) + "[" + assoc.keyType.accept(this) + "]";
+		String result = assoc.valueType.accept(this) + "[" + assoc.keyType.accept(this) + "]";
+		if (assoc.storage == null)
+			return result;
+		
+		return result + '`' + assoc.storage.toString();
 	}
 
 	@Override
 		StringBuilder result = new StringBuilder();
 		result.append("function");
 		FormattingUtils.formatHeader(result, settings, function.header, this);
+		
+		if (function.storage != null) {
+			result.append('`');
+			result.append(function.storage.toString());
+		}
+		
 		return result.toString();
 	}
 
 	@Override
 	public String visitDefinition(DefinitionTypeID definition) {
 		String importedName = importer.importDefinition(definition.definition);
-		if (definition.typeParameters == null)
+		if (definition.typeArguments == null)
 			return importedName;
 		
 		StringBuilder result = new StringBuilder();
 		result.append(importedName);
 		result.append("<");
 		int index = 0;
-		for (ITypeID typeParameter : definition.typeParameters) {
+		for (ITypeID typeParameter : definition.typeArguments) {
 			if (index > 0)
 				result.append(", ");
 			
 			result.append(typeParameter.accept(this));
 		}
 		result.append(">");
+		
+		if (definition.storage != null) {
+			result.append('`');
+			result.append(definition.storage.toString());
+		}
+		
 		return result.toString();
 	}
 
 	@Override
 	public String visitGeneric(GenericTypeID generic) {
-		return generic.parameter.name;
+		if (generic.storage == null)
+			return generic.parameter.name;
+		
+		return generic.parameter.name + '`' + generic.storage.toString();
 	}
 
 	@Override
 		result.append("[<");
 		FormattingUtils.formatTypeParameters(result, new TypeParameter[] { map.key }, this);
 		result.append("]>");
+		
+		if (map.storage != null) {
+			result.append('`');
+			result.append(map.storage.toString());
+		}
+		
 		return result.toString();
 	}
 }

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

  * @author Hoofdgebruiker
  */
 public class FunctionHeader {
-	private static final FunctionParameter[] NO_PARAMETERS = new FunctionParameter[0];
-	
 	public final TypeParameter[] typeParameters;
 	private ITypeID returnType;
 	public final FunctionParameter[] parameters;
 		
 		this.typeParameters = TypeParameter.NONE;
 		this.returnType = returnType;
-		this.parameters = NO_PARAMETERS;
+		this.parameters = FunctionParameter.NONE;
 		this.thrownType = null;
 		
 		minParameters = 0;
 		if (typeParameters.length > 0) {
 			Map<TypeParameter, ITypeID> innerMap = new HashMap<>();
 			for (TypeParameter parameter : typeParameters)
-				innerMap.put(parameter, mapper.registry.getGeneric(parameter));
+				innerMap.put(parameter, mapper.registry.getGeneric(parameter, null));
 			
 			mapper = mapper.getInner(registry, innerMap);
 		}

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

 		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).withStorage(registry, type.storage) : type;
 	}
 	
 	public FunctionHeader map(FunctionHeader original) {
 	public GenericMapper getInner(GlobalTypeRegistry registry, TypeParameter[] parameters) {
 		Map<TypeParameter, ITypeID> resultMap = new HashMap<>(this.mapping);
 		for (TypeParameter parameter : parameters)
-			resultMap.put(parameter, registry.getGeneric(parameter));
+			resultMap.put(parameter, registry.getGeneric(parameter, null));
 		return new GenericMapper(registry, resultMap);
 	}
 	

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

 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
+import org.openzen.zenscript.codemodel.type.storage.StaticStorageTag;
 
 /**
  *
 	public List<FunctionHeader> getInitializers(BaseScope scope) {
 		return Collections.singletonList(new FunctionHeader(
 				BasicTypeID.VOID,
-				scope.getType(CodePosition.BUILTIN, enforcementLevelName),
+				scope.getType(CodePosition.BUILTIN, enforcementLevelName, StaticStorageTag.INSTANCE),
 				BasicTypeID.BOOL,
 				StringTypeID.UNIQUE));
 	}

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

 		
 		if (types.containsKey(name.get(index).name)) {
 			CompilingType type = types.get(name.get(index).name);
-			DefinitionTypeID result = context.getTypeRegistry().getForDefinition(type.load(), name.get(index).arguments);
+			DefinitionTypeID result = context.getTypeRegistry().getForDefinition(type.load(), null, name.get(index).arguments);
 			return getInner(context, name, index + 1, type, result);
 		}
 		
 		if (innerType == null)
 			return null;
 		
-		DefinitionTypeID innerResult = context.getTypeRegistry().getForDefinition(innerType.load(), name.get(index).arguments, result);
+		DefinitionTypeID innerResult = context.getTypeRegistry().getForDefinition(innerType.load(), name.get(index).arguments, result, null);
 		return getInner(context, name, index + 1, innerType, innerResult);
 	}
 }

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

 	HighLevelDefinition load();
 	
 	default DefinitionTypeID getInnerType(GlobalTypeRegistry registry, List<GenericName> name, int index, DefinitionTypeID outer) {
-		DefinitionTypeID type = registry.getForDefinition(load(), name.get(index).arguments, outer);
+		DefinitionTypeID type = registry.getForDefinition(load(), name.get(index).arguments, outer, null);
 		index++;
 		if (index == name.size())
 			return type;

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
+	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
 		if (imports.containsKey(name.get(0).name)) {
 			return GenericName.getInnerType(
 					getTypeRegistry(),
-					getTypeRegistry().getForDefinition(imports.get(name.get(0).name), name.get(0).arguments),
+					getTypeRegistry().getForDefinition(imports.get(name.get(0).name), null, name.get(0).arguments),
 					name,
-					1);
+					1,
+					storage);
 		}
 		
 		ITypeID moduleType = modulePackage.getType(this, name);
 		if (moduleType != null)
 			return moduleType;
 		
-		return module.getType(position, name);
+		return module.getType(position, name, storage);
+	}
+	
+	@Override
+	public StorageTag getStorageTag(CodePosition position, String name, String[] arguments) {
+		return module.getStorageTag(position, name, arguments);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
+	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
 		if (type != null) {
 			CompilingType compiling = type.getInner(name.get(0).name);
 			if (compiling != null) {
 		if (name.size() == 1 && name.get(0).hasNoArguments()) {
 			for (TypeParameter parameter : parameters)
 				if (parameter.name.equals(name.get(0).name))
-					return getTypeRegistry().getGeneric(parameter);
+					return getTypeRegistry().getGeneric(parameter, storage);
 		}
 		
-		return outer.getType(position, name);
+		return outer.getType(position, name, storage);
+	}
+
+	@Override
+	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
+		return outer.getStorageTag(position, name, parameters);
 	}
 	
 	@Override

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

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

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

 	public GenericMapper getMapper() {
 		Map<TypeParameter, ITypeID> mapper = new HashMap<>();
 		for (TypeParameter parameter : typeParameters)
-			mapper.put(parameter, moduleContext.registry.getGeneric(parameter));
+			mapper.put(parameter, moduleContext.registry.getGeneric(parameter, null));
 		return new GenericMapper(moduleContext.registry, mapper);
 	}
 	

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	
 	AnnotationDefinition getAnnotation(String name);
 	
-	ITypeID getType(CodePosition position, List<GenericName> name);
+	ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage);
+	
+	StorageTag getStorageTag(CodePosition position, String name, String[] parameters);
 	
 	ITypeID getThisType();
 }

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

 	public void setHeader(GlobalTypeRegistry registry, FunctionHeader header) {
 		this.header = header;
 		addMember(caller = new CallerMember(position, this, modifiers | Modifiers.STATIC, header, null));
-		callerGroup.addMethod(new FunctionalMemberRef(caller, registry.getFunction(header), GenericMapper.EMPTY), TypeMemberPriority.SPECIFIED);
+		callerGroup.addMethod(new FunctionalMemberRef(caller, registry.getFunction(header, null), GenericMapper.EMPTY), TypeMemberPriority.SPECIFIED);
 	}
 	
 	public void setCode(Statement statement) {

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 			if (types.get(name.name).typeParameters.length != name.getNumberOfArguments())
 				throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_INVALID_NUMBER, "Invalid number of type arguments");
 			
-			return new PartialTypeExpression(position, registry.getForDefinition(types.get(name.name), name.arguments), name.arguments);
+			return new PartialTypeExpression(position, registry.getForDefinition(types.get(name.name), null, name.arguments), name.arguments);
 		}
 		
 		return null;
 		return null;
 	}
 	
-	public ITypeID getType(CodePosition position, TypeResolutionContext context, List<GenericName> nameParts) {
-		return getType(position, context, nameParts, 0);
+	public ITypeID getType(CodePosition position, TypeResolutionContext context, List<GenericName> nameParts, StorageTag storage) {
+		return getType(position, context, nameParts, 0, storage);
 	}
 	
-	public ITypeID getType(CodePosition position, TypeResolutionContext context, GenericName name) {
+	public ITypeID getType(CodePosition position, TypeResolutionContext context, GenericName name, StorageTag storage) {
 		if (types.containsKey(name.name)) {
-			return context.getTypeRegistry().getForDefinition(types.get(name.name), name.arguments);
+			return context.getTypeRegistry().getForDefinition(types.get(name.name), storage, name.arguments);
 		}
 		
 		return null;
 	}
 	
-	private ITypeID getType(CodePosition position, TypeResolutionContext context, List<GenericName> nameParts, int depth) {
+	private ITypeID getType(CodePosition position, TypeResolutionContext context, List<GenericName> nameParts, int depth, StorageTag storage) {
 		if (depth >= nameParts.size())
 			return null;
 		
 		GenericName name = nameParts.get(depth);
 		if (subPackages.containsKey(name.name) && name.hasNoArguments())
-			return subPackages.get(name.name).getType(position, context, nameParts, depth + 1);
+			return subPackages.get(name.name).getType(position, context, nameParts, depth + 1, storage);
 		
 		if (types.containsKey(name.name)) {
-			DefinitionTypeID type = context.getTypeRegistry().getForDefinition(types.get(name.name), name.arguments);
-			return GenericName.getInnerType(context.getTypeRegistry(), type, nameParts, depth + 1);
+			DefinitionTypeID type = context.getTypeRegistry().getForDefinition(types.get(name.name), null, name.arguments);
+			return GenericName.getInnerType(context.getTypeRegistry(), type, nameParts, depth + 1, storage);
 		}
 		
 		return null;

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

 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.storage.StaticStorageTag;
 
 /**
  *
 	}
 	
 	public EnumConstantExpression(CodePosition position, GlobalTypeRegistry registry, EnumDefinition type, EnumConstantMember value) {
-		super(position, registry.getForDefinition(type), null);
+		super(position, registry.getForDefinition(type, StaticStorageTag.INSTANCE), null);
 		
 		this.value = value;
 	}

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 import stdlib.Strings;
 
 /**
 		List<GenericName> name = new ArrayList<>();
 		for (String namePart : nameParts)
 			name.add(new GenericName(namePart));
-		ITypeID type = scope.getType(position, name);
+		ITypeID type = scope.getType(position, name, UniqueStorageTag.INSTANCE);
 		if (type == null)
 			throw new CompileException(position, CompileExceptionCode.NO_SUCH_TYPE, "No such type: " + typename);
 		

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

 	
 	public T visitStaticSetter(StaticSetterExpression expression);
 	
+	public T visitStorageCast(StorageCastExpression expression);
+	
 	public T visitSupertypeCast(SupertypeCastExpression expression);
 	
 	public T visitThis(ThisExpression expression);

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

 	
 	public R visitStaticSetter(C context, StaticSetterExpression expression);
 	
+	public R visitStorageCast(C context, StorageCastExpression expression);
+	
 	public R visitSupertypeCast(C context, SupertypeCastExpression expression);
 	
 	public R visitThis(C context, ThisExpression expression);

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.expression;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class StorageCastExpression extends Expression {
+	public final Expression value;
+	
+	public StorageCastExpression(CodePosition position, Expression value, ITypeID toType) {
+		super(position, toType, value.thrownType);
+		
+		this.value = value;
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitStorageCast(this);
+	}
+
+	@Override
+	public <C, R> R accept(C context, ExpressionVisitorWithContext<C, R> visitor) {
+		return visitor.visitStorageCast(context, this);
+	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression transformed = transformer.transform(value);
+		return transformed == this ? this : new StorageCastExpression(position, transformed, type);
+	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		Expression normalized = value.normalize(scope);
+		return normalized == value ? this : new StorageCastExpression(position, normalized, type);
+	}
+}

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

 		if (definition.typeParameters != null) {
 			parameters = new ITypeID[definition.typeParameters.length];
 			for (int i = 0; i < parameters.length; i++)
-				parameters[i] = registry.getGeneric(definition.typeParameters[i]);
+				parameters[i] = registry.getGeneric(definition.typeParameters[i], null);
 		}
 		
 		if (autoGetterAccess != 0) {

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

 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 		this.outerTypeArguments = outerTypeArguments;
 	}
 	
-	public DefinitionTypeID instance(GlobalTypeRegistry registry, ITypeID[] typeArguments, DefinitionTypeID outer) {
-		return registry.getForDefinition(definition, typeArguments, outer);
+	public DefinitionTypeID instance(GlobalTypeRegistry registry, ITypeID[] typeArguments, DefinitionTypeID outer, StorageTag storage) {
+		return registry.getForDefinition(definition, typeArguments, outer, storage);
 	}
 }

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

 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 
 /**
  *
 	}
 	
 	private static FunctionHeader createIteratorHeader(GlobalTypeRegistry registry, ITypeID[] iteratorTypes) {
-		return new FunctionHeader(registry.getIterator(iteratorTypes));
+		return new FunctionHeader(registry.getIterator(iteratorTypes, UniqueStorageTag.INSTANCE));
 	}
 }

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

 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
-		return parent.getType(position, name);
+	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
+		return parent.getType(position, name, storage);
+	}
+
+	@Override
+	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
+		return parent.getStorageTag(position, name, parameters);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	@Override
 	public IPartialExpression get(CodePosition position, GenericName name) {
 		if (typeParameters.containsKey(name.name) && !name.hasArguments())
-			return new PartialTypeExpression(position, getTypeRegistry().getGeneric(typeParameters.get(name.name)), name.arguments);
+			return new PartialTypeExpression(position, getTypeRegistry().getGeneric(typeParameters.get(name.name), null), name.arguments);
 
 		return outer.get(position, name);
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
-		if (typeParameters.containsKey(name.get(0).name) && name.size() == 1 && !name.get(0).hasArguments()) {
-			return getTypeRegistry().getGeneric(typeParameters.get(name.get(0).name));
-		}
+	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
+		if (typeParameters.containsKey(name.get(0).name) && name.size() == 1 && !name.get(0).hasArguments())
+			return getTypeRegistry().getGeneric(typeParameters.get(name.get(0).name), storage);
 
-		return outer.getType(position, name);
+		return outer.getType(position, name, storage);
+	}
+
+	@Override
+	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
+		return outer.getStorageTag(position, name, parameters);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 			
 			for (TypeParameter parameter : expansion.typeParameters) {
 				genericParameters.put(parameter.name, parameter);
-				typeParameters.put(parameter, outer.getTypeRegistry().getGeneric(parameter));
+				typeParameters.put(parameter, outer.getTypeRegistry().getGeneric(parameter, null));
 			}
 		} else {
 			DefinitionTypeID definitionType = outer.getTypeRegistry().getForMyDefinition(definition);
 			while (definitionType != null) {
 				for (TypeParameter parameter : definitionType.definition.typeParameters) {
 					genericParameters.put(parameter.name, parameter);
-					typeParameters.put(parameter, outer.getTypeRegistry().getGeneric(parameter));
+					typeParameters.put(parameter, outer.getTypeRegistry().getGeneric(parameter, null));
 				}
 				definitionType = definitionType.definition.isStatic() ? null : definitionType.outer;
 			}
 	public IPartialExpression get(CodePosition position, GenericName name) {
 		if (members != null) {
 			if (members.hasInnerType(name.name))
-				return new PartialTypeExpression(position, members.getInnerType(position, name), name.arguments);
+				return new PartialTypeExpression(position, members.getInnerType(position, name, null), name.arguments);
 			if (members.hasMember(name.name) && !name.hasArguments())
 				return members.getMemberExpression(position, this, new ThisExpression(position, type), name, true);
 		} else if (innerTypes.containsKey(name.name)) {
-			return new PartialTypeExpression(position, getTypeRegistry().getForDefinition(innerTypes.get(name).get(), name.arguments), name.arguments);
+			return new PartialTypeExpression(position, getTypeRegistry().getForDefinition(innerTypes.get(name).get(), null, name.arguments), name.arguments);
 		}
 		if (genericParameters.containsKey(name.name) && !name.hasArguments())
-			return new PartialTypeExpression(position, getTypeRegistry().getGeneric(genericParameters.get(name.name)), name.arguments);
+			return new PartialTypeExpression(position, getTypeRegistry().getGeneric(genericParameters.get(name.name), null), name.arguments);
 		
 		return outer.get(position, name);
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
+	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
 		if (members != null && members.hasInnerType(name.get(0).name)) {
-			ITypeID result = members.getInnerType(position, name.get(0));
+			ITypeID result = members.getInnerType(position, name.get(0), storage);
 			for (int i = 1; i < name.size(); i++) {
-				result = getTypeMembers(result).getInnerType(position, name.get(i));
+				result = getTypeMembers(result).getInnerType(position, name.get(i), storage);
 			}
 			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));
+			return getTypeRegistry().getGeneric(genericParameters.get(name.get(0).name), null);
 		} else if (innerTypes.containsKey(name.get(0).name)) {
-			ITypeID result = getTypeRegistry().getForDefinition(innerTypes.get(name.get(0).name).get(), name.get(0).arguments);
+			ITypeID result = getTypeRegistry().getForDefinition(innerTypes.get(name.get(0).name).get(), null, name.get(0).arguments);
 			for (int i = 1; i < name.size(); i++) {
-				result = getTypeMembers(result).getInnerType(position, name.get(i)); // TODO: this cannot be right, where did the type arguments go? the abyss?
+				result = getTypeMembers(result).getInnerType(position, name.get(i), storage); // TODO: this cannot be right, where did the type arguments go? the abyss?
 			}
 			return result;
 		}
 		
-		return outer.getType(position, name);
+		return outer.getType(position, name, storage);
+	}
+
+	@Override
+	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
+		return outer.getStorageTag(position, name, parameters);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	}
 	
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
-		return outer.getType(position, name);
+	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
+		return outer.getType(position, name, storage);
+	}
+
+	@Override
+	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
+		return outer.getStorageTag(position, name, parameters);
 	}
 	
 	@Override

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 
 	@Override
 	public IPartialExpression get(CodePosition position, GenericName name) {
-		ITypeID type = context.getType(position, Collections.singletonList(name));
+		ITypeID type = context.getType(position, Collections.singletonList(name), null);
 		if (type != null)
 			return new PartialTypeExpression(position, type, name.arguments);
 		
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
-		ITypeID type = context.getType(position, name);
+	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
+		ITypeID type = context.getType(position, name, storage);
 		if (type != null)
 			return type;
 		
 		if (globals.containsKey(name.get(0).name)) {
-			type = globals.get(name.get(0).name).getType(position, context, name.get(0).arguments);
+			type = globals.get(name.get(0).name).getType(position, context, name.get(0).arguments, storage);
 			for (int i = 1; i < name.size(); i++) {
-				type = getTypeMembers(type).getInnerType(position, name.get(i));
+				type = getTypeMembers(type).getInnerType(position, name.get(i), storage);
 				if (type == null)
 					break;
 			}
 		return null;
 	}
 
+	@Override
+	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
+		return context.getStorageTag(position, name, parameters);
+	}
+
 	@Override
 	public LoopStatement getLoop(String name) {
 		return null;

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
-		return outer.getType(position, name);
+	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
+		return outer.getType(position, name, storage);
+	}
+
+	@Override
+	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
+		return outer.getStorageTag(position, name, parameters);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 			if (header.typeParameters != null) {
 				for (TypeParameter parameter : header.typeParameters) {
 					if (parameter.name.equals(name.name))
-						return new PartialTypeExpression(position, getTypeRegistry().getGeneric(parameter), name.arguments);
+						return new PartialTypeExpression(position, getTypeRegistry().getGeneric(parameter, null), name.arguments);
 				}
 			}
 		}
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
+	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
 		if (name.size() == 1 && name.get(0).hasNoArguments()) {
 			if (header.typeParameters != null) {
 				for (TypeParameter parameter : header.typeParameters) {
 					if (parameter.name.equals(name.get(0).name))
-						return getTypeRegistry().getGeneric(parameter);
+						return getTypeRegistry().getGeneric(parameter, null);
 				}
 			}
 		}
 		
-		return outer.getType(position, name);
+		return outer.getType(position, name, storage);
+	}
+
+	@Override
+	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
+		return outer.getStorageTag(position, name, parameters);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	@Override
 	public IPartialExpression get(CodePosition position, GenericName name) {
 		if (parameters.containsKey(name.name) && name.hasNoArguments())
-			return new PartialTypeExpression(position, getTypeRegistry().getGeneric(parameters.get(name.name)), name.arguments);
+			return new PartialTypeExpression(position, getTypeRegistry().getGeneric(parameters.get(name.name), null), name.arguments);
 		
 		return outer.get(position, name);
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
+	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
 		if (name.size() == 1 && parameters.containsKey(name.get(0).name) && name.get(0).hasNoArguments())
-			return getTypeRegistry().getGeneric(parameters.get(name.get(0).name));
+			return getTypeRegistry().getGeneric(parameters.get(name.get(0).name), null);
 		
-		return outer.getType(position, name);
+		return outer.getType(position, name, storage);
+	}
+
+	@Override
+	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
+		return outer.getStorageTag(position, name, parameters);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
-		return file.getType(position, name);
+	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
+		return file.getType(position, name, storage);
+	}
+
+	@Override
+	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
+		return file.getStorageTag(position, name, parameters);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	@Override
 	public IPartialExpression get(CodePosition position, GenericName name) {
 		if (members.hasInnerType(name.name))
-			return new PartialTypeExpression(position, members.getInnerType(position, name), name.arguments);
+			return new PartialTypeExpression(position, members.getInnerType(position, name, null), name.arguments);
 		if (members.hasMember(name.name))
 			return members.getMemberExpression(position, this, new ThisExpression(position, outer.getThisType()), name, true);
 		
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
+	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
 		if (members.hasInnerType(name.get(0).name)) {
-			ITypeID result = members.getInnerType(position, name.get(0));
+			ITypeID result = members.getInnerType(position, name.get(0), storage);
 			for (int i = 1; i < name.size(); i++) {
-				result = getTypeMembers(result).getInnerType(position, name.get(i));
+				result = getTypeMembers(result).getInnerType(position, name.get(i), storage);
 			}
 			return result;
 		}
 		
-		return outer.getType(position, name);
+		return outer.getType(position, name, storage);
+	}
+
+	@Override
+	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
+		return outer.getStorageTag(position, name, parameters);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
-		return outer.getType(position, name);
+	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
+		return outer.getType(position, name, storage);
+	}
+
+	@Override
+	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
+		return outer.getStorageTag(position, name, parameters);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
-		return outer.getType(position, name);
+	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
+		return outer.getType(position, name, storage);
+	}
+
+	@Override
+	public StorageTag getStorageTag(CodePosition position, String name, String[] parameters) {
+		return outer.getStorageTag(position, name, parameters);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.type.GenericName;
-import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 
 /**
  *

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

 package org.openzen.zenscript.codemodel.type;
 
 import java.util.List;
+import java.util.Objects;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
+import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ArrayTypeID implements ITypeID {
-	public static final ArrayTypeID INT = new ArrayTypeID(null, BasicTypeID.INT, 1);
-	public static final ArrayTypeID CHAR = new ArrayTypeID(null, BasicTypeID.CHAR, 1);
+	public static final ArrayTypeID INT_NOSTORAGE = new ArrayTypeID(BasicTypeID.INT, 1, null);
+	public static final ArrayTypeID CHAR_NOSTORAGE = new ArrayTypeID(BasicTypeID.CHAR, 1, null);
+	
+	public static final ArrayTypeID INT_UNIQUE = new ArrayTypeID(BasicTypeID.INT, 1, UniqueStorageTag.INSTANCE);
+	public static final ArrayTypeID CHAR_UNIQUE = new ArrayTypeID(BasicTypeID.CHAR, 1, UniqueStorageTag.INSTANCE);
 	
 	public final ITypeID elementType;
 	public final int dimension;
+	public final StorageTag storage;
 	private final ArrayTypeID normalized;
+	private final ArrayTypeID withoutStorage;
 
-	public ArrayTypeID(GlobalTypeRegistry registry, ITypeID elementType, int dimension) {
+	private ArrayTypeID(ITypeID elementType, int dimension, StorageTag storage) {
+		this.elementType = elementType;
+		this.dimension = dimension;
+		this.normalized = this;
+		this.storage = storage;
+		
+		if (storage == null) {
+			withoutStorage = this;
+		} else {
+			if (elementType == BasicTypeID.INT)
+				withoutStorage = INT_NOSTORAGE;
+			else if (elementType == BasicTypeID.CHAR)
+				withoutStorage = CHAR_NOSTORAGE;
+			else
+				throw new IllegalArgumentException();
+		}
+	}
+	
+	public ArrayTypeID(GlobalTypeRegistry registry, ITypeID elementType, int dimension, StorageTag storage) {
 		this.elementType = elementType;
 		this.dimension = dimension;
-		this.normalized = elementType.getNormalized() == elementType ? this : registry.getArray(elementType.getNormalized(), dimension);
+		this.normalized = elementType.getNormalized() == elementType ? this : registry.getArray(elementType.getNormalized(), dimension, storage);
+		this.storage = storage;
+		
+		withoutStorage = storage == null ? this : registry.getArray(elementType, dimension, null);
 	}
 	
 	@Override
 	
 	@Override
 	public ArrayTypeID instance(GenericMapper mapper) {
-		return mapper.registry.getArray(elementType.instance(mapper), dimension);
+		return mapper.registry.getArray(elementType.instance(mapper), dimension, storage);
+	}
+	
+	@Override
+	public ArrayTypeID withStorage(GlobalTypeRegistry registry, StorageTag storage) {
+		return registry.getArray(elementType, dimension, storage);
 	}
 
 	@Override
 		int hash = 7;
 		hash = 79 * hash + elementType.hashCode();
 		hash = 79 * hash + dimension;
+		hash = 79 * hash + Objects.hashCode(storage);
 		return hash;
 	}
 
 			return false;
 		}
 		final ArrayTypeID other = (ArrayTypeID) obj;
-		return this.dimension == other.dimension && this.elementType == other.elementType;
+		return this.dimension == other.dimension
+				&& this.elementType == other.elementType
+				&& Objects.equals(this.storage, other.storage);
 	}
 
 	@Override
 			result.append(',');
 		}
 		result.append(']');
+		if (storage != null) {
+			result.append('`');
+			result.append(storage.toString());
+		}
 		return result.toString();
 	}
+
+	@Override
+	public StorageTag getStorage() {
+		return storage;
+	}
+
+	@Override
+	public ITypeID withoutStorage() {
+		return withoutStorage;
+	}
 }

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

 package org.openzen.zenscript.codemodel.type;
 
 import java.util.List;
+import java.util.Objects;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 public class AssocTypeID implements ITypeID {
 	public final ITypeID keyType;
 	public final ITypeID valueType;
+	public final StorageTag storage;
 	private final AssocTypeID normalized;
+	private final AssocTypeID withoutStorage;
 	
-	public AssocTypeID(GlobalTypeRegistry typeRegistry, ITypeID keyType, ITypeID valueType) {
+	public AssocTypeID(GlobalTypeRegistry typeRegistry, ITypeID keyType, ITypeID valueType, StorageTag storage) {
 		this.keyType = keyType;
 		this.valueType = valueType;
+		this.storage = storage;
 		
 		if (keyType != keyType.getNormalized() || valueType != valueType.getNormalized())
-			normalized = typeRegistry.getAssociative(keyType.getNormalized(), valueType.getNormalized());
+			normalized = typeRegistry.getAssociative(keyType.getNormalized(), valueType.getNormalized(), storage);
 		else
 			normalized = this;
+		
+		withoutStorage = storage == null ? this : typeRegistry.getAssociative(normalized.keyType, normalized.valueType, null);
 	}
 	
 	@Override
 	public AssocTypeID instance(GenericMapper mapper) {
 		return mapper.registry.getAssociative(
 				keyType.instance(mapper),
-				valueType.instance(mapper));
+				valueType.instance(mapper),
+				storage);
+	}
+	
+	@Override
+	public AssocTypeID withStorage(GlobalTypeRegistry registry, StorageTag storage) {
+		return registry.getAssociative(keyType, valueType, storage);
 	}
 	
 	@Override
 		int hash = 7;
 		hash = 29 * hash + keyType.hashCode();
 		hash = 29 * hash + valueType.hashCode();
+		hash = 29 * hash + Objects.hashCode(storage);
 		return hash;
 	}
 
 			return false;
 		}
 		final AssocTypeID other = (AssocTypeID) obj;
-		return this.keyType == other.keyType && this.valueType == other.valueType;
+		return this.keyType == other.keyType
+				&& this.valueType == other.valueType
+				&& Objects.equals(this.storage, other.storage);
 	}
 	
 	@Override
 		result.append(']');
 		return result.toString();
 	}
+
+	@Override
+	public StorageTag getStorage() {
+		return storage;
+	}
+
+	@Override
+	public ITypeID withoutStorage() {
+		return withoutStorage;
+	}
 }

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

 import java.util.List;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
 	public ITypeID instance(GenericMapper mapper) {
 		return this;
 	}
+
+	@Override
+	public ITypeID withStorage(GlobalTypeRegistry registry, StorageTag storage) {
+		return this;
+	}
 	
 	@Override
 	public String toString() {
 	public void extractTypeParameters(List<TypeParameter> typeParameters) {
 		
 	}
+
+	@Override
+	public StorageTag getStorage() {
+		return ValueStorageTag.INSTANCE;
+	}
+
+	@Override
+	public ITypeID withoutStorage() {
+		return this;
+	}
 }

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

 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class DefinitionTypeID implements ITypeID {
-	public static DefinitionTypeID forType(HighLevelDefinition definition) {
+	public static DefinitionTypeID forType(GlobalTypeRegistry registry, HighLevelDefinition definition, StorageTag storage) {
 		if (definition.typeParameters != null && definition.typeParameters.length > 0)
 			throw new IllegalArgumentException("Definition has type arguments!");
 		
-		return new DefinitionTypeID(null, definition, ITypeID.NONE);
+		return new DefinitionTypeID(registry, definition, ITypeID.NONE, storage);
 	}
 	
 	public final HighLevelDefinition definition;
-	public final ITypeID[] typeParameters;
+	public final ITypeID[] typeArguments;
 	public final DefinitionTypeID outer;
+	public final StorageTag storage;
 	private ITypeID normalized;
+	private ITypeID withoutStorage;
 	
 	public ITypeID superType;
 	
-	public DefinitionTypeID(GlobalTypeRegistry typeRegistry, HighLevelDefinition definition, ITypeID[] typeParameters) {
-		this(typeRegistry, definition, typeParameters, null);
+	public DefinitionTypeID(GlobalTypeRegistry typeRegistry, HighLevelDefinition definition, ITypeID[] typeParameters, StorageTag storage) {
+		this(typeRegistry, definition, typeParameters, null, storage);
 	}
 	
 	// For inner classes of generic outer classes
-	public DefinitionTypeID(GlobalTypeRegistry typeRegistry, HighLevelDefinition definition, ITypeID[] typeParameters, DefinitionTypeID outer) {
+	public DefinitionTypeID(GlobalTypeRegistry typeRegistry, HighLevelDefinition definition, ITypeID[] typeParameters, DefinitionTypeID outer, StorageTag storage) {
 		if (typeParameters == null)
 			throw new NullPointerException("typeParameters cannot be null");
 		if (typeParameters.length != definition.getNumberOfGenericParameters())
 			throw new IllegalArgumentException("Static inner definition must not have outer instance");
 		
 		this.definition = definition;
-		this.typeParameters = typeParameters;
+		this.typeArguments = typeParameters;
 		this.outer = outer;
+		this.storage = storage;
 		
 		normalized = isDenormalized() ? normalize(typeRegistry) : this;
 		if (normalized instanceof DefinitionTypeID && ((DefinitionTypeID)normalized).isDenormalized())
 			throw new AssertionError();
+		
+		withoutStorage = storage == null ? this : typeRegistry.getForDefinition(definition, typeParameters, outer, null);
 	}
 	
 	private boolean isDenormalized() {
 		if (definition instanceof AliasDefinition)
 			return true;
 		
-		for (ITypeID typeParameter : typeParameters)
+		for (ITypeID typeParameter : typeArguments)
 			if (typeParameter.getNormalized() != typeParameter)
 				return true;
 		if (outer != null && outer.getNormalized() != outer)
 			
 			Map<TypeParameter, ITypeID> typeMapping = new HashMap<>();
 			for (int i = 0; i < definition.typeParameters.length; i++)
-				typeMapping.put(definition.typeParameters[i], typeParameters[i].getNormalized());
+				typeMapping.put(definition.typeParameters[i], typeArguments[i].getNormalized());
 			GenericMapper mapper = new GenericMapper(typeRegistry, typeMapping);
 			ITypeID result = alias.type.instance(mapper).getNormalized();
 			return result;
 		}
 		
-		ITypeID[] normalizedTypeParameters = new ITypeID[typeParameters.length];
+		ITypeID[] normalizedTypeParameters = new ITypeID[typeArguments.length];
 		for (int i = 0; i < normalizedTypeParameters.length; i++)
-			normalizedTypeParameters[i] = typeParameters[i].getNormalized();
+			normalizedTypeParameters[i] = typeArguments[i].getNormalized();
 		
-		return typeRegistry.getForDefinition(definition, normalizedTypeParameters, outer == null ? null : (DefinitionTypeID)outer.getNormalized());
+		return typeRegistry.getForDefinition(definition, normalizedTypeParameters, outer == null ? null : (DefinitionTypeID)outer.getNormalized(), storage);
 	}
 	
 	public boolean hasTypeParameters() {
-		return typeParameters.length > 0;
+		return typeArguments.length > 0;
 	}
 	
 	public Map<TypeParameter, ITypeID> getTypeParameterMapping() {
 		Map<TypeParameter, ITypeID> mapping = new HashMap<>();
 		DefinitionTypeID current = this;
 		do {
-			if (current.typeParameters != null) {
+			if (current.typeArguments != null) {
 				if (current.definition.typeParameters == null)
 					System.out.println("Type parameters but no generic parameters");
 				else
-					for (int i = 0; i < current.typeParameters.length; i++)
-						mapping.put(current.definition.typeParameters[i], current.typeParameters[i]);
+					for (int i = 0; i < current.typeArguments.length; i++)
+						mapping.put(current.definition.typeParameters[i], current.typeArguments[i]);
 			}
 
 			current = current.outer;
 		return mapping;
 	}
 	
-	public DefinitionTypeID(HighLevelDefinition definition) {
+	public DefinitionTypeID(HighLevelDefinition definition, StorageTag storage) {
 		this.definition = definition;
-		this.typeParameters = ITypeID.NONE;
+		this.typeArguments = ITypeID.NONE;
 		this.superType = definition.getSuperType();
 		this.outer = null;
+		this.storage = storage;
 	}
 	
 	@Override
 		
 		ITypeID[] instancedArguments = ITypeID.NONE;
 		if (hasTypeParameters()) {
-			instancedArguments = new ITypeID[typeParameters.length];
-			for (int i = 0; i < typeParameters.length; i++) {
-				instancedArguments[i] = typeParameters[i].instance(mapper);
-			}
+			instancedArguments = new ITypeID[typeArguments.length];
+			for (int i = 0; i < typeArguments.length; i++)
+				instancedArguments[i] = typeArguments[i].instance(mapper);
 		}
 		
 		DefinitionTypeID instancedOuter = outer == null ? null : outer.instance(mapper);
-		return mapper.registry.getForDefinition(definition, instancedArguments, instancedOuter);
+		return mapper.registry.getForDefinition(definition, instancedArguments, instancedOuter, storage);
+	}
+
+	@Override
+	public DefinitionTypeID withStorage(GlobalTypeRegistry registry, StorageTag storage) {
+		return registry.getForDefinition(definition, typeArguments, outer, storage);
 	}
 	
 	@Override
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
 		if (hasTypeParameters()) {
-			for (ITypeID typeParameter : typeParameters)
+			for (ITypeID typeParameter : typeArguments)
 				if (typeParameter.hasInferenceBlockingTypeParameters(parameters))
 					return true;
 		}
 	public int hashCode() {
 		int hash = 7;
 		hash = 97 * hash + definition.hashCode();
-		hash = 97 * hash + Arrays.deepHashCode(typeParameters);
+		hash = 97 * hash + Arrays.deepHashCode(typeArguments);
 		hash = 97 * hash + Objects.hashCode(outer);
+		hash = 97 * hash + Objects.hashCode(storage);
 		return hash;
 	}
 
 		}
 		final DefinitionTypeID other = (DefinitionTypeID) obj;
 		return this.definition == other.definition
-				&& Arrays.deepEquals(this.typeParameters, other.typeParameters)
-				&& Objects.equals(outer, this.outer);
+				&& Arrays.deepEquals(this.typeArguments, other.typeArguments)
+				&& Objects.equals(outer, this.outer)
+				&& Objects.equals(this.storage, other.storage);
 	}
 	
 	@Override
 		
 		result.append(definition.name);
 		result.append('<');
-		for (int i = 0; i < typeParameters.length; i++) { 
+		for (int i = 0; i < typeArguments.length; i++) { 
 			if (i > 0)
 				result.append(", ");
-			result.append(typeParameters[i].toString());
+			result.append(typeArguments[i].toString());
 		}
 		result.append('>');
 		return result.toString();
 
 	@Override
 	public void extractTypeParameters(List<TypeParameter> typeParameters) {
-		for (ITypeID type : this.typeParameters)
+		for (ITypeID type : this.typeArguments)
 			type.extractTypeParameters(typeParameters);
 	}
 	
 		return definition.isDestructible();
 	}
 
-	public DefinitionTypeID getInnerType(GenericName name, GlobalTypeRegistry registry) {
+	public DefinitionTypeID getInnerType(GenericName name, GlobalTypeRegistry registry, StorageTag storage) {
 		HighLevelDefinition type = definition.getInnerType(name.name);
-		return registry.getForDefinition(type, name.arguments, this);
+		return registry.getForDefinition(type, name.arguments, this, storage);
+	}
+
+	@Override
+	public StorageTag getStorage() {
+		return storage;
+	}
+
+	@Override
+	public ITypeID withoutStorage() {
+		return withoutStorage;
 	}
 }

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

 
 import java.util.Arrays;
 import java.util.List;
+import java.util.Objects;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
  */
 public class FunctionTypeID implements ITypeID {
 	public final FunctionHeader header;
+	public final StorageTag storage;
 	private final FunctionTypeID normalized;
+	private final FunctionTypeID withoutStorage;
 	
-	public FunctionTypeID(GlobalTypeRegistry registry, FunctionHeader header) {
+	public FunctionTypeID(GlobalTypeRegistry registry, FunctionHeader header, StorageTag storage) {
 		this.header = header;
+		this.storage = storage;
 		
 		FunctionHeader normalizedHeader = header.normalize(registry);
-		normalized = header == normalizedHeader ? this : registry.getFunction(normalizedHeader);
+		normalized = header == normalizedHeader ? this : registry.getFunction(normalizedHeader, storage);
+		withoutStorage = storage == null ? this : registry.getFunction(header, null);
 	}
 	
 	@Override
 	
 	@Override
 	public ITypeID instance(GenericMapper mapper) {
-		return mapper.registry.getFunction(mapper.map(header));
+		return mapper.registry.getFunction(mapper.map(header), storage);
+	}
+
+	@Override
+	public ITypeID withStorage(GlobalTypeRegistry registry, StorageTag storage) {
+		return registry.getFunction(header, storage);
 	}
 	
 	@Override
 		hash = 71 * hash + header.getReturnType().hashCode();
 		hash = 71 * hash + Arrays.deepHashCode(header.parameters);
 		hash = 71 * hash + Arrays.deepHashCode(header.typeParameters);
+		hash = 71 * hash + Objects.hashCode(storage);
 		return hash;
 	}
 
 		final FunctionTypeID other = (FunctionTypeID) obj;
 		return this.header.getReturnType() == other.header.getReturnType()
 				&& Arrays.deepEquals(this.header.parameters, other.header.parameters)
-				&& Arrays.deepEquals(this.header.typeParameters, other.header.typeParameters);
+				&& Arrays.deepEquals(this.header.typeParameters, other.header.typeParameters)
+				&& Objects.equals(this.storage, other.storage);
 	}
 	
 	@Override
 		result.append(header.getReturnType());
 		return result.toString();
 	}
+
+	@Override
+	public StorageTag getStorage() {
+		return storage;
+	}
+
+	@Override
+	public ITypeID withoutStorage() {
+		return withoutStorage;
+	}
 }

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

 import java.util.Objects;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 public class GenericMapTypeID implements ITypeID {
 	public final ITypeID value;
 	public final TypeParameter key;
+	public final StorageTag storage;
 	private final GenericMapTypeID normalized;
+	private final GenericMapTypeID withoutStorage;
 	
-	public GenericMapTypeID(GlobalTypeRegistry registry, ITypeID value, TypeParameter key) {
+	public GenericMapTypeID(GlobalTypeRegistry registry, ITypeID value, TypeParameter key, StorageTag storage) {
 		this.value = value;
 		this.key = key;
+		this.storage = storage;
 		
-		normalized = value.getNormalized() == value ? this : registry.getGenericMap(value.getNormalized(), key);
+		normalized = value.getNormalized() == value ? this : registry.getGenericMap(value.getNormalized(), key, storage);
+		withoutStorage = storage == null ? this : registry.getGenericMap(value, key, null);
 	}
 	
 	@Override
 
 	@Override
 	public ITypeID instance(GenericMapper mapper) {
-		return mapper.registry.getGenericMap(value.instance(mapper), key);
+		return mapper.registry.getGenericMap(value.instance(mapper), key, storage);
+	}
+
+	@Override
+	public ITypeID withStorage(GlobalTypeRegistry registry, StorageTag storage) {
+		return registry.getGenericMap(value, key, storage);
 	}
 
 	@Override
 		int hash = 5;
 		hash = 97 * hash + this.value.hashCode();
 		hash = 97 * hash + this.key.hashCode();
+		hash = 97 * hash + Objects.hashCode(this.storage);
 		return hash;
 	}
 
 	@Override
 	public boolean equals(Object obj) {
-		if (this == obj) {
+		if (this == obj)
 			return true;
-		}
-		if (obj == null) {
+		if (obj == null)
 			return false;
-		}
-		if (getClass() != obj.getClass()) {
+		if (getClass() != obj.getClass())
 			return false;
-		}
+		
 		final GenericMapTypeID other = (GenericMapTypeID) obj;
-		if (!Objects.equals(this.value, other.value)) {
-			return false;
-		}
-		if (!Objects.equals(this.key, other.key)) {
-			return false;
-		}
-		return true;
+		return Objects.equals(this.value, other.value)
+				&& Objects.equals(this.key, other.key)
+				&& Objects.equals(this.storage, other.storage);
+	}
+
+	@Override
+	public StorageTag getStorage() {
+		return storage;
+	}
+
+	@Override
+	public ITypeID withoutStorage() {
+		return withoutStorage;
 	}
 }

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

 package org.openzen.zenscript.codemodel.type;
 
 import java.util.List;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 		return arguments.length == 0;
 	}
 	
-	public static ITypeID getInnerType(GlobalTypeRegistry registry, DefinitionTypeID type, List<GenericName> name, int index) {
+	public static ITypeID getInnerType(GlobalTypeRegistry registry, DefinitionTypeID type, List<GenericName> name, int index, StorageTag storage) {
 		while (index < name.size()) {
 			GenericName innerName = name.get(index++);
-			type = type.getInnerType(innerName, registry);
+			type = type.getInnerType(innerName, registry, storage);
 			if (type == null)
 				return null;
 		}

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

 package org.openzen.zenscript.codemodel.type;
 
 import java.util.List;
+import java.util.Objects;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
  */
 public class GenericTypeID implements ITypeID {
 	public final TypeParameter parameter;
+	public final StorageTag storage;
+	private final GenericTypeID withoutStorage;
 
-	public GenericTypeID(TypeParameter parameter) {
+	public GenericTypeID(GlobalTypeRegistry registry, TypeParameter parameter, StorageTag storage) {
 		this.parameter = parameter;
+		this.storage = storage;
+		withoutStorage = storage == null ? this : registry.getGeneric(parameter, null);
 	}
 	
 	public boolean matches(LocalMemberCache cache, ITypeID type) {
 	
 	@Override
 	public ITypeID instance(GenericMapper mapper) {
-		return mapper.map(this);
+		return mapper.map(this).withStorage(mapper.registry, storage);
+	}
+	
+	@Override
+	public ITypeID withStorage(GlobalTypeRegistry registry, StorageTag storage) {
+		return registry.getGeneric(parameter, storage);
 	}
 
 	@Override
 	public int hashCode() {
 		int hash = 7;
 		hash = 47 * hash + parameter.hashCode();
+		hash = 47 * hash + Objects.hashCode(storage);
 		return hash;
 	}
 
 			return false;
 		}
 		final GenericTypeID other = (GenericTypeID) obj;
-		return this.parameter == other.parameter;
+		return this.parameter == other.parameter
+				&& Objects.equals(this.storage, other.storage);
 	}
 	
 	@Override
 	public String toString() {
 		return parameter.toString();
 	}
+
+	@Override
+	public StorageTag getStorage() {
+		return storage;
+	}
+
+	@Override
+	public ITypeID withoutStorage() {
+		return withoutStorage;
+	}
 }

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class GlobalTypeRegistry {
+	private final Map<StringTypeID, StringTypeID> stringTypes = new HashMap<>();
 	private final Map<ArrayTypeID, ArrayTypeID> arrayTypes = new HashMap<>();
 	private final Map<AssocTypeID, AssocTypeID> assocTypes = new HashMap<>();
 	private final Map<GenericMapTypeID, GenericMapTypeID> genericMapTypes = new HashMap<>();
 	public GlobalTypeRegistry(ZSPackage stdlib) {
 		this.stdlib = stdlib;
 		
-		arrayTypes.put(ArrayTypeID.INT, ArrayTypeID.INT);
-		arrayTypes.put(ArrayTypeID.CHAR, ArrayTypeID.CHAR);
+		stringTypes.put(StringTypeID.NOSTORAGE, StringTypeID.NOSTORAGE);
+		stringTypes.put(StringTypeID.ANY, StringTypeID.ANY);
+		stringTypes.put(StringTypeID.BORROW, StringTypeID.BORROW);
+		stringTypes.put(StringTypeID.SHARED, StringTypeID.SHARED);
+		stringTypes.put(StringTypeID.STATIC, StringTypeID.STATIC);
+		stringTypes.put(StringTypeID.UNIQUE, StringTypeID.UNIQUE);
+		
+		arrayTypes.put(ArrayTypeID.INT_UNIQUE, ArrayTypeID.INT_UNIQUE);
+		arrayTypes.put(ArrayTypeID.CHAR_UNIQUE, ArrayTypeID.CHAR_UNIQUE);
 		
 		rangeTypes.put(RangeTypeID.INT, RangeTypeID.INT);
 		rangeTypes.put(RangeTypeID.USIZE, RangeTypeID.USIZE);
 	}
 	
-	public ArrayTypeID getArray(ITypeID baseType, int dimension) {
-		ArrayTypeID id = new ArrayTypeID(this, baseType, dimension);
-		if (arrayTypes.containsKey(id)) {
-			return arrayTypes.get(id);
-		} else {
-			arrayTypes.put(id, id);
-			return id;
-		}
+	public StringTypeID getString(StorageTag storage) {
+		StringTypeID id = new StringTypeID(storage);
+		return internalize(stringTypes, id);
 	}
 	
-	public AssocTypeID getAssociative(ITypeID keyType, ITypeID valueType) {
-		AssocTypeID id = new AssocTypeID(this, keyType, valueType);
-		if (assocTypes.containsKey(id)) {
-			return assocTypes.get(id);
-		} else {
-			assocTypes.put(id, id);
-			return id;
-		}
+	public ArrayTypeID getArray(ITypeID baseType, int dimension, StorageTag storage) {
+		ArrayTypeID id = new ArrayTypeID(this, baseType, dimension, storage);
+		return internalize(arrayTypes, id);
 	}
 	
-	public GenericMapTypeID getGenericMap(ITypeID valueType, TypeParameter key) {
-		GenericMapTypeID id = new GenericMapTypeID(this, valueType, key);
-		if (genericMapTypes.containsKey(id)) {
-			return genericMapTypes.get(id);
-		} else {
-			genericMapTypes.put(id, id);
-			return id;
-		}
+	public AssocTypeID getAssociative(ITypeID keyType, ITypeID valueType, StorageTag storage) {
+		AssocTypeID id = new AssocTypeID(this, keyType, valueType, storage);
+		return internalize(assocTypes, id);
 	}
 	
-	public IteratorTypeID getIterator(ITypeID[] loopTypes) {
-		IteratorTypeID id = new IteratorTypeID(this, loopTypes);
-		if (iteratorTypes.containsKey(id)) {
-			return iteratorTypes.get(id);
-		} else {
-			iteratorTypes.put(id, id);
-			return id;
-		}
+	public GenericMapTypeID getGenericMap(ITypeID valueType, TypeParameter key, StorageTag storage) {
+		GenericMapTypeID id = new GenericMapTypeID(this, valueType, key, storage);
+		return internalize(genericMapTypes, id);
 	}
 	
-	public FunctionTypeID getFunction(FunctionHeader header) {
-		FunctionTypeID id = new FunctionTypeID(this, header);
+	public IteratorTypeID getIterator(ITypeID[] loopTypes, StorageTag storage) {
+		IteratorTypeID id = new IteratorTypeID(this, loopTypes, storage);
+		return internalize(iteratorTypes, id);
+	}
+	
+	public FunctionTypeID getFunction(FunctionHeader header, StorageTag storage) {
+		FunctionTypeID id = new FunctionTypeID(this, header, storage);
 		if (functionTypes.containsKey(id)) {
 			return functionTypes.get(id);
 		} else {
 		}
 	}
 	
-	public GenericTypeID getGeneric(TypeParameter parameter) {
-		GenericTypeID id = new GenericTypeID(parameter);
+	public GenericTypeID getGeneric(TypeParameter parameter, StorageTag storage) {
+		GenericTypeID id = new GenericTypeID(this, parameter, storage);
 		if (genericTypes.containsKey(id)) {
 			return genericTypes.get(id);
 		} else {
 		if (definition.getNumberOfGenericParameters() > 0) {
 			typeArguments = new ITypeID[definition.getNumberOfGenericParameters()];
 			for (int i = 0; i < definition.typeParameters.length; i++)
-				typeArguments[i] = getGeneric(definition.typeParameters[i]);
+				typeArguments[i] = getGeneric(definition.typeParameters[i], null);
 		}
 		DefinitionTypeID outer = null;
 		if (definition.outerDefinition != null)
 			outer = getForMyDefinition(definition.outerDefinition);
 		
-		return getForDefinition(definition, typeArguments, outer);
+		return getForDefinition(definition, typeArguments, outer, BorrowStorageTag.THIS);
 	}
 	
-	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, ITypeID... genericArguments) {
-		return this.getForDefinition(definition, genericArguments, null);
+	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, StorageTag storage, ITypeID... genericArguments) {
+		return this.getForDefinition(definition, genericArguments, null, storage);
 	}
 	
-	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, ITypeID[] typeParameters, DefinitionTypeID outer) {
-		DefinitionTypeID id = new DefinitionTypeID(this, definition, typeParameters, definition.isStatic() ? null : outer);
+	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, ITypeID[] typeParameters, DefinitionTypeID outer, StorageTag storage) {
+		DefinitionTypeID id = new DefinitionTypeID(this, definition, typeParameters, definition.isStatic() ? null : outer, storage);
 		
 		if (definitionTypes.containsKey(id)) {
 			return definitionTypes.get(id);
 		}
 		
 		ModifiedTypeID result = new ModifiedTypeID(this, modifiers, type);
-		if (modifiedTypes.containsKey(result)) {
-			return modifiedTypes.get(result);
+		return internalize(modifiedTypes, result);
+	}
+	
+	private <T> T internalize(Map<T, T> identityMap, T id) {
+		if (identityMap.containsKey(id)) {
+			return identityMap.get(id);
 		} else {
-			modifiedTypes.put(result, result);
-			return result;
+			identityMap.put(id, id);
+			return id;
 		}
 	}
 }

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

 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 public interface ISymbol {
 	public IPartialExpression getExpression(CodePosition position, BaseScope scope, ITypeID[] typeArguments);
 	
-	public ITypeID getType(CodePosition position, TypeResolutionContext context, ITypeID[] typeArguments);
+	public ITypeID getType(CodePosition position, TypeResolutionContext context, ITypeID[] typeArguments, StorageTag storage);
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/ITypeID.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;
 
 /**
  *
 		throw new UnsupportedOperationException("Not an immutable type");
 	}
 	
+	public ITypeID withoutStorage();
+	
+	public StorageTag getStorage();
+	
 	public boolean hasDefaultValue();
 	
 	public boolean isObjectType();
 	
 	public ITypeID instance(GenericMapper mapper);
 	
+	public ITypeID withStorage(GlobalTypeRegistry registry, StorageTag storage);
+	
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters);
 	
 	// Infers type parameters for this type so it matches with targetType
 				if (definitionType.definition != definition.definition)
 					return false;
 				
-				if (definition.typeParameters != null) {
-					for (int i = 0; i < definitionType.typeParameters.length; i++) {
-						if (!match(definitionType.typeParameters[i], definition.typeParameters[i]))
+				if (definition.typeArguments != null) {
+					for (int i = 0; i < definitionType.typeArguments.length; i++) {
+						if (!match(definitionType.typeArguments[i], definition.typeArguments[i]))
 							return false;
 					}
 				}

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

 
 import java.util.Arrays;
 import java.util.List;
-import java.util.Map;
+import java.util.Objects;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
  */
 public class IteratorTypeID implements ITypeID {
 	public final ITypeID[] iteratorTypes;
+	public final StorageTag storage;
 	private final IteratorTypeID normalized;
+	private final IteratorTypeID withoutStorage;
 	
-	public IteratorTypeID(GlobalTypeRegistry registry, ITypeID[] iteratorTypes) {
+	public IteratorTypeID(GlobalTypeRegistry registry, ITypeID[] iteratorTypes, StorageTag storage) {
 		this.iteratorTypes = iteratorTypes;
+		this.storage = storage;
 		
 		normalized = isDenormalized() ? normalize(registry) : this;
+		withoutStorage = storage == null ? this : registry.getIterator(iteratorTypes, null);
 	}
 	
 	@Override
 		ITypeID[] normalizedTypes = new ITypeID[iteratorTypes.length];
 		for (int i = 0; i < normalizedTypes.length; i++)
 			normalizedTypes[i] = iteratorTypes[i].getNormalized();
-		return registry.getIterator(normalizedTypes);
+		return registry.getIterator(normalizedTypes, storage);
 	}
 
 	@Override
 		ITypeID[] instanced = new ITypeID[iteratorTypes.length];
 		for (int i = 0; i < iteratorTypes.length; i++)
 			instanced[i] = iteratorTypes[i].instance(mapper);
-		return mapper.registry.getIterator(instanced);
+		return mapper.registry.getIterator(instanced, storage);
+	}
+	
+	@Override
+	public ITypeID withStorage(GlobalTypeRegistry registry, StorageTag storage) {
+		return registry.getIterator(iteratorTypes, storage);
 	}
 
 	@Override
 	public int hashCode() {
 		int hash = 5;
 		hash = 13 * hash + Arrays.deepHashCode(this.iteratorTypes);
+		hash = 13 * hash + Objects.hashCode(storage);
 		return hash;
 	}
 
 			return false;
 		}
 		final IteratorTypeID other = (IteratorTypeID) obj;
-		if (!Arrays.deepEquals(this.iteratorTypes, other.iteratorTypes)) {
-			return false;
-		}
-		return true;
+		return Arrays.deepEquals(this.iteratorTypes, other.iteratorTypes)
+				&& Objects.equals(this.storage, other.storage);
+	}
+
+	@Override
+	public StorageTag getStorage() {
+		return storage;
+	}
+
+	@Override
+	public ITypeID withoutStorage() {
+		return withoutStorage;
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/ModifiedTypeID.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;
 
 /**
  *
 	public final ITypeID baseType;
 	private final ITypeID normalized;
 	private final GlobalTypeRegistry registry;
+	private final ITypeID withoutStorage;
 	
 	public ModifiedTypeID(GlobalTypeRegistry registry, int modifiers, ITypeID baseType) {
 		this.modifiers = modifiers;
 		this.registry = registry;
 		
 		normalized = baseType.getNormalized() == baseType ? this : registry.getModified(modifiers, baseType.getNormalized());
+		withoutStorage = baseType.withoutStorage() == baseType ? this : registry.getModified(modifiers, baseType.withoutStorage());
 	}
 	
 	@Override
 		return mapper.registry.getModified(modifiers, baseType.instance(mapper));
 	}
 	
+	@Override
+	public ITypeID withStorage(GlobalTypeRegistry registry, StorageTag storage) {
+		return registry.getModified(modifiers, baseType.withStorage(registry, storage));
+	}
+	
 	@Override
 	public <T> T accept(TypeVisitor<T> visitor) {
 		return visitor.visitModified(this);
 	public int hashCode() {
 		int hash = 3;
 		hash = 79 * hash + Objects.hashCode(this.baseType);
+		hash = 79 * hash + modifiers;
 		return hash;
 	}
 
 	@Override
 	public boolean equals(Object obj) {
-		if (this == obj) {
+		if (this == obj)
 			return true;
-		}
-		if (obj == null) {
+		if (obj == null)
 			return false;
-		}
-		if (getClass() != obj.getClass()) {
+		if (getClass() != obj.getClass())
 			return false;
-		}
 		final ModifiedTypeID other = (ModifiedTypeID) obj;
-		return this.baseType == other.baseType;
+		return this.baseType == other.baseType
+				&& this.modifiers == other.modifiers;
 	}
 	
 	@Override
 			result.append("?");
 		return result.toString();
 	}
+
+	@Override
+	public StorageTag getStorage() {
+		return baseType.getStorage();
+	}
+
+	@Override
+	public ITypeID withoutStorage() {
+		return withoutStorage;
+	}
 }

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

 import java.util.List;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
 	public ITypeID instance(GenericMapper mapper) {
 		return mapper.registry.getRange(baseType.instance(mapper));
 	}
+	
+	@Override
+	public ITypeID withStorage(GlobalTypeRegistry registry, StorageTag storage) {
+		return registry.getRange(baseType.withStorage(registry, storage));
+	}
 
 	@Override
 	public <T> T accept(TypeVisitor<T> visitor) {
 	public String toString() {
 		return baseType.toString() + " .. " + baseType.toString();
 	}
+
+	@Override
+	public StorageTag getStorage() {
+		return ValueStorageTag.INSTANCE;
+	}
+
+	@Override
+	public ITypeID withoutStorage() {
+		return this;
+	}
 }

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

 package org.openzen.zenscript.codemodel.type;
 
 import java.util.List;
+import java.util.Objects;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.storage.AnyStorageTag;
 	public static final StringTypeID UNIQUE = new StringTypeID(UniqueStorageTag.INSTANCE);
 	public static final StringTypeID BORROW = new StringTypeID(BorrowStorageTag.INVOCATION);
 	public static final StringTypeID SHARED = new StringTypeID(SharedStorageTag.INSTANCE);
+	public static final StringTypeID NOSTORAGE = new StringTypeID(null);
 	
 	public final StorageTag storage;
 	
 
 	@Override
 	public ITypeID instance(GenericMapper mapper) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		return this;
+	}
+	
+	@Override
+	public ITypeID withStorage(GlobalTypeRegistry registry, StorageTag storage) {
+		return registry.getString(storage);
 	}
 
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		return false;
 	}
 
 	@Override
 	public void extractTypeParameters(List<TypeParameter> typeParameters) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		
+	}
+	
+	@Override
+	public String toString() {
+		if (storage == null)
+			return "string";
+		
+		return "string`" + storage.toString();
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = 5;
+		hash = 97 * 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 StringTypeID other = (StringTypeID) obj;
+		return Objects.equals(this.storage, other.storage);
+	}
+
+	@Override
+	public StorageTag getStorage() {
+		return storage;
+	}
+
+	@Override
+	public ITypeID withoutStorage() {
+		return NOSTORAGE;
 	}
 }

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

 
 	@Override
 	public Void visitDefinition(DefinitionTypeID definition) {
-		for (ITypeID argument : definition.typeParameters)
+		for (ITypeID argument : definition.typeArguments)
 			argument.accept(this);
 		if (definition.outer != null)
 			visitDefinition(definition.outer);

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

 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	
 	@Override
 	public IPartialExpression getExpression(CodePosition position, BaseScope scope, ITypeID[] typeArguments) {
-		return new PartialTypeExpression(position, scope.getTypeRegistry().getForDefinition(definition, typeArguments), typeArguments);
+		return new PartialTypeExpression(position, scope.getTypeRegistry().getForDefinition(definition, null, typeArguments), typeArguments);
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, TypeResolutionContext context, ITypeID[] typeArguments) {
-		return context.getTypeRegistry().getForDefinition(definition, typeArguments);
+	public ITypeID getType(CodePosition position, TypeResolutionContext context, ITypeID[] typeArguments, StorageTag storage) {
+		return context.getTypeRegistry().getForDefinition(definition, storage, typeArguments);
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/UnstoredTypeID.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 org.openzen.zenscript.codemodel.type.storage.StorageTag;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface UnstoredTypeID {
+	ITypeID withStorage(GlobalTypeRegistry registry, StorageTag storage);
+}

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

 import org.openzen.zenscript.codemodel.member.IteratorMember;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.codemodel.type.TypeVisitor;
+import org.openzen.zenscript.codemodel.type.storage.AnyStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.StaticStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 
 /**
  *
 	public Void visitString(StringTypeID string) {
 		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "string", Modifiers.EXPORT, null);
 		
-		constructor(builtin, STRING_CONSTRUCTOR_CHARACTERS, registry.getArray(CHAR, 1));
+		constructor(builtin, STRING_CONSTRUCTOR_CHARACTERS, registry.getModified(ModifiedTypeID.MODIFIER_CONST, registry.getArray(CHAR, 1, BorrowStorageTag.INVOCATION)));
 		
 		add(builtin, STRING_ADD_STRING, StringTypeID.BORROW, StringTypeID.UNIQUE);
 		indexGet(builtin, STRING_INDEXGET, USIZE, CHAR);
 		compare(builtin, STRING_COMPARE, StringTypeID.BORROW);
 		
 		getter(builtin, STRING_LENGTH, "length", USIZE);
-		getter(builtin, STRING_CHARACTERS, "characters", registry.getArray(CHAR, 1));
+		getter(builtin, STRING_CHARACTERS, "characters", registry.getArray(CHAR, 1, UniqueStorageTag.INSTANCE)); // TODO: can this be const borrowed / immutable borrowed?
 		getter(builtin, STRING_ISEMPTY, "isEmpty", BOOL);
 
 		method(builtin, STRING_REMOVE_DIACRITICS, "removeDiacritics", StringTypeID.BORROW);
 					ARRAY_INDEXGETRANGE);
 			
 			if (baseType == BYTE)
-				castImplicit(definition, BYTE_ARRAY_AS_SBYTE_ARRAY, registry.getArray(SBYTE, 1));
+				castImplicit(definition, BYTE_ARRAY_AS_SBYTE_ARRAY, registry.getArray(SBYTE, 1, array.storage));
 			if (baseType == SBYTE)
-				castImplicit(definition, SBYTE_ARRAY_AS_BYTE_ARRAY, registry.getArray(BYTE, 1));
+				castImplicit(definition, SBYTE_ARRAY_AS_BYTE_ARRAY, registry.getArray(BYTE, 1, array.storage));
 			if (baseType == SHORT)
-				castImplicit(definition, SHORT_ARRAY_AS_USHORT_ARRAY, registry.getArray(USHORT, 1));
+				castImplicit(definition, SHORT_ARRAY_AS_USHORT_ARRAY, registry.getArray(USHORT, 1, array.storage));
 			if (baseType == USHORT)
-				castImplicit(definition, USHORT_ARRAY_AS_SHORT_ARRAY, registry.getArray(SHORT, 1));
+				castImplicit(definition, USHORT_ARRAY_AS_SHORT_ARRAY, registry.getArray(SHORT, 1, array.storage));
 			if (baseType == INT)
-				castImplicit(definition, INT_ARRAY_AS_UINT_ARRAY, registry.getArray(UINT, 1));
+				castImplicit(definition, INT_ARRAY_AS_UINT_ARRAY, registry.getArray(UINT, 1, array.storage));
 			if (baseType == UINT)
-				castImplicit(definition, UINT_ARRAY_AS_INT_ARRAY, registry.getArray(INT, 1));
+				castImplicit(definition, UINT_ARRAY_AS_INT_ARRAY, registry.getArray(INT, 1, array.storage));
 			if (baseType == LONG)
-				castImplicit(definition, LONG_ARRAY_AS_ULONG_ARRAY, registry.getArray(ULONG, 1));
+				castImplicit(definition, LONG_ARRAY_AS_ULONG_ARRAY, registry.getArray(ULONG, 1, array.storage));
 			if (baseType == ULONG)
-				castImplicit(definition, ULONG_ARRAY_AS_LONG_ARRAY, registry.getArray(LONG, 1));
+				castImplicit(definition, ULONG_ARRAY_AS_LONG_ARRAY, registry.getArray(LONG, 1, array.storage));
 		}
 
 		FunctionHeader containsHeader = new FunctionHeader(BOOL, new FunctionParameter(baseType, "value"));
 			lambdaConstructorParameters[i] = new FunctionParameter(USIZE, null);
 		
 		FunctionHeader lambdaConstructorFunction = new FunctionHeader(baseType, indexGetParameters);
-		lambdaConstructorParameters[dimension] = new FunctionParameter(cache.getRegistry().getFunction(lambdaConstructorFunction), null);
+		lambdaConstructorParameters[dimension] = new FunctionParameter(cache.getRegistry().getFunction(lambdaConstructorFunction, BorrowStorageTag.INVOCATION), null);
 		FunctionHeader lambdaConstructorHeader = new FunctionHeader(VOID, lambdaConstructorParameters);
 		members.addConstructor(new ConstructorMember(
 				BUILTIN,
 		
 		{
 			TypeParameter mappedConstructorParameter = new TypeParameter(BUILTIN, "T");
-			FunctionHeader mappedConstructorHeaderWithoutIndex = new FunctionHeader(baseType, registry.getGeneric(mappedConstructorParameter));
+			FunctionHeader mappedConstructorHeaderWithoutIndex = new FunctionHeader(baseType, registry.getGeneric(mappedConstructorParameter, BorrowStorageTag.INVOCATION));
 			FunctionHeader mappedConstructorFunctionWithoutIndex = new FunctionHeader(
 					new TypeParameter[] { mappedConstructorParameter },
 					VOID,
 					null,
-					new FunctionParameter(registry.getArray(registry.getGeneric(mappedConstructorParameter), dimension), "original"),
-					new FunctionParameter(registry.getFunction(mappedConstructorHeaderWithoutIndex), "projection"));
+					new FunctionParameter(registry.getArray(registry.getGeneric(mappedConstructorParameter, BorrowStorageTag.INVOCATION), dimension, BorrowStorageTag.INVOCATION), "original"),
+					new FunctionParameter(registry.getFunction(mappedConstructorHeaderWithoutIndex, BorrowStorageTag.INVOCATION), "projection"));
 			members.addConstructor(new ConstructorMember(
 					BUILTIN,
 					definition,
 			FunctionParameter[] projectionParameters = new FunctionParameter[dimension + 1];
 			for (int i = 0; i < dimension; i++)
 				projectionParameters[i] = new FunctionParameter(USIZE);
-			projectionParameters[dimension] = new FunctionParameter(registry.getGeneric(mappedConstructorParameter));
+			projectionParameters[dimension] = new FunctionParameter(registry.getGeneric(mappedConstructorParameter, BorrowStorageTag.INVOCATION));
 			
 			FunctionHeader mappedConstructorHeaderWithIndex = new FunctionHeader(baseType, projectionParameters);
 			FunctionHeader mappedConstructorFunctionWithIndex = new FunctionHeader(
 					new TypeParameter[] { mappedConstructorParameter },
 					VOID,
 					null,
-					new FunctionParameter(registry.getArray(registry.getGeneric(mappedConstructorParameter), dimension), "original"),
-					new FunctionParameter(registry.getFunction(mappedConstructorHeaderWithIndex), "projection"));
+					new FunctionParameter(registry.getArray(registry.getGeneric(mappedConstructorParameter, BorrowStorageTag.INVOCATION), dimension, BorrowStorageTag.INVOCATION), "original"),
+					new FunctionParameter(registry.getFunction(mappedConstructorHeaderWithIndex, BorrowStorageTag.INVOCATION), "projection"));
 			constructor(definition, ARRAY_CONSTRUCTOR_PROJECTED_INDEXED, mappedConstructorFunctionWithIndex);
 		}
 		
 		
 		getter(builtin, BuiltinID.ASSOC_SIZE, "size", USIZE);
 		getter(builtin, BuiltinID.ASSOC_ISEMPTY, "isEmpty", BOOL);
-		getter(builtin, BuiltinID.ASSOC_KEYS, "keys", cache.getRegistry().getArray(keyType, 1));
-		getter(builtin, BuiltinID.ASSOC_VALUES, "values", cache.getRegistry().getArray(valueType, 1));
+		getter(builtin, BuiltinID.ASSOC_KEYS, "keys", cache.getRegistry().getArray(keyType, 1, UniqueStorageTag.INSTANCE));
+		getter(builtin, BuiltinID.ASSOC_VALUES, "values", cache.getRegistry().getArray(valueType, 1, UniqueStorageTag.INSTANCE));
 		getter(builtin, BuiltinID.ASSOC_HASHCODE, "objectHashCode", BasicTypeID.INT);
 		
 		iterator(builtin, ITERATOR_ASSOC_KEYS, keyType);
 	@Override
 	public Void visitGenericMap(GenericMapTypeID map) {
 		TypeParameter functionParameter = new TypeParameter(BUILTIN, "T");
-		Map<TypeParameter, ITypeID> parameterFilled = Collections.singletonMap(map.key, registry.getGeneric(functionParameter));
+		Map<TypeParameter, ITypeID> parameterFilled = Collections.singletonMap(map.key, registry.getGeneric(functionParameter, null));
 		ITypeID valueType = map.value.instance(new GenericMapper(registry, parameterFilled));
 		
 		FunctionHeader getOptionalHeader = new FunctionHeader(new TypeParameter[] { functionParameter }, registry.getOptional(valueType), null, new FunctionParameter[0]);
 			for (int i = 0; i < constValues.length; i++)
 				constValues[i] = new EnumConstantExpression(BUILTIN, type, enumConstants.get(i));
 			
-			constant(definition, ENUM_VALUES, "values", new ArrayExpression(BUILTIN, constValues, registry.getArray(type, 1)));
+			constant(definition, ENUM_VALUES, "values", new ArrayExpression(BUILTIN, constValues, registry.getArray(type, 1, StaticStorageTag.INSTANCE)));
 			compare(definition, ENUM_COMPARE, type);
 			
 			if (!members.canCast(StringTypeID.STATIC)) {

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

 import org.openzen.zenscript.codemodel.expression.InterfaceCastExpression;
 import org.openzen.zenscript.codemodel.expression.MakeConstExpression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
+import org.openzen.zenscript.codemodel.expression.StorageCastExpression;
 import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	}
 	
 	public boolean extendsOrImplements(ITypeID other) {
-		other = other.getNormalized();
+		other = other.getNormalized().withoutStorage();
 		ITypeID superType = type.getSuperType(cache.getRegistry());
 		if (superType != null) {
 			if (superType == other)
 	
 	public boolean canCastImplicit(ITypeID toType) {
 		toType = toType.getNormalized();
-		if (toType == type)
+		if (areEquivalent(type, toType))
 			return true;
-		if (toType == null)
-			throw new NullPointerException();
 		if (toType == BasicTypeID.UNDETERMINED)
 			throw new IllegalArgumentException("Cannot cast to undetermined type!");
-		
 		if (type == BasicTypeID.NULL && toType.isOptional())
 			return true;
+		
+		if (!type.getStorage().canCastTo(toType.getStorage()) && !toType.getStorage().canCastFrom(type.getStorage()))
+			return false;
+		
 		if (toType.isOptional() && canCastImplicit(toType.withoutOptional()))
 			return true;
 		if (toType.isConst() && canCastImplicit(toType.withoutConst()))
 			return true;
-		if (type.isOptional() && type.withoutOptional() == toType)
+		if (type.isOptional() && areEquivalent(type.withoutOptional(), toType))
 			return true;
 		
 		return getImplicitCaster(toType) != null || extendsOrImplements(toType);
 	}
 	
+	private boolean areEquivalent(ITypeID fromType, ITypeID toType) {
+		if (fromType == toType)
+			return true;
+		if (fromType.getStorage() == null || toType.getStorage() == null)
+			throw new NullPointerException();
+		if (!fromType.getStorage().canCastTo(toType.getStorage()) && !toType.getStorage().canCastFrom(fromType.getStorage()))
+			return false;
+		
+		return fromType.withoutStorage() == toType.withoutStorage();
+	}
+	
 	public CasterMemberRef getImplicitCaster(ITypeID toType) {
 		toType = toType.getNormalized();
 		for (TypeMember<CasterMemberRef> caster : casters) {
-			if (caster.member.isImplicit() && toType == caster.member.toType)
+			if (caster.member.isImplicit() && areEquivalent(caster.member.toType, toType))
 				return caster.member;
 		}
 		
 	public CasterMemberRef getCaster(ITypeID toType) {
 		toType = toType.getNormalized();
 		for (TypeMember<CasterMemberRef> caster : casters) {
-			if (toType == caster.member.toType)
+			if (areEquivalent(caster.member.toType, toType))
 				return caster.member;
 		}
 		
 			return true;
 		
 		for (TypeMember<CasterMemberRef> caster : casters) {
-			if (toType == caster.member.toType)
+			if (areEquivalent(caster.member.toType, toType))
 				return true;
 		}
 		
 		return false;
 	}
 	
+	private Expression castEquivalent(CodePosition position, Expression value, ITypeID toType) {
+		if (toType == value.type)
+			return value;
+		
+		return new StorageCastExpression(position, value, toType);
+	}
+	
 	public Expression castImplicit(CodePosition position, Expression value, ITypeID toType, boolean implicit) {
 		toType = toType.getNormalized();
 		if (toType == type || toType == BasicTypeID.UNDETERMINED)
 			return value;
+		if (toType.withoutStorage() == type.withoutStorage())
+			return new StorageCastExpression(position, value, toType);
 		if (toType == null)
 			throw new NullPointerException();
 		
 		if (type == BasicTypeID.NULL && toType.isOptional())
 			return new NullExpression(position, toType);
 		if (toType.isOptional() && canCastImplicit(toType.withoutOptional()))
-			return new WrapOptionalExpression(position, castImplicit(position, value, toType.withoutOptional(), implicit), toType);
+			return castEquivalent(position, new WrapOptionalExpression(position, castImplicit(position, value, toType.withoutOptional(), implicit), toType), toType);
 		if (toType.isConst() && canCastImplicit(toType.withoutConst()))
-			return new MakeConstExpression(position, castImplicit(position, value, toType.withoutConst(), implicit), toType);
-		if (type.isOptional() && type.withoutOptional() == toType)
-			return new CheckNullExpression(position, value);
+			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);
 		
 		for (TypeMember<CasterMemberRef> caster : casters) {
-			if (caster.member.isImplicit() && toType == caster.member.toType)
-				return caster.member.cast(position, value, implicit);
+			if (caster.member.isImplicit() && areEquivalent(caster.member.toType, toType))
+				return castEquivalent(position, caster.member.cast(position, value, implicit), toType);
 		}
 		for (TypeMember<ImplementationMemberRef> implementation : implementations) {
 			if (implementation.member.implementsType.equals(toType))
 		if (members.containsKey(name.name))
 			return new PartialStaticMemberGroupExpression(position, scope, type, members.get(name.name), name.arguments);
 		if (innerTypes.containsKey(name.name))
-			return new PartialTypeExpression(position, innerTypes.get(name.name).instance(cache.getRegistry(), name.arguments, (DefinitionTypeID)type), name.arguments);
+			return new PartialTypeExpression(position, innerTypes.get(name.name).instance(cache.getRegistry(), name.arguments, (DefinitionTypeID)type, null), name.arguments);
 		if (variantOptions.containsKey(name.name))
 			return new PartialVariantOptionExpression(position, scope, variantOptions.get(name.name));
 		
 		return innerTypes.containsKey(name);
 	}
 	
-	public DefinitionTypeID getInnerType(CodePosition position, GenericName name) {
+	public DefinitionTypeID getInnerType(CodePosition position, GenericName name, StorageTag storage) {
 		if (!innerTypes.containsKey(name.name))
 			throw new CompileException(position, CompileExceptionCode.NO_SUCH_INNER_TYPE, "No such inner type in " + type + ": " + name.name);
 		
-		return innerTypes.get(name.name).instance(cache.getRegistry(), name.arguments, (DefinitionTypeID)type);
+		return innerTypes.get(name.name).instance(cache.getRegistry(), name.arguments, (DefinitionTypeID)type, storage);
 	}
 	
 	@Override

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

 	public StorageType getType() {
 		return AnyStorageType.INSTANCE;
 	}
+	
+	@Override
+	public String toString() {
+		return "any";
+	}
+
+	@Override
+	public boolean canCastTo(StorageTag other) {
+		return other == BorrowStorageTag.INVOCATION;
+	}
+
+	@Override
+	public boolean canCastFrom(StorageTag other) {
+		return true;
+	}
 }

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

  */
 package org.openzen.zenscript.codemodel.type.storage;
 
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
+
 /**
  *
  * @author Hoofdgebruiker
 	public static final AnyStorageType INSTANCE = new AnyStorageType();
 	
 	private AnyStorageType() {}
+
+	@Override
+	public String getName() {
+		return "any";
+	}
+
+	@Override
+	public StorageTag instance(CodePosition position, String[] arguments) {
+		if (arguments != null)
+			throw new CompileException(position, CompileExceptionCode.INVALID_STORAGE_TYPE_ARGUMENTS, "any storage type doesn't take arguments");
+		
+		return AnyStorageTag.INSTANCE;
+	}
 }

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

  */
 public class BorrowStorageTag implements StorageTag {
 	public static final BorrowStorageTag INVOCATION = new BorrowStorageTag();
+	public static final BorrowStorageTag THIS = new BorrowStorageTag();
 	
 	private BorrowStorageTag() {} // TODO: scoped borrow
 
 	public StorageType getType() {
 		return BorrowStorageType.INSTANCE;
 	}
+	
+	@Override
+	public String toString() {
+		return "borrow";
+	}
+
+	@Override
+	public boolean canCastTo(StorageTag other) {
+		return this == other;
+	}
+
+	@Override
+	public boolean canCastFrom(StorageTag other) {
+		return true;
+	}
 }

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

  */
 package org.openzen.zenscript.codemodel.type.storage;
 
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
+
 /**
  *
  * @author Hoofdgebruiker
 	public static final BorrowStorageType INSTANCE = new BorrowStorageType();
 
 	private BorrowStorageType() {}
+
+	@Override
+	public String getName() {
+		return "borrow";
+	}
+
+	@Override
+	public StorageTag instance(CodePosition position, String[] arguments) {
+		if (arguments != null) {
+			if (arguments.length == 1 && arguments[0].equals("this"))
+				return BorrowStorageTag.THIS;
+			
+			throw new CompileException(position, CompileExceptionCode.INVALID_STORAGE_TYPE_ARGUMENTS, "borrow storage type doesn't take arguments");
+		}
+		
+		return BorrowStorageTag.INVOCATION;
+	}
 }

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

 	public StorageType getType() {
 		return SharedStorageType.INSTANCE;
 	}
+	
+	@Override
+	public String toString() {
+		return "shared";
+	}
+
+	@Override
+	public boolean canCastTo(StorageTag other) {
+		return false;
+	}
+
+	@Override
+	public boolean canCastFrom(StorageTag other) {
+		return other == this || other == UniqueStorageTag.INSTANCE;
+	}
 }

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

  */
 package org.openzen.zenscript.codemodel.type.storage;
 
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
+
 /**
  *
  * @author Hoofdgebruiker
 	public static final SharedStorageType INSTANCE = new SharedStorageType();
 	
 	private SharedStorageType() {}
+
+	@Override
+	public String getName() {
+		return "shared";
+	}
+
+	@Override
+	public StorageTag instance(CodePosition position, String[] arguments) {
+		if (arguments != null)
+			throw new CompileException(position, CompileExceptionCode.INVALID_STORAGE_TYPE_ARGUMENTS, "shared storage type doesn't take arguments");
+		
+		return SharedStorageTag.INSTANCE;
+	}
 }

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

 	public StorageType getType() {
 		return StaticStorageType.INSTANCE;
 	}
+	
+	@Override
+	public String toString() {
+		return "static";
+	}
+
+	@Override
+	public boolean canCastTo(StorageTag other) {
+		return false;
+	}
+
+	@Override
+	public boolean canCastFrom(StorageTag other) {
+		return other == this || other == UniqueStorageTag.INSTANCE;
+	}
 }

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

  */
 package org.openzen.zenscript.codemodel.type.storage;
 
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
+
 /**
  *
  * @author Hoofdgebruiker
 	public static final StaticStorageType INSTANCE = new StaticStorageType();
 	
 	private StaticStorageType() {}
+
+	@Override
+	public String getName() {
+		return "static";
+	}
+
+	@Override
+	public StorageTag instance(CodePosition position, String[] arguments) {
+		if (arguments != null)
+			throw new CompileException(position, CompileExceptionCode.INVALID_STORAGE_TYPE_ARGUMENTS, "static storage type doesn't take arguments");
+		
+		return StaticStorageTag.INSTANCE;
+	}
 }

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

  */
 public interface StorageTag {
 	StorageType getType();
+	
+	boolean canCastTo(StorageTag other);
+	
+	boolean canCastFrom(StorageTag other);
 }

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

  */
 package org.openzen.zenscript.codemodel.type.storage;
 
+import org.openzen.zencode.shared.CodePosition;
+
 /**
  *
  * @author Hoofdgebruiker
  */
 public interface StorageType {
+	public static StorageType[] getStandard() {
+		return new StorageType[] {
+			AnyStorageType.INSTANCE,
+			BorrowStorageType.INSTANCE,
+			SharedStorageType.INSTANCE,
+			StaticStorageType.INSTANCE,
+			UniqueStorageType.INSTANCE
+		};
+	}
+	
+	String getName();
 	
+	StorageTag instance(CodePosition position, String[] arguments);
 }

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

 	public StorageType getType() {
 		return UniqueStorageType.INSTANCE;
 	}
+	
+	@Override
+	public String toString() {
+		return "unique";
+	}
+
+	@Override
+	public boolean canCastTo(StorageTag other) {
+		return false;
+	}
+
+	@Override
+	public boolean canCastFrom(StorageTag other) {
+		return other == this;
+	}
 }

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

  */
 package org.openzen.zenscript.codemodel.type.storage;
 
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
+
 /**
  *
  * @author Hoofdgebruiker
 	public static final UniqueStorageType INSTANCE = new UniqueStorageType();
 	
 	private UniqueStorageType() {}
+
+	@Override
+	public String getName() {
+		return "unique";
+	}
+
+	@Override
+	public StorageTag instance(CodePosition position, String[] arguments) {
+		if (arguments != null)
+			throw new CompileException(position, CompileExceptionCode.INVALID_STORAGE_TYPE_ARGUMENTS, "unique storage type doesn't take arguments");
+		
+		return UniqueStorageTag.INSTANCE;
+	}
 }

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.type.storage;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ValueStorageTag implements StorageTag {
+	public static final ValueStorageTag INSTANCE = new ValueStorageTag();
+			
+	private ValueStorageTag() {}
+
+	@Override
+	public StorageType getType() {
+		return ValueStorageType.INSTANCE;
+	}
+
+	@Override
+	public boolean canCastTo(StorageTag other) {
+		return other == this;
+	}
+
+	@Override
+	public boolean canCastFrom(StorageTag other) {
+		return other == this;
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.type.storage;
+
+import org.openzen.zencode.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ValueStorageType implements StorageType {
+	public static final ValueStorageType INSTANCE = new ValueStorageType();
+	
+	private ValueStorageType() {}
+
+	@Override
+	public String getName() {
+		return "value";
+	}
+
+	@Override
+	public StorageTag instance(CodePosition position, String[] arguments) {
+		return ValueStorageTag.INSTANCE;
+	}
+}

CompilerShared/src/main/java/org/openzen/zenscript/compiler/CompileScope.java

 import java.util.List;
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
+import org.openzen.zenscript.codemodel.type.storage.StorageType;
 
 /**
  *
 	private final List<ExpansionDefinition> expansions;
 	private final LocalMemberCache cache;
 	private final Map<String, AnnotationDefinition> annotations = new HashMap<>();
+	private final Map<String, StorageType> storageTypes = new HashMap<>();
 	
-	public CompileScope(GlobalTypeRegistry globalRegistry, List<ExpansionDefinition> expansions, AnnotationDefinition[] annotations) {
+	public CompileScope(GlobalTypeRegistry globalRegistry, List<ExpansionDefinition> expansions, AnnotationDefinition[] annotations, StorageType[] storageTypes) {
 		this.globalRegistry = globalRegistry;
 		this.expansions = expansions;
 		this.cache = new LocalMemberCache(globalRegistry, expansions);
 		
-		for (AnnotationDefinition annotation : annotations) {
+		for (AnnotationDefinition annotation : annotations)
 			this.annotations.put(annotation.getAnnotationName(), annotation);
-		}
+		for (StorageType type : storageTypes)
+			this.storageTypes.put(type.getName(), type);
 	}
 
 	@Override
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, List<GenericName> name) {
+	public ITypeID getType(CodePosition position, List<GenericName> name, StorageTag storage) {
 		throw new UnsupportedOperationException("Not supported yet.");
 	}
 	
+	@Override
+	public StorageTag getStorageTag(CodePosition position, String name, String[] arguments) {
+		if (!storageTypes.containsKey(name))
+			throw new CompileException(position, CompileExceptionCode.NO_SUCH_STORAGE_TYPE, "No such storage type: " + name);
+		
+		return storageTypes.get(name).instance(position, arguments);
+	}
+	
 	@Override
 	public ITypeID getThisType() {
 		return null;

CompilerShared/src/main/java/org/openzen/zenscript/compiler/ModuleSpace.java

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

CompilerShared/src/main/java/org/openzen/zenscript/compiler/SemanticModule.java

 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.scope.FileScope;
 import org.openzen.zenscript.codemodel.type.ISymbol;
+import org.openzen.zenscript.codemodel.type.storage.StorageType;
 import org.openzen.zenscript.validator.ValidationLogEntry;
 import org.openzen.zenscript.validator.Validator;
 
 	public final CompilationUnit compilationUnit;
 	public final List<ExpansionDefinition> expansions;
 	public final AnnotationDefinition[] annotations;
+	public final StorageType[] storageTypes;
 	
 	public SemanticModule(
 			String name,
 			List<ScriptBlock> scripts,
 			CompilationUnit compilationUnit,
 			List<ExpansionDefinition> expansions,
-			AnnotationDefinition[] annotations)
+			AnnotationDefinition[] annotations,
+			StorageType[] storageTypes)
 	{
 		this.name = name;
 		this.module = module;
 		this.compilationUnit = compilationUnit;
 		this.expansions = expansions;
 		this.annotations = annotations;
+		this.storageTypes = storageTypes;
 	}
 	
 	public boolean isValid() {
 		if (state != State.ASSEMBLED)
 			throw new IllegalStateException("Module is invalid");
 		
-		ModuleTypeResolutionContext context = new ModuleTypeResolutionContext(compilationUnit.globalTypeRegistry, annotations, rootPackage, null, globals);
+		ModuleTypeResolutionContext context = new ModuleTypeResolutionContext(compilationUnit.globalTypeRegistry, annotations, storageTypes, rootPackage, null, globals);
 		AnnotationProcessor annotationProcessor = new AnnotationProcessor(context, expansions);
 		List<ScriptBlock> processedScripts = new ArrayList<>();
 		for (ScriptBlock block : scripts)
 				processedScripts,
 				compilationUnit,
 				expansions,
-				annotations);
+				annotations,
+				storageTypes);
 	}
 	
 	public boolean validate(Consumer<ValidationLogEntry> logger) {

Constructor/src/main/java/org/openzen/zenscript/constructor/module/DirectoryModuleReference.java

 import org.openzen.zenscript.constructor.ParsedModule;
 import org.openzen.zenscript.constructor.ModuleLoader;
 import org.openzen.zenscript.codemodel.type.TypeSymbol;
+import org.openzen.zenscript.codemodel.type.storage.StorageType;
 import org.openzen.zenscript.parser.ParsedFile;
 
 /**
 			}
 
 			// TODO: annotation type registration
-			ModuleSpace space = new ModuleSpace(unit, new ArrayList<>());
+			ModuleSpace space = new ModuleSpace(unit, new ArrayList<>(), StorageType.getStandard());
 			SemanticModule[] dependencies = new SemanticModule[dependencyNames.size()];
 			for (int i = 0; i < dependencies.length; i++) {
 				String dependencyName = dependencyNames.get(i);

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

 
 import org.openzen.drawablegui.DEmptyView;
 import org.openzen.drawablegui.DScalableSize;
-import org.openzen.drawablegui.DSizing;
 import org.openzen.drawablegui.border.DLineBorder;
 import org.openzen.drawablegui.scroll.DScrollPane;
 import org.openzen.drawablegui.layout.DSideLayout;

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

 			writer.invokeStatic(method);
 		return null;
 	}
+	
+	@Override
+	public Void visitString(StringTypeID string) {
+		//NO-OP
+		return null;
+	}
 
 	@Override
 	public Void visitArray(ArrayTypeID array) {

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

 
 import java.io.FileOutputStream;
 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;
 	public static final JavaMethod OBJECT_HASHCODE = JavaMethod.getNativeVirtual(JavaClass.OBJECT, "hashCode", "()I");
 	private static final JavaMethod COLLECTION_SIZE = JavaMethod.getNativeVirtual(JavaClass.COLLECTION, "size", "()I");
 	private static final JavaMethod COLLECTION_TOARRAY = JavaMethod.getNativeVirtual(JavaClass.COLLECTION, "toArray", "([Ljava/lang/Object;)[Ljava/lang/Object;");
-
+	
+	private static final JavaMethod SHARED_INIT = JavaMethod.getConstructor(JavaClass.SHARED, "(Ljava/lang/Object;)V", Modifier.PUBLIC);
+	private static final JavaMethod SHARED_GET = JavaMethod.getNativeVirtual(JavaClass.SHARED, "get", "()Ljava/lang/Object;");
+	private static final JavaMethod SHARED_ADDREF = JavaMethod.getNativeVirtual(JavaClass.SHARED, "addRef", "()V");
+	private static final JavaMethod SHARED_RELEASE = JavaMethod.getNativeVirtual(JavaClass.SHARED, "release", "()V");
+	
 	protected final JavaWriter javaWriter;
 	private final JavaCapturedExpressionVisitor capturedExpressionVisitor = new JavaCapturedExpressionVisitor(this);
 	private final JavaBytecodeContext context;
 						case CHAR:
 							javaWriter.invokeStatic(ARRAYS_COPY_OF_RANGE_CHARS);
 							break;
-						case STRING:
-							javaWriter.invokeStatic(ARRAYS_COPY_OF_RANGE_OBJECTS);
-							javaWriter.checkCast("[Ljava/lang/String;");
-							break;
 						default:
 							throw new IllegalArgumentException("Unknown basic type: " + type.elementType);
 					}
 						case CHAR:
 							javaWriter.invokeStatic(ARRAYS_EQUALS_CHARS);
 							break;
-						case STRING:
-							javaWriter.invokeStatic(ARRAYS_EQUALS_OBJECTS);
-							break;
 						default:
 							throw new IllegalArgumentException("Unknown basic type: " + type.elementType);
 					}
 
 		final JavaMethod methodInfo = JavaMethod.getNativeVirtual(javaWriter.method.cls, "accept", signature);
 		final ClassWriter lambdaCW = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
-		lambdaCW.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, name, null, "java/lang/Object", new String[]{context.getInternalName(new FunctionTypeID(null, expression.header))});
+		lambdaCW.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, name, null, "java/lang/Object", new String[]{context.getInternalName(new FunctionTypeID(null, expression.header, null))});
 		final JavaWriter functionWriter = new JavaWriter(lambdaCW, methodInfo, null, signature, null, "java/lang/Override");
 
 		javaWriter.newObject(name);
 				break;
 			case ASSOC_KEYS: {
 				AssocTypeID type = (AssocTypeID) expression.target.type;
-				ArrayTypeID result = new ArrayTypeID(null, type.keyType, 1);
+				ArrayTypeID result = new ArrayTypeID(null, type.keyType, 1, UniqueStorageTag.INSTANCE);
 				Type resultType = context.getType(result);
 
 				javaWriter.invokeVirtual(MAP_KEYS);
 			}
 			case ASSOC_VALUES: {
 				AssocTypeID type = (AssocTypeID) expression.target.type;
-				ArrayTypeID result = new ArrayTypeID(null, type.valueType, 1);
+				ArrayTypeID result = new ArrayTypeID(null, type.valueType, 1, UniqueStorageTag.INSTANCE);
 				Type resultType = context.getType(result);
 
 				javaWriter.invokeVirtual(MAP_VALUES);
 						case CHAR:
 							javaWriter.invokeStatic(ARRAYS_HASHCODE_CHARS);
 							break;
-						case STRING:
-							javaWriter.invokeStatic(ARRAYS_DEEPHASHCODE);
-							break;
 						default:
 							throw new IllegalArgumentException("Unknown basic type: " + type.elementType);
 					}
 		expression.value.accept(this);
 
 		//TODO replace beforeSwitch visitor or similar
-		if (expression.value.type == BasicTypeID.STRING)
+		if (expression.value.type instanceof StringTypeID)
 			javaWriter.invokeVirtual(OBJECT_HASHCODE);
 
 		//TODO replace with beforeSwitch visitor or similar
 
 	@Override
 	public Void visitStaticSetter(StaticSetterExpression expression) {
+		throw new UnsupportedOperationException("Not yet implemented");
+	}
+	
+	@Override
+	public Void visitStorageCast(StorageCastExpression expression) {
+		expression.value.accept(this);
+		
+		if (expression.type.isDestructible()) { // only destructible types matter here; nondestructible types never need conversion
+			StorageTag fromTag = expression.value.type.getStorage();
+			StorageTag toTag = expression.type.getStorage();
+			if (fromTag == SharedStorageTag.INSTANCE && toTag == BorrowStorageTag.INVOCATION) {
+				// Shared<T>.get()
+				javaWriter.invokeVirtual(SHARED_GET);
+			} else if (fromTag == UniqueStorageTag.INSTANCE && toTag == SharedStorageTag.INSTANCE) {
+				// new Shared<T>(value)
+				javaWriter.newObject("zsynthetic/Shared");
+				javaWriter.dup();
+				javaWriter.invokeSpecial(SHARED_INIT);
+			}
+		}
+		
 		return null;
 	}
 

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

 		throw new UnsupportedOperationException("Invalid increment target");
 	}
 	
+	@Override
+	public Void visitStorageCast(StorageCastExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+	
 	@Override
 	public Void visitSupertypeCast(SupertypeCastExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");

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

 		throw new UnsupportedOperationException("Invalid increment target");
 	}
 	
+	@Override
+	public Void visitStorageCast(StorageCastExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+	
 	@Override
 	public Void visitSupertypeCast(SupertypeCastExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");

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

 import org.objectweb.asm.Label;
 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.statement.*;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 
 import java.util.Arrays;
 import java.util.List;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 
 public class JavaStatementVisitor implements StatementVisitor<Boolean> {
 
 		javaWriter.label(start);
 		statement.value.accept(expressionVisitor);
-		if (statement.value.type == BasicTypeID.STRING)
+		if (statement.value.type instanceof StringTypeID)
 			javaWriter.invokeVirtual(JavaExpressionVisitor.OBJECT_HASHCODE);
 		boolean out = false;
 

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

 	public static final JavaClass CHARACTER = new JavaClass("java.lang", "Character", Kind.CLASS);
 	public static final JavaClass COLLECTION = new JavaClass("java.util", "Collection", Kind.INTERFACE);
 	
+	public static final JavaClass SHARED = new JavaClass("zsynthetic", "Shared", Kind.CLASS);
+	
 	public static JavaClass fromInternalName(String internalName, Kind kind) {
 		if (kind == Kind.ARRAY)
 			return new JavaClass("", internalName, kind, new String[0]);

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

 			functions.put("TToU", new JavaSynthesizedFunction(
 					new JavaClass("java.util.function", "Function", JavaClass.Kind.INTERFACE),
 					new TypeParameter[] { t, u },
-					new FunctionHeader(registry.getGeneric(u), registry.getGeneric(t)),
+					new FunctionHeader(registry.getGeneric(u, null), registry.getGeneric(t, null)),
 					"apply"));
 			
 			functions.put("TUToV", new JavaSynthesizedFunction(
 					new JavaClass("java.util.function", "BiFunction", JavaClass.Kind.INTERFACE),
 					new TypeParameter[] { t, u, v },
-					new FunctionHeader(registry.getGeneric(v), registry.getGeneric(t), registry.getGeneric(u)),
+					new FunctionHeader(registry.getGeneric(v, null), registry.getGeneric(t, null), registry.getGeneric(u, null)),
 					"apply"));
 			
 			functions.put("TToVoid", new JavaSynthesizedFunction(
 					new JavaClass("java.util.function", "Consumer", JavaClass.Kind.INTERFACE),
 					new TypeParameter[] { t },
-					new FunctionHeader(BasicTypeID.VOID, registry.getGeneric(t)),
+					new FunctionHeader(BasicTypeID.VOID, registry.getGeneric(t, null)),
 					"accept"));
 			
 			functions.put("TUToVoid", new JavaSynthesizedFunction(
 					new JavaClass("java.util.function", "BiConsumer", JavaClass.Kind.INTERFACE),
 					new TypeParameter[] { t, u },
-					new FunctionHeader(BasicTypeID.VOID, registry.getGeneric(t), registry.getGeneric(u)),
+					new FunctionHeader(BasicTypeID.VOID, registry.getGeneric(t, null), registry.getGeneric(u, null)),
 					"accept"));
 			
 			functions.put("TToBool", new JavaSynthesizedFunction(
 					new JavaClass("java.util.function", "Predicate", JavaClass.Kind.INTERFACE),
 					new TypeParameter[] { t },
-					new FunctionHeader(BasicTypeID.BOOL, registry.getGeneric(t)),
+					new FunctionHeader(BasicTypeID.BOOL, registry.getGeneric(t, null)),
 					"test"));
 		}
 	}
 				} else {
 					TypeParameter typeParameter = new TypeParameter(CodePosition.BUILTIN, getTypeParameter(typeParameters.size()));
 					typeParameters.add(typeParameter);
-					parameters.add(new FunctionParameter(registry.getGeneric(typeParameter), Character.toString((char)('a' + parameters.size()))));
+					parameters.add(new FunctionParameter(registry.getGeneric(typeParameter, null), Character.toString((char)('a' + parameters.size()))));
 				}
 			}
 			ITypeID returnType;
 				} else {
 					TypeParameter typeParameter = new TypeParameter(CodePosition.BUILTIN, getTypeParameter(typeParameters.size()));
 					typeParameters.add(typeParameter);
-					returnType = registry.getGeneric(typeParameter);
+					returnType = registry.getGeneric(typeParameter, null);
 				}
 			}
 			function = new JavaSynthesizedFunction(
 				range = new JavaSynthesizedRange(cls, TypeParameter.NONE, type.baseType);
 			} else {
 				TypeParameter typeParameter = new TypeParameter(CodePosition.BUILTIN, "T");
-				range = new JavaSynthesizedRange(cls, new TypeParameter[] { typeParameter }, registry.getGeneric(typeParameter));
+				range = new JavaSynthesizedRange(cls, new TypeParameter[] { typeParameter }, registry.getGeneric(typeParameter, null));
 			}
 			ranges.put(id, range);
 			getTypeGenerator().synthesizeRange(range);

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

 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
 import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.codemodel.type.TypeVisitor;
 
 /**
  * @author Hoofdgebruiker
  */
 public class JavaSyntheticTypeSignatureConverter implements TypeVisitor<String> {
-	private static final String[] typeParameterNames = {"T", "U", "V", "W", "X", "Y", "Z"}; // if we have more than this, make it Tx with x the number
+	private static final String[] TYPE_PARAMETER_NAMES = {"T", "U", "V", "W", "X", "Y", "Z"}; // if we have more than this, make it Tx with x the number
 	private final Map<TypeParameter, String> typeParameters = new HashMap<>();
 	public final List<TypeParameter> typeParameterList = new ArrayList<>();
 	
 			case FLOAT: return "Float";
 			case DOUBLE: return "Double";
 			case CHAR: return "Char";
-			case STRING: return "String";
 			default:
 				throw new IllegalArgumentException("Invalid type: " + basic);
 		}
 	}
+	
+	@Override
+	public String visitString(StringTypeID string) {
+		return "String";
+	}
 
 	@Override
 	public String visitArray(ArrayTypeID array) {
 	public String visitDefinition(DefinitionTypeID definition) {
 		StringBuilder result = new StringBuilder();
 		result.append(definition.definition.name);
-		if (definition.typeParameters.length > 0) {
+		if (definition.typeArguments.length > 0) {
 			result.append("With");
-			for (int i = 0; i < definition.typeParameters.length; i++) {
-				result.append(definition.typeParameters[i].accept(this));
+			for (int i = 0; i < definition.typeArguments.length; i++) {
+				result.append(definition.typeArguments[i].accept(this));
 			}
 		}
 		return result.toString();
 		if (typeParameters.containsKey(generic.parameter))
 			return typeParameters.get(generic.parameter);
 		
-		String name = typeParameters.size() < typeParameterNames.length ? typeParameterNames[typeParameters.size()] : "T" + typeParameters.size();
+		String name = typeParameters.size() < TYPE_PARAMETER_NAMES.length ? TYPE_PARAMETER_NAMES[typeParameters.size()] : "T" + typeParameters.size();
 		typeParameters.put(generic.parameter, name);
 		typeParameterList.add(generic.parameter);
 		return name;

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

 				case USIZE: return "I"; // special case: optional usize fits in an int where null = -1
 				case FLOAT: return "Ljava/lang/Float;";
 				case DOUBLE: return "Ljava/lang/Double;";
-				case STRING: return "Ljava/lang/String;";
 				default:
 					throw new IllegalArgumentException("Not a valid type: " + basic);
 			}
 				case USIZE: return "I";
 				case FLOAT: return "F";
 				case DOUBLE: return "D";
-				case STRING: return "Ljava/lang/String;";
 				default:
 					throw new IllegalArgumentException("Not a valid type: " + basic);
 			}
 		}
     }
+	
+	@Override
+	public String visitString(StringTypeID string) {
+		return "Ljava/lang/String;";
+	}
 
     @Override
     public String visitArray(ArrayTypeID array) {

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

 	public String visitBasic(BasicTypeID basic) {
 		return context.getDescriptor(basic);
 	}
+	
+	@Override
+	public String visitString(StringTypeID string) {
+		return context.getDescriptor(string);
+	}
 
 	@Override
 	public String visitArray(ArrayTypeID array) {
 	public String visitDefinition(DefinitionTypeID definition) {
 		StringBuilder builder = new StringBuilder("L").append(definition.definition.name);
 
-		if (definition.typeParameters.length > 0) {
+		if (definition.typeArguments.length > 0) {
 			builder.append("<");
-			for (ITypeID typeParameter : definition.typeParameters) {
+			for (ITypeID typeParameter : definition.typeArguments) {
 				builder.append(typeParameter.accept(this));
 			}
 			builder.append(">");

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

 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
 import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.codemodel.type.TypeVisitor;
 
 /**
 
 		@Override
 		public JavaTypeInfo visitBasic(BasicTypeID basic) {
-			switch (basic) {
-				case STRING:
-				case NULL:
-					return OBJECT;
-				default:
-					return PRIMITIVE;
-			}
+			return basic == BasicTypeID.NULL ? OBJECT : PRIMITIVE;
+		}
+		
+		@Override
+		public JavaTypeInfo visitString(StringTypeID string) {
+			return OBJECT;
 		}
 
 		@Override

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

 				case USIZE: return "java/lang/Integer";
 				case FLOAT: return "java/lang/Float";
 				case DOUBLE: return "java/lang/Double";
-				case STRING: return "java/lang/String";
 				default:
 					throw new IllegalArgumentException("Not a valid type: " + basic);
 			}
 				case USIZE: return "I";
 				case FLOAT: return "F";
 				case DOUBLE: return "D";
-				case STRING: return "java/lang/String";
 				default:
 					throw new IllegalArgumentException("Not a valid type: " + basic);
 			}
 		}
     }
+	
+	@Override
+	public String visitString(StringTypeID string) {
+		return "java/lang/String";
+	}
 
     @Override
     public String visitArray(ArrayTypeID array) {

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

 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.codemodel.type.TypeVisitor;
 
 /**
 			case ULONG: return "ULong";
 			case FLOAT: return "Float";
 			case DOUBLE: return "Double";
-			case STRING: return "String";
 			case CHAR: return "Char";
 			default: throw new IllegalArgumentException("Invalid type: " + basic);
 		}
 	}
+	
+	@Override
+	public String visitString(StringTypeID string) {
+		return "String";
+	}
 
 	@Override
 	public String visitArray(ArrayTypeID array) {

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

 import org.openzen.zenscript.codemodel.expression.SetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
+import org.openzen.zenscript.codemodel.expression.StorageCastExpression;
 import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
 import org.openzen.zenscript.codemodel.expression.ThrowExpression;
 	public Boolean visitStaticSetter(StaticSetterExpression expression) {
 		return true;
 	}
+	
+	@Override
+	public Boolean visitStorageCast(StorageCastExpression expression) {
+		return false;
+	}
 
 	@Override
 	public Boolean visitSupertypeCast(SupertypeCastExpression expression) {

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

 		GlobalTypeRegistry typeRegistry = module.compilationUnit.globalTypeRegistry;
 		DefinitionTypeID thisType = typeRegistry.getForMyDefinition(definition);
 		
-		CompileScope scope = new CompileScope(module.compilationUnit.globalTypeRegistry, module.expansions, module.annotations);
+		CompileScope scope = new CompileScope(module.compilationUnit.globalTypeRegistry, module.expansions, module.annotations, module.storageTypes);
 		return new JavaSourceFileScope(file.importer, compiler.helperGenerator, cls, scope, definition instanceof InterfaceDefinition, thisType, compiler.context);
 	}
 
 		if (definition.hasTag(JavaNativeClass.class)) {
 			ITypeID[] typeParameters = new ITypeID[definition.getNumberOfGenericParameters()];
 			for (int i = 0; i < typeParameters.length; i++)
-				typeParameters[i] = scope.semanticScope.getTypeRegistry().getGeneric(definition.typeParameters[i]);
-			ITypeID targetType = scope.semanticScope.getTypeRegistry().getForDefinition(definition, typeParameters);
+				typeParameters[i] = scope.semanticScope.getTypeRegistry().getGeneric(definition.typeParameters[i], null);
+			ITypeID targetType = scope.semanticScope.getTypeRegistry().getForDefinition(definition, null, typeParameters);
 			
 			JavaExpansionMemberCompiler memberCompiler = new JavaExpansionMemberCompiler(settings, targetType, definition.typeParameters, indent + settings.indent, output, scope, definition);
 			for (IDefinitionMember member : definition.members)

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

 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
 import org.openzen.zenscript.javashared.JavaMethod;
 
 
 	@Override
 	public Void visitCustomIterator(IteratorMember member) {
-		compileMethod(member, new FunctionHeader(scope.semanticScope.getTypeRegistry().getIterator(member.getLoopVariableTypes())), member.body);
+		compileMethod(member, new FunctionHeader(scope.semanticScope.getTypeRegistry().getIterator(member.getLoopVariableTypes(), UniqueStorageTag.INSTANCE)), member.body);
 		return null;
 	}
 

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

 import org.openzen.zenscript.codemodel.statement.EmptyStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
 import org.openzen.zenscript.javashared.JavaClass;
 
 	@Override
 	public Void visitCustomIterator(IteratorMember member) {
-		compileMethod(member, new FunctionHeader(scope.semanticScope.getTypeRegistry().getIterator(member.getLoopVariableTypes())), member.body);
+		compileMethod(member, new FunctionHeader(scope.semanticScope.getTypeRegistry().getIterator(member.getLoopVariableTypes(), UniqueStorageTag.INSTANCE)), member.body);
 		return null;
 	}
 

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

 import org.openzen.zenscript.codemodel.expression.SetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
+import org.openzen.zenscript.codemodel.expression.StorageCastExpression;
 import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
 import org.openzen.zenscript.codemodel.expression.ThrowExpression;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+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.formattershared.ExpressionString;
 import org.openzen.zenscript.formattershared.StatementFormattingTarget;
 import org.openzen.zenscript.javasource.scope.JavaSourceStatementScope;
 				JavaOperator.ASSIGN);
 	}
 	
+	@Override
+	public ExpressionString visitStorageCast(StorageCastExpression expression) {
+		ExpressionString value = expression.accept(this);
+		if (expression.value.type.isDestructible()) {
+			StorageTag fromTag = expression.value.type.getStorage();
+			StorageTag toTag = expression.type.getStorage();
+			if (fromTag == SharedStorageTag.INSTANCE && toTag == BorrowStorageTag.INVOCATION) {
+				// Shared<T>.get()
+				return value.unaryPostfix(JavaOperator.CALL, ".get()");
+			} else if (fromTag == UniqueStorageTag.INSTANCE && toTag == SharedStorageTag.INSTANCE) {
+				// new Shared<T>(value)
+				return new ExpressionString("new " + scope.type(JavaClass.SHARED) + "(" + value.value + ")", JavaOperator.NEW);
+			}
+		}
+		return value;
+	}
+	
 	@Override
 	public ExpressionString visitSupertypeCast(SupertypeCastExpression expression) {
 		return expression.value.accept(this);
 		
 		ExpressionString value = hoist(expression.value).accept(this);
 		target.writeLine("if (" + value.value + " instanceof " + errorType + ")");
-		target.writeLine(scope.settings.indent + "throw ((" + errorType + formatTypeArguments(type.typeParameters) + ")" + value.value + ").value;");
+		target.writeLine(scope.settings.indent + "throw ((" + errorType + formatTypeArguments(type.typeArguments) + ")" + value.value + ").value;");
 		
 		return value
-				.unaryPrefix(JavaOperator.CAST, "(" + okType + formatTypeArguments(type.typeParameters) + ")")
+				.unaryPrefix(JavaOperator.CAST, "(" + okType + formatTypeArguments(type.typeArguments) + ")")
 				.unaryPostfix(JavaOperator.MEMBER, ".value");
 	}
 
 		
 		ExpressionString value = hoist(expression.value).accept(this);
 		target.writeLine("if (" + value.value + " instanceof " + errorType + ")");
-		target.writeLine(scope.settings.indent + "return new " + errorType + "<>(((" + errorType + formatTypeArguments(type.typeParameters) + ")" + value.value + ").value);");
+		target.writeLine(scope.settings.indent + "return new " + errorType + "<>(((" + errorType + formatTypeArguments(type.typeArguments) + ")" + value.value + ").value);");
 		
 		return value
-				.unaryPrefix(JavaOperator.CAST, "(" + okType + formatTypeArguments(type.typeParameters) + ")")
+				.unaryPrefix(JavaOperator.CAST, "(" + okType + formatTypeArguments(type.typeArguments) + ")")
 				.unaryPostfix(JavaOperator.MEMBER, ".value");
 	}
 	

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

 			case FLOAT: return "Float";
 			case DOUBLE: return "Double";
 			case CHAR: return "Character";
-			case STRING: return "String";
 			default:
 				throw new IllegalArgumentException("Unknown basic type: " + basic);
 		}

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

 						statementOutput.append(scope.type(switchValue.option.types[i])).append(" ").append(switchValue.parameters[i]).append(" = ((").append(variantTypeName).append(".").append(switchValue.option.getName());
 						if (variant.typeParameters != null && variant.typeParameters.length > 0) {
 							statementOutput.append("<");
-							for (int j = 0; j < variantType.typeParameters.length; j++) {
+							for (int j = 0; j < variantType.typeArguments.length; j++) {
 								if (j > 0)
 									statementOutput.append(", ");
-								statementOutput.append(scope.type(variantType.typeParameters[j]));
+								statementOutput.append(scope.type(variantType.typeArguments[j]));
 							}
 							statementOutput.append(">");
 						}

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

 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaContext;
 import org.openzen.zenscript.javashared.JavaMethod;
 					throw new UnsupportedOperationException("Invalid array base type: " + basic);
 			}
 		}
+		
+		@Override
+		public ArrayKind visitString(StringTypeID string) {
+			return ArrayKind.OBJECT;
+		}
 
 		@Override
 		public ArrayKind visitArray(ArrayTypeID array) {

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

 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaSynthesizedFunctionInstance;
 import org.openzen.zenscript.codemodel.type.TypeVisitor;
 			case FLOAT: return "float";
 			case DOUBLE: return "double";
 			case CHAR: return "char";
-			case STRING: return "String";
 			default:
 				throw new IllegalArgumentException("Unknown basic type: " + basic);
 		}
 	}
+	
+	@Override
+	public String visitString(StringTypeID string) {
+		return "String";
+	}
 
 	@Override
 	public String visitArray(ArrayTypeID array) {
 			output.append(cls == null ? importer.importType(type.definition) : importer.importType(cls));
 		}
 		
-		if (!isStatic && type.typeParameters.length > 0) {
+		if (!isStatic && type.typeArguments.length > 0) {
 			output.append("<");
-			for (int i = 0; i < type.typeParameters.length; i++) {
+			for (int i = 0; i < type.typeArguments.length; i++) {
 				if (i > 0)
 					output.append(", ");
-				output.append(type.typeParameters[i].accept(objectTypeVisitor));
+				output.append(type.typeArguments[i].accept(objectTypeVisitor));
 			}
 			output.append(">");
 		}

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

 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.moduleserialization.CodePositionEncoding;
 			case TypeEncoding.TYPE_CHAR:
 				return BasicTypeID.CHAR;
 			case TypeEncoding.TYPE_STRING:
-				return BasicTypeID.STRING;
+				return new StringTypeID(storageTag);
 			case TypeEncoding.TYPE_UNDETERMINED:
 				return BasicTypeID.UNDETERMINED;
 			case TypeEncoding.TYPE_DEFINITION: {

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

 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.storage.StorageType;
 import org.openzen.zenscript.compiler.CompilationUnit;
 import org.openzen.zenscript.compiler.SemanticModule;
 
 	private final PackageDefinitions definitions = new PackageDefinitions();
 	private final List<ScriptBlock> scripts = new ArrayList<>();
 	private final AnnotationDefinition[] annotations;
+	private final StorageType[] storageTypes;
 	
 	private final List<ExpansionDefinition> expansions;
 	public final ModuleContext context;
 			DeserializingModule[] dependencies,
 			ZSPackage rootPackage,
 			ZSPackage modulePackage,
-			AnnotationDefinition[] annotations)
+			AnnotationDefinition[] annotations,
+			StorageType[] storageTypes)
 	{
 		this.name = name;
 		this.module = new Module(name);
 		this.rootPackage = rootPackage;
 		this.modulePackage = modulePackage;
 		this.annotations = annotations;
+		this.storageTypes = storageTypes;
 		
 		expansions = new ArrayList<>();
 		context = new ModuleContext(registry, module, expansions, rootPackage);
 		this.rootPackage = module.rootPackage;
 		this.modulePackage = module.modulePackage;
 		this.annotations = module.annotations;
+		this.storageTypes = module.storageTypes;
 		
 		expansions = module.expansions;
 		context = module.getContext();
 				scripts,
 				compilationUnit,
 				expansions,
-				annotations);
+				annotations,
+				storageTypes);
 	}
 	
 	public void add(HighLevelDefinition definition) {