WIP on memory tags

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

 import org.openzen.zenscript.codemodel.serialization.CodeSerializationInput;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
 
 /**
  *
 	public static final NativeAnnotationDefinition INSTANCE = new NativeAnnotationDefinition();
 	
 	private static final List<FunctionHeader> INITIALIZERS = Collections.singletonList(
-			new FunctionHeader(BasicTypeID.VOID, BasicTypeID.STRING));
+			new FunctionHeader(BasicTypeID.VOID, StringTypeID.UNIQUE));
 	
 	private NativeAnnotationDefinition() {}
 

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

 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
 
 /**
  *
 				BasicTypeID.VOID,
 				scope.getType(CodePosition.BUILTIN, enforcementLevelName),
 				BasicTypeID.BOOL,
-				BasicTypeID.STRING));
+				StringTypeID.UNIQUE));
 	}
 
 	@Override

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
 
 /**
  *
 	public final String value;
 	
 	public ConstantStringExpression(CodePosition position, String value) {
-		super(position, BasicTypeID.STRING, null);
+		super(position, StringTypeID.STATIC, null);
 		
 		this.value = value;
 	}

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

 	FLOAT("float"),
 	DOUBLE("double"),
 	CHAR("char"),
-	STRING("string"),
 	
 	UNDETERMINED("undetermined");
 	
 	
 	@Override
 	public boolean isObjectType() {
-		return this == STRING;
+		return false;
 	}
 
 	@Override

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

 		public Boolean visitBasic(BasicTypeID basic) {
 			return basic == type;
 		}
+		
+		@Override
+		public Boolean visitString(StringTypeID string) {
+			return string == type || (type instanceof StringTypeID && ((StringTypeID)type).storage == null);
+		}
 
 		@Override
 		public Boolean visitArray(ArrayTypeID array) {

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.type;
+
+import java.util.List;
+import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.AnyStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.SharedStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.StaticStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
+import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class StringTypeID implements ITypeID {
+	public static final StringTypeID ANY = new StringTypeID(AnyStorageTag.INSTANCE);
+	public static final StringTypeID STATIC = new StringTypeID(StaticStorageTag.INSTANCE);
+	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 final StorageTag storage;
+	
+	public StringTypeID(StorageTag storage) {
+		this.storage = storage;
+	}
+
+	@Override
+	public ITypeID getUnmodified() {
+		return this;
+	}
+
+	@Override
+	public ITypeID getNormalized() {
+		return this;
+	}
+
+	@Override
+	public <T> T accept(TypeVisitor<T> visitor) {
+		return visitor.visitString(this);
+	}
+
+	@Override
+	public <C, R> R accept(C context, TypeVisitorWithContext<C, R> visitor) {
+		return visitor.visitString(context, this);
+	}
+
+	@Override
+	public boolean hasDefaultValue() {
+		return true;
+	}
+
+	@Override
+	public boolean isObjectType() {
+		return true;
+	}
+
+	@Override
+	public ITypeID instance(GenericMapper mapper) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public void extractTypeParameters(List<TypeParameter> typeParameters) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+}

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

 	public Void visitBasic(BasicTypeID basic) {
 		return null;
 	}
+	
+	@Override
+	public Void visitString(StringTypeID string) {
+		return null;
+	}
 
 	@Override
 	public Void visitArray(ArrayTypeID array) {

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

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

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

 public interface TypeVisitorWithContext<C, R> {
 	R visitBasic(C context, BasicTypeID basic);
 	
+	R visitString(C context, StringTypeID string);
+	
 	R visitArray(C context, ArrayTypeID array);
 	
 	R visitAssoc(C context, AssocTypeID assoc);

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

 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.expression.ConstantUSizeExpression;
 import org.openzen.zenscript.codemodel.member.IteratorMember;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.codemodel.type.TypeVisitor;
 
 /**
 			case CHAR:
 				visitChar();
 				break;
-			case STRING:
-				visitString();
-				break;
 		}
 		
 		return null;
 	}
+	
+	@Override
+	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));
+		
+		add(builtin, STRING_ADD_STRING, StringTypeID.BORROW, StringTypeID.UNIQUE);
+		indexGet(builtin, STRING_INDEXGET, USIZE, CHAR);
+		indexGet(builtin, STRING_RANGEGET, RangeTypeID.USIZE, StringTypeID.UNIQUE);
+		compare(builtin, STRING_COMPARE, StringTypeID.BORROW);
+		
+		getter(builtin, STRING_LENGTH, "length", USIZE);
+		getter(builtin, STRING_CHARACTERS, "characters", registry.getArray(CHAR, 1));
+		getter(builtin, STRING_ISEMPTY, "isEmpty", BOOL);
+
+		method(builtin, STRING_REMOVE_DIACRITICS, "removeDiacritics", StringTypeID.BORROW);
+		method(builtin, STRING_TRIM, "trim", StringTypeID.BORROW, StringTypeID.UNIQUE);
+		method(builtin, STRING_TO_LOWER_CASE, "toLowerCase", StringTypeID.UNIQUE);
+		method(builtin, STRING_TO_UPPER_CASE, "toUpperCase", StringTypeID.UNIQUE);
+		
+		iterator(builtin, ITERATOR_STRING_CHARS, CHAR);
+		
+		processType(builtin, string);
+		return null;
+	}
 
 	@Override
 	public Void visitArray(ArrayTypeID array) {
 		}
 		
 		if (definition instanceof EnumDefinition) {
-			getter(definition, ENUM_NAME, "name", STRING);
+			getter(definition, ENUM_NAME, "name", StringTypeID.STATIC);
 			getter(definition, ENUM_ORDINAL, "ordinal", USIZE);
 			
 			List<EnumConstantMember> enumConstants = ((EnumDefinition) definition).enumConstants;
 			constant(definition, ENUM_VALUES, "values", new ArrayExpression(BUILTIN, constValues, registry.getArray(type, 1)));
 			compare(definition, ENUM_COMPARE, type);
 			
-			if (!members.canCast(BasicTypeID.STRING)) {
-				castImplicit(definition, ENUM_TO_STRING, STRING);
+			if (!members.canCast(StringTypeID.STATIC)) {
+				castImplicit(definition, ENUM_TO_STRING, StringTypeID.STATIC);
 			}
 		}
 		
 		equals(builtin, BOOL_EQUALS, BOOL);
 		notequals(builtin, BOOL_NOTEQUALS, BOOL);
 		
-		castExplicit(builtin, BOOL_TO_STRING, STRING);
-		staticMethod(builtin, BOOL_PARSE, "parse", BOOL, STRING);
+		castExplicit(builtin, BOOL_TO_STRING, StringTypeID.STATIC);
+		staticMethod(builtin, BOOL_PARSE, "parse", BOOL, StringTypeID.BORROW);
 		
 		processType(builtin, BOOL);
 	}
 		castImplicit(builtin, BYTE_TO_FLOAT, FLOAT);
 		castImplicit(builtin, BYTE_TO_DOUBLE, DOUBLE);
 		castExplicit(builtin, BYTE_TO_CHAR, CHAR);
-		castImplicit(builtin, BYTE_TO_STRING, STRING);
+		castImplicit(builtin, BYTE_TO_STRING, StringTypeID.UNIQUE);
 		
-		staticMethod(builtin, BYTE_PARSE, "parse", BYTE, STRING);
-		staticMethod(builtin, BYTE_PARSE_WITH_BASE, "parse", BYTE, STRING, INT);
+		staticMethod(builtin, BYTE_PARSE, "parse", BYTE, StringTypeID.BORROW);
+		staticMethod(builtin, BYTE_PARSE_WITH_BASE, "parse", BYTE, StringTypeID.BORROW, INT);
 		
 		constant(builtin, BYTE_GET_MIN_VALUE, "MIN_VALUE", new ConstantByteExpression(BUILTIN, 0));
 		constant(builtin, BYTE_GET_MAX_VALUE, "MAX_VALUE", new ConstantByteExpression(BUILTIN, 255));
 		castImplicit(builtin, SBYTE_TO_FLOAT, FLOAT);
 		castImplicit(builtin, SBYTE_TO_DOUBLE, DOUBLE);
 		castExplicit(builtin, SBYTE_TO_CHAR, CHAR);
-		castImplicit(builtin, SBYTE_TO_STRING, STRING);
+		castImplicit(builtin, SBYTE_TO_STRING, StringTypeID.UNIQUE);
 		
-		staticMethod(builtin, SBYTE_PARSE, "parse", SBYTE, STRING);
-		staticMethod(builtin, SBYTE_PARSE_WITH_BASE, "parse", SBYTE, STRING, INT);
+		staticMethod(builtin, SBYTE_PARSE, "parse", SBYTE, StringTypeID.BORROW);
+		staticMethod(builtin, SBYTE_PARSE_WITH_BASE, "parse", SBYTE, StringTypeID.BORROW, INT);
 		
 		constant(builtin, SBYTE_GET_MIN_VALUE, "MIN_VALUE", new ConstantSByteExpression(BUILTIN, Byte.MIN_VALUE));
 		constant(builtin, SBYTE_GET_MAX_VALUE, "MAX_VALUE", new ConstantSByteExpression(BUILTIN, Byte.MAX_VALUE));
 		castImplicit(builtin, SHORT_TO_FLOAT, FLOAT);
 		castImplicit(builtin, SHORT_TO_DOUBLE, DOUBLE);
 		castExplicit(builtin, SHORT_TO_CHAR, CHAR);
-		castImplicit(builtin, SHORT_TO_STRING, STRING);
+		castImplicit(builtin, SHORT_TO_STRING, StringTypeID.UNIQUE);
 		
-		staticMethod(builtin, SHORT_PARSE, "parse", SHORT, STRING);
-		staticMethod(builtin, SHORT_PARSE_WITH_BASE, "parse", SHORT, STRING, INT);
+		staticMethod(builtin, SHORT_PARSE, "parse", SHORT, StringTypeID.BORROW);
+		staticMethod(builtin, SHORT_PARSE_WITH_BASE, "parse", SHORT, StringTypeID.BORROW, INT);
 		
 		constant(builtin, SHORT_GET_MIN_VALUE, "MIN_VALUE", new ConstantShortExpression(BUILTIN, Short.MIN_VALUE));
 		constant(builtin, SHORT_GET_MAX_VALUE, "MAX_VALUE", new ConstantShortExpression(BUILTIN, Short.MAX_VALUE));
 		castImplicit(builtin, USHORT_TO_FLOAT, FLOAT);
 		castImplicit(builtin, USHORT_TO_DOUBLE, DOUBLE);
 		castExplicit(builtin, USHORT_TO_CHAR, CHAR);
-		castImplicit(builtin, USHORT_TO_STRING, STRING);
+		castImplicit(builtin, USHORT_TO_STRING, StringTypeID.UNIQUE);
 		
-		staticMethod(builtin, USHORT_PARSE, "parse", USHORT, STRING);
-		staticMethod(builtin, USHORT_PARSE_WITH_BASE, "parse", USHORT, STRING, INT);
+		staticMethod(builtin, USHORT_PARSE, "parse", USHORT, StringTypeID.BORROW);
+		staticMethod(builtin, USHORT_PARSE_WITH_BASE, "parse", USHORT, StringTypeID.BORROW, INT);
 		
 		constant(builtin, USHORT_GET_MIN_VALUE, "MIN_VALUE", new ConstantUShortExpression(BUILTIN, 0));
 		constant(builtin, USHORT_GET_MAX_VALUE, "MAX_VALUE", new ConstantUShortExpression(BUILTIN, 65535));
 		castImplicit(builtin, INT_TO_FLOAT, FLOAT);
 		castImplicit(builtin, INT_TO_DOUBLE, DOUBLE);
 		castExplicit(builtin, INT_TO_CHAR, CHAR);
-		castImplicit(builtin, INT_TO_STRING, STRING);
+		castImplicit(builtin, INT_TO_STRING, StringTypeID.UNIQUE);
 		
-		staticMethod(builtin, INT_PARSE, "parse", INT, STRING);
-		staticMethod(builtin, INT_PARSE_WITH_BASE, "parse", INT, STRING, INT);
+		staticMethod(builtin, INT_PARSE, "parse", INT, StringTypeID.BORROW);
+		staticMethod(builtin, INT_PARSE_WITH_BASE, "parse", INT, StringTypeID.BORROW, INT);
 		
 		method(builtin, INT_COUNT_LOW_ZEROES, "countLowZeroes", INT);
 		method(builtin, INT_COUNT_HIGH_ZEROES, "countHighZeroes", INT);
 		castImplicit(builtin, UINT_TO_FLOAT, FLOAT);
 		castImplicit(builtin, UINT_TO_DOUBLE, DOUBLE);
 		castExplicit(builtin, UINT_TO_CHAR, CHAR);
-		castImplicit(builtin, UINT_TO_STRING, STRING);
+		castImplicit(builtin, UINT_TO_STRING, StringTypeID.UNIQUE);
 		
-		staticMethod(builtin, UINT_PARSE, "parse", UINT, STRING);
-		staticMethod(builtin, UINT_PARSE_WITH_BASE, "parse", UINT, STRING, INT);
+		staticMethod(builtin, UINT_PARSE, "parse", UINT, StringTypeID.BORROW);
+		staticMethod(builtin, UINT_PARSE_WITH_BASE, "parse", UINT, StringTypeID.BORROW, INT);
 		
 		method(builtin, UINT_COUNT_LOW_ZEROES, "countLowZeroes", UINT);
 		method(builtin, UINT_COUNT_HIGH_ZEROES, "countHighZeroes", UINT);
 		castImplicit(builtin, LONG_TO_FLOAT, FLOAT);
 		castImplicit(builtin, LONG_TO_DOUBLE, DOUBLE);
 		castExplicit(builtin, LONG_TO_CHAR, CHAR);
-		castImplicit(builtin, LONG_TO_STRING, STRING);
+		castImplicit(builtin, LONG_TO_STRING, StringTypeID.UNIQUE);
 		
-		staticMethod(builtin, LONG_PARSE, "parse", LONG, STRING);
-		staticMethod(builtin, LONG_PARSE_WITH_BASE, "parse", LONG, STRING, INT);
+		staticMethod(builtin, LONG_PARSE, "parse", LONG, StringTypeID.BORROW);
+		staticMethod(builtin, LONG_PARSE_WITH_BASE, "parse", LONG, StringTypeID.BORROW, INT);
 		
 		method(builtin, LONG_COUNT_LOW_ZEROES, "countLowZeroes", INT);
 		method(builtin, LONG_COUNT_HIGH_ZEROES, "countHighZeroes", INT);
 		castImplicit(builtin, ULONG_TO_FLOAT, FLOAT);
 		castImplicit(builtin, ULONG_TO_DOUBLE, DOUBLE);
 		castExplicit(builtin, ULONG_TO_CHAR, CHAR);
-		castImplicit(builtin, ULONG_TO_STRING, STRING);
+		castImplicit(builtin, ULONG_TO_STRING, StringTypeID.UNIQUE);
 		
-		staticMethod(builtin, ULONG_PARSE, "parse", ULONG, STRING);
-		staticMethod(builtin, ULONG_PARSE_WITH_BASE, "parse", ULONG, STRING, INT);
+		staticMethod(builtin, ULONG_PARSE, "parse", ULONG, StringTypeID.BORROW);
+		staticMethod(builtin, ULONG_PARSE_WITH_BASE, "parse", ULONG, StringTypeID.BORROW, INT);
 		
 		method(builtin, ULONG_COUNT_LOW_ZEROES, "countLowZeroes", INT);
 		method(builtin, ULONG_COUNT_HIGH_ZEROES, "countHighZeroes", INT);
 		castImplicit(builtin, USIZE_TO_FLOAT, FLOAT);
 		castImplicit(builtin, USIZE_TO_DOUBLE, DOUBLE);
 		castExplicit(builtin, USIZE_TO_CHAR, CHAR);
-		castImplicit(builtin, USIZE_TO_STRING, STRING);
+		castImplicit(builtin, USIZE_TO_STRING, StringTypeID.UNIQUE);
 		
-		staticMethod(builtin, USIZE_PARSE, "parse", USIZE, STRING);
-		staticMethod(builtin, USIZE_PARSE_WITH_BASE, "parse", USIZE, STRING, INT);
+		staticMethod(builtin, USIZE_PARSE, "parse", USIZE, StringTypeID.BORROW);
+		staticMethod(builtin, USIZE_PARSE_WITH_BASE, "parse", USIZE, StringTypeID.BORROW, INT);
 		
 		method(builtin, USIZE_COUNT_LOW_ZEROES, "countLowZeroes", INT);
 		method(builtin, USIZE_COUNT_HIGH_ZEROES, "countHighZeroes", INT);
 		castExplicit(builtin, FLOAT_TO_ULONG, ULONG);
 		castExplicit(builtin, FLOAT_TO_USIZE, USIZE);
 		castImplicit(builtin, FLOAT_TO_DOUBLE, DOUBLE);
-		castImplicit(builtin, FLOAT_TO_STRING, STRING);
+		castImplicit(builtin, FLOAT_TO_STRING, StringTypeID.UNIQUE);
 		
-		staticMethod(builtin, FLOAT_PARSE, "parse", FLOAT, STRING);
+		staticMethod(builtin, FLOAT_PARSE, "parse", FLOAT, StringTypeID.BORROW);
 		staticMethod(builtin, FLOAT_FROM_BITS, "fromBits", FLOAT, UINT);
 		
 		getter(builtin, FLOAT_BITS, "bits", UINT);
 		castExplicit(builtin, DOUBLE_TO_ULONG, ULONG);
 		castExplicit(builtin, DOUBLE_TO_USIZE, USIZE);
 		castImplicit(builtin, DOUBLE_TO_FLOAT, FLOAT);
-		castImplicit(builtin, DOUBLE_TO_STRING, STRING);
+		castImplicit(builtin, DOUBLE_TO_STRING, StringTypeID.UNIQUE);
 		
-		staticMethod(builtin, DOUBLE_PARSE, "parse", DOUBLE, STRING);
+		staticMethod(builtin, DOUBLE_PARSE, "parse", DOUBLE, StringTypeID.BORROW);
 		staticMethod(builtin, DOUBLE_FROM_BITS, "fromBits", DOUBLE, ULONG);
 		
 		getter(builtin, DOUBLE_BITS, "bits", ULONG);
 		castImplicit(builtin, CHAR_TO_LONG, LONG);
 		castImplicit(builtin, CHAR_TO_ULONG, ULONG);
 		castImplicit(builtin, CHAR_TO_USIZE, USIZE);
-		castImplicit(builtin, CHAR_TO_STRING, STRING);
+		castImplicit(builtin, CHAR_TO_STRING, StringTypeID.UNIQUE);
 		
 		getter(builtin, CHAR_GET_MIN_VALUE, "MIN_VALUE", CHAR);
 		getter(builtin, CHAR_GET_MAX_VALUE, "MAX_VALUE", CHAR);
 		
 		processType(builtin, CHAR);
 	}
-
-	private void visitString() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "string", Modifiers.EXPORT, null);
-		
-		constructor(builtin, STRING_CONSTRUCTOR_CHARACTERS, registry.getArray(CHAR, 1));
-		
-		add(builtin, STRING_ADD_STRING, STRING, STRING);
-		indexGet(builtin, STRING_INDEXGET, USIZE, CHAR);
-		indexGet(builtin, STRING_RANGEGET, RangeTypeID.USIZE, STRING);
-		compare(builtin, STRING_COMPARE, STRING);
-		
-		getter(builtin, STRING_LENGTH, "length", USIZE);
-		getter(builtin, STRING_CHARACTERS, "characters", registry.getArray(CHAR, 1));
-		getter(builtin, STRING_ISEMPTY, "isEmpty", BOOL);
-
-		method(builtin, STRING_REMOVE_DIACRITICS, "removeDiacritics", STRING);
-		method(builtin, STRING_TRIM, "trim", STRING, STRING);
-		method(builtin, STRING_TO_LOWER_CASE, "toLowerCase", STRING);
-		method(builtin, STRING_TO_UPPER_CASE, "toUpperCase", STRING);
-		
-		iterator(builtin, ITERATOR_STRING_CHARS, CHAR);
-		
-		processType(builtin, STRING);
-	}
 	
 	private void castedTargetCall(OperatorMember member, ITypeID toType, BuiltinID casterBuiltin) {
 		CasterMemberRef caster = castImplicitRef(member.definition, casterBuiltin, toType);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/AnyStorageTag.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 AnyStorageTag implements StorageTag {
+	public static final AnyStorageTag INSTANCE = new AnyStorageTag();
+	
+	private AnyStorageTag() {}
+
+	@Override
+	public StorageType getType() {
+		return AnyStorageType.INSTANCE;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/AnyStorageType.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 AnyStorageType implements StorageType {
+	public static final AnyStorageType INSTANCE = new AnyStorageType();
+	
+	private AnyStorageType() {}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/BorrowStorageTag.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 BorrowStorageTag implements StorageTag {
+	public static final BorrowStorageTag INVOCATION = new BorrowStorageTag();
+	
+	private BorrowStorageTag() {} // TODO: scoped borrow
+
+	@Override
+	public StorageType getType() {
+		return BorrowStorageType.INSTANCE;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/BorrowStorageType.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 BorrowStorageType implements StorageType {
+	public static final BorrowStorageType INSTANCE = new BorrowStorageType();
+
+	private BorrowStorageType() {}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/SharedStorageTag.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 SharedStorageTag implements StorageTag {
+	public static final SharedStorageTag INSTANCE = new SharedStorageTag();
+	
+	private SharedStorageTag() {}
+
+	@Override
+	public StorageType getType() {
+		return SharedStorageType.INSTANCE;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/SharedStorageType.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 SharedStorageType implements StorageType {
+	public static final SharedStorageType INSTANCE = new SharedStorageType();
+	
+	private SharedStorageType() {}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/StaticStorageTag.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 StaticStorageTag implements StorageTag {
+	public static final StaticStorageTag INSTANCE = new StaticStorageTag();
+	
+	private StaticStorageTag() {}
+
+	@Override
+	public StorageType getType() {
+		return StaticStorageType.INSTANCE;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/StaticStorageType.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 StaticStorageType implements StorageType {
+	public static final StaticStorageType INSTANCE = new StaticStorageType();
+	
+	private StaticStorageType() {}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/StorageTag.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 interface StorageTag {
+	StorageType getType();
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/StorageType.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 interface StorageType {
+	
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/UniqueStorageTag.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 UniqueStorageTag implements StorageTag {
+	public static final UniqueStorageTag INSTANCE = new UniqueStorageTag() {};
+			
+	private UniqueStorageTag() {}
+
+	@Override
+	public StorageType getType() {
+		return UniqueStorageType.INSTANCE;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/UniqueStorageType.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 UniqueStorageType implements StorageType {
+	public static final UniqueStorageType INSTANCE = new UniqueStorageType();
+	
+	private UniqueStorageType() {}
+}

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

 	T_NOTEQUAL("!=", "!="),
 	T_NOT("!", "!"),
 	T_DOLLAR("$", "$"),
+	T_BACKTICK("`", "`"),
 	
 	K_IMPORT(true, "import"),
 	K_ALIAS(true, "alias"),

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

 				tokens.next();
 				result = ParsedTypeBasic.CHAR;
 				break;
-			case K_STRING:
+			case K_STRING: {
 				tokens.next();
-				result = ParsedTypeBasic.STRING;
+				ParsedStorageTag storage = ParsedStorageTag.parse(tokens);
+				result = new ParsedString(modifiers, storage);
 				break;
+			}
 			case K_FUNCTION: {
 				tokens.next();
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
-				result = new ParsedFunctionType(position, header);
+				ParsedStorageTag storage = ParsedStorageTag.parse(tokens);
+				result = new ParsedFunctionType(position, header, storage);
 				break;
 			}
 			case T_IDENTIFIER: {
 					List<IParsedType> generic = parseGenericParameters(tokens);
 					name.add(new ParsedNamedType.ParsedNamePart(namePart, generic));
 				} while (tokens.optional(ZSTokenType.T_DOT) != null);
-				
-				result = new ParsedNamedType(position, name);
+				ParsedStorageTag storage = ParsedStorageTag.parse(tokens);
+				result = new ParsedNamedType(position, name, storage);
 				break;
 			}
 			default:
 						dimension++;
 					
 					if (tokens.optional(ZSTokenType.T_SQCLOSE) != null) {
-						result = new ParsedTypeArray(result, dimension);
+						ParsedStorageTag storage = ParsedStorageTag.parse(tokens);
+						result = new ParsedTypeArray(result, dimension, storage);
 					} else if (tokens.isNext(T_LESS)) {
 						tokens.next();
 						ParsedTypeParameter parameter = ParsedTypeParameter.parse(tokens);
 						tokens.required(T_GREATER, "> expected");
-						result = new ParsedTypeGenericMap(parameter, result, modifiers);
 						tokens.required(ZSTokenType.T_SQCLOSE, "] expected");
+						ParsedStorageTag storage = ParsedStorageTag.parse(tokens);
+						result = new ParsedTypeGenericMap(parameter, result, modifiers, storage);
 					} else {
 						IParsedType keyType = parse(tokens);
-						result = new ParsedTypeAssociative(keyType, result);
 						tokens.required(ZSTokenType.T_SQCLOSE, "] expected");
+						ParsedStorageTag storage = ParsedStorageTag.parse(tokens);
+						result = new ParsedTypeAssociative(keyType, result, storage);
 					}
 					break;
 				case T_QUEST:

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

 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
-import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 
 /**
 	private final CodePosition position;
 	private final int modifiers;
 	private final ParsedFunctionHeader header;
+	private final ParsedStorageTag storageTag;
 	
-	public ParsedFunctionType(CodePosition position, ParsedFunctionHeader header) {
+	public ParsedFunctionType(CodePosition position, ParsedFunctionHeader header, ParsedStorageTag storageTag) {
 		this.position = position;
 		this.header = header;
 		this.modifiers = 0;
+		this.storageTag = storageTag;
 	}
 	
-	private ParsedFunctionType(CodePosition position, ParsedFunctionHeader header, int modifiers) {
+	private ParsedFunctionType(CodePosition position, ParsedFunctionHeader header, int modifiers, ParsedStorageTag storageTag) {
 		this.position = position;
 		this.header = header;
 		this.modifiers = modifiers;
+		this.storageTag = storageTag;
 	}
 	
 	@Override
 	public IParsedType withOptional() {
-		return new ParsedFunctionType(position, header, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL);
+		return new ParsedFunctionType(position, header, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL, storageTag);
 	}
 
 	@Override
 	public IParsedType withModifiers(int modifiers) {
-		return new ParsedFunctionType(position, header, modifiers | this.modifiers);
+		return new ParsedFunctionType(position, header, modifiers | this.modifiers, storageTag);
 	}
 
 	@Override

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

 	private final CodePosition position;
 	private final int modifiers;
 	public final List<ParsedNamePart> name;
+	private final ParsedStorageTag storage;
 	
-	public ParsedNamedType(CodePosition position, List<ParsedNamePart> name) {
+	public ParsedNamedType(CodePosition position, List<ParsedNamePart> name, ParsedStorageTag storage) {
 		this.position = position;
 		this.modifiers = 0;
 		this.name = name;
+		this.storage = storage;
 	}
 	
-	private ParsedNamedType(CodePosition position, int modifiers, List<ParsedNamePart> name) {
+	private ParsedNamedType(CodePosition position, int modifiers, List<ParsedNamePart> name, ParsedStorageTag storage) {
 		this.position = position;
 		this.modifiers = modifiers;
 		this.name = name;
+		this.storage = storage;
 	}
 	
 	@Override
 	
 	@Override
 	public IParsedType withOptional() {
-		return new ParsedNamedType(position, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL, name);
+		return new ParsedNamedType(position, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL, name, storage);
 	}
 	
 	@Override
 	public IParsedType withModifiers(int modifiers) {
-		return new ParsedNamedType(position, this.modifiers | modifiers, name);
+		return new ParsedNamedType(position, this.modifiers | modifiers, name, storage);
 	}
 	
 	@Override

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.parser.type;
+
+import org.openzen.zenscript.lexer.ZSTokenParser;
+import org.openzen.zenscript.lexer.ZSTokenType;
+import org.openzen.zenscript.parser.expression.ParsedCallArguments;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ParsedStorageTag {
+	public static ParsedStorageTag parse(ZSTokenParser parser) {
+		if (parser.optional(ZSTokenType.T_BACKTICK) == null)
+			return null;
+		
+		String name = parser.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
+		ParsedCallArguments arguments = null;
+		if (parser.peek().type == ZSTokenType.T_BROPEN)
+			arguments = ParsedCallArguments.parse(parser);
+		
+		return new ParsedStorageTag(name, arguments);
+	}
+	
+	public String name;
+	public ParsedCallArguments arguments;
+	
+	public ParsedStorageTag(String name, ParsedCallArguments arguments) {
+		this.name = name;
+		this.arguments = arguments;
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.parser.type;
+
+import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ParsedString implements IParsedType {
+	private final int modifiers;
+	private final ParsedStorageTag storageTag;
+	
+	public ParsedString(int modifiers, ParsedStorageTag storageTag) {
+		this.modifiers = modifiers;
+		this.storageTag = storageTag;
+	}
+
+	@Override
+	public IParsedType withOptional() {
+		return new ParsedString(modifiers | ModifiedTypeID.MODIFIER_OPTIONAL, storageTag);
+	}
+
+	@Override
+	public IParsedType withModifiers(int modifiers) {
+		return new ParsedString(this.modifiers | modifiers, storageTag);
+	}
+
+	@Override
+	public ITypeID compile(TypeResolutionContext context) {
+		return StringTypeID.UNIQUE; // TODO
+	}
+}

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedTypeArray.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.member.TypeMembers;
 
 /**
  *
 	public final IParsedType baseType;
 	public final int dimension;
 	public final int modifiers;
+	public final ParsedStorageTag storageTag;
 	
-	public ParsedTypeArray(IParsedType baseType, int dimension) {
+	public ParsedTypeArray(IParsedType baseType, int dimension, ParsedStorageTag storageTag) {
 		this.baseType = baseType;
 		this.dimension = dimension;
 		this.modifiers = 0;
+		this.storageTag = storageTag;
 	}
 
-	private ParsedTypeArray(IParsedType baseType, int dimension, int modifiers) {
+	private ParsedTypeArray(IParsedType baseType, int dimension, int modifiers, ParsedStorageTag storageTag) {
 		this.baseType = baseType;
 		this.dimension = dimension;
 		this.modifiers = modifiers;
+		this.storageTag = storageTag;
 	}
 	
 	@Override
 	public IParsedType withOptional() {
-		return new ParsedTypeArray(baseType, dimension, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL);
+		return new ParsedTypeArray(baseType, dimension, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL, storageTag);
 	}
 
 	@Override
 	public IParsedType withModifiers(int modifiers) {
-		return new ParsedTypeArray(baseType, dimension, this.modifiers | modifiers);
+		return new ParsedTypeArray(baseType, dimension, this.modifiers | modifiers, storageTag);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 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.scope.BaseScope;
 import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
 
 /**
 	public final IParsedType key;
 	public final IParsedType value;
 	public final int modifiers;
+	private final ParsedStorageTag storage;
 	
-	public ParsedTypeAssociative(IParsedType key, IParsedType value) {
+	public ParsedTypeAssociative(IParsedType key, IParsedType value, ParsedStorageTag storage) {
 		this.key = key;
 		this.value = value;
 		this.modifiers = 0;
+		this.storage = storage;
 	}
 
-	private ParsedTypeAssociative(IParsedType key, IParsedType value, int modifiers) {
+	private ParsedTypeAssociative(IParsedType key, IParsedType value, int modifiers, ParsedStorageTag storage) {
 		this.key = key;
 		this.value = value;
 		this.modifiers = modifiers;
+		this.storage = storage;
 	}
 	
 	@Override
 	public IParsedType withOptional() {
-		return new ParsedTypeAssociative(key, value, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL);
+		return new ParsedTypeAssociative(key, value, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL, storage);
 	}
 
 	@Override
 	public IParsedType withModifiers(int modifiers) {
-		return new ParsedTypeAssociative(key, value, this.modifiers | modifiers);
+		return new ParsedTypeAssociative(key, value, this.modifiers | modifiers, storage);
 	}
 
 	@Override

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

 	FLOAT(BasicTypeID.FLOAT),
 	DOUBLE(BasicTypeID.DOUBLE),
 	CHAR(BasicTypeID.CHAR),
-	STRING(BasicTypeID.STRING),
 	
 	UNDETERMINED(BasicTypeID.UNDETERMINED);
 	

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedTypeGenericMap.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.member.TypeMembers;
 import org.openzen.zenscript.parser.definitions.ParsedTypeParameter;
 
 /**
 	private final ParsedTypeParameter key;
 	private final IParsedType value;
 	private final int modifiers;
+	private final ParsedStorageTag storage;
 	
-	public ParsedTypeGenericMap(ParsedTypeParameter key, IParsedType value, int modifiers) {
+	public ParsedTypeGenericMap(ParsedTypeParameter key, IParsedType value, int modifiers, ParsedStorageTag storage) {
 		this.key = key;
 		this.value = value;
 		this.modifiers = modifiers;
+		this.storage = storage;
 	}
 
 	@Override
 	public IParsedType withOptional() {
-		return new ParsedTypeGenericMap(key, value, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL);
+		return new ParsedTypeGenericMap(key, value, modifiers | ModifiedTypeID.MODIFIER_OPTIONAL, storage);
 	}
 
 	@Override
 	public IParsedType withModifiers(int modifiers) {
-		return new ParsedTypeGenericMap(key, value, modifiers | this.modifiers);
+		return new ParsedTypeGenericMap(key, value, modifiers | this.modifiers, storage);
 	}
 
 	@Override