- Fixed recursive errors in destructability test

- Fixed some more storage tag issues
- Added methods with storage tag requirements

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

 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 	private StoredType returnType;
 	public final FunctionParameter[] parameters;
 	public final StoredType thrownType;
+	public final StorageTag storage;
 	
 	public final int minParameters;
 	public final int maxParameters;
 		this.returnType = returnType;
 		this.parameters = FunctionParameter.NONE;
 		this.thrownType = null;
+		this.storage = null;
 		
 		minParameters = 0;
 		maxParameters = 0;
 		this.returnType = returnType;
 		this.parameters = new FunctionParameter[parameterTypes.length];
 		this.thrownType = null;
+		this.storage = null;
 		
 		for (int i = 0; i < parameterTypes.length; i++)
 			parameters[i] = new FunctionParameter(parameterTypes[i], null);
 		this.returnType = returnType;
 		this.parameters = parameters;
 		this.thrownType = null;
+		this.storage = null;
 		
 		minParameters = getMinParameters(parameters);
 		maxParameters = getMaxParameters(parameters);
 		this(returnType.stored, parameters);
 	}
 	
-	public FunctionHeader(TypeParameter[] typeParameters, StoredType returnType, StoredType thrownType, FunctionParameter... parameters) {
+	public FunctionHeader(TypeParameter[] typeParameters, StoredType returnType, StoredType thrownType, StorageTag storage, FunctionParameter... parameters) {
 		if (returnType == null)
 			throw new NullPointerException();
 		if (typeParameters == null)
 		this.returnType = returnType;
 		this.parameters = parameters;
 		this.thrownType = thrownType;
+		this.storage = storage;
 		
 		minParameters = getMinParameters(parameters);
 		maxParameters = getMaxParameters(parameters);
 		FunctionParameter[] normalizedParameters = new FunctionParameter[parameters.length];
 		for (int i = 0; i < normalizedParameters.length; i++)
 			normalizedParameters[i] = parameters[i].normalized(registry);
-		return new FunctionHeader(typeParameters, returnType.getNormalized(), thrownType == null ? null : thrownType.getNormalized(), normalizedParameters);
+		return new FunctionHeader(typeParameters, returnType.getNormalized(), thrownType == null ? null : thrownType.getNormalized(), storage, normalizedParameters);
 	}
 	
 	public int getNumberOfTypeParameters() {
 	}
 	
 	public FunctionHeader withReturnType(StoredType returnType) {
-		return new FunctionHeader(typeParameters, returnType, thrownType, parameters);
+		return new FunctionHeader(typeParameters, returnType, thrownType, storage, parameters);
 	}
 	
 	public FunctionHeader inferFromOverride(GlobalTypeRegistry registry, FunctionHeader overridden) {
 			}
 		}
 		
-		return new FunctionHeader(resultTypeParameters, resultReturnType, resultThrownType, resultParameters);
+		StorageTag resultStorage = this.storage;
+		if (resultStorage == null)
+			resultStorage = overridden.storage;
+		
+		return new FunctionHeader(resultTypeParameters, resultReturnType, resultThrownType, resultStorage, resultParameters);
 	}
 	
 	public boolean matchesExactly(CallArguments arguments, TypeScope scope) {
 		for (int i = 0; i < parameters.length; i++) {
 			parameters[i] = this.parameters[i].withGenericArguments(mapper);
 		}
-		return new FunctionHeader(typeParameters, returnType, thrownType == null ? null : thrownType.instance(mapper), parameters);
+		return new FunctionHeader(typeParameters, returnType, thrownType == null ? null : thrownType.instance(mapper), storage, parameters);
 	}
 	
 	public FunctionHeader fillGenericArguments(GlobalTypeRegistry registry, TypeID[] arguments, GenericMapper typeParameterMapping) {
 		for (int i = 0; i < parameters.length; i++) {
 			parameters[i] = this.parameters[i].withGenericArguments(mapper);
 		}
-		return new FunctionHeader(TypeParameter.NONE, returnType, thrownType == null ? null : thrownType.instance(mapper), parameters);
+		return new FunctionHeader(TypeParameter.NONE, returnType, thrownType == null ? null : thrownType.instance(mapper), storage, parameters);
 	}
 	
 	public FunctionHeader forTypeParameterInference() {
 		for (int i = 0; i < lambdaHeader.parameters.length; i++)
 			parameters[i] = new FunctionParameter(this.parameters[i].type, lambdaHeader.parameters[i].name);
 		
-		return new FunctionHeader(typeParameters, returnType, thrownType, parameters);
+		return new FunctionHeader(typeParameters, returnType, thrownType, storage, parameters);
 	}
 	
 	public FunctionParameter getVariadicParameter() {

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

 package org.openzen.zenscript.codemodel;
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.Taggable;
 import org.openzen.zenscript.codemodel.annotations.DefinitionAnnotation;
 	}
 	
 	public boolean isDestructible() {
+		Set<HighLevelDefinition> scanning = new HashSet<>();
+		return isDestructible(scanning);
+	}
+	
+	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
+		if (scanning.contains(this))
+			return false;
+		
+		scanning.add(this);
+		
 		boolean isDestructible = false;
 		for (IDefinitionMember member : members) {
 			if (member instanceof DestructorMember)
 				isDestructible = true;
 			if (member instanceof FieldMember) {
 				FieldMember field = (FieldMember)member;
-				if (!field.type.isDefinition(this) && field.type.isDestructible())
+				if (field.type.isDestructible(scanning))
 					isDestructible = true;
 			}
 			if ((member instanceof ImplementationMember) && ((ImplementationMember)member).type.isDestructible())
 				isDestructible = true;
 		}
+		
+		scanning.remove(this);
 		return isDestructible;
 	}
 	

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

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

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

 	private final BaseScope outer;
 	private final FunctionHeader header;
 	private final GenericMapper typeParameterMap;
+	private final StoredType thisType;
 	
 	public FunctionScope(BaseScope outer, FunctionHeader header) {
 		this.outer = outer;
 		this.header = header;
+		this.thisType = outer.getThisType() == null || header.storage == null ? outer.getThisType() : outer.getThisType().type.stored(header.storage);
+		if (header.storage != null)
+			System.out.println("Storage is " + header.storage);
 		
 		if (outer.getLocalTypeParameters() == null)
 			throw new NullPointerException();
 
 	@Override
 	public StoredType getThisType() {
-		return outer.getThisType();
+		return thisType;
 	}
 
 	@Override

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

 package org.openzen.zenscript.codemodel.type;
 
 import java.util.List;
+import java.util.Set;
 import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 /**
 		return elementType.type.isDestructible();
 	}
 	
+	@Override
+	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
+		return elementType.type.isDestructible(scanning);
+	}
+	
 	@Override
 	public ArrayTypeID instanceUnstored(GenericMapper mapper) {
 		return mapper.registry.getArray(elementType.instance(mapper), dimension);

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

 package org.openzen.zenscript.codemodel.type;
 
 import java.util.List;
+import java.util.Set;
 import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 /**
 		return keyType.isDestructible() || valueType.isDestructible();
 	}
 	
+	@Override
+	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
+		return keyType.isDestructible(scanning) || valueType.isDestructible(scanning);
+	}
+	
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
 		return keyType.hasInferenceBlockingTypeParameters(parameters) || valueType.hasInferenceBlockingTypeParameters(parameters);

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

 
 import java.util.Collections;
 import java.util.List;
+import java.util.Set;
 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.ValueStorageTag;
 
 	public boolean isDestructible() {
 		return false;
 	}
+	
+	@Override
+	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
+		return false;
+	}
 
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {

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

 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
 		return definition.isDestructible();
 	}
 	
+	@Override
+	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
+		return definition.isDestructible(scanning);
+	}
+	
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
 		if (hasTypeParameters()) {

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

 
 import java.util.Arrays;
 import java.util.List;
+import java.util.Set;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 	public boolean isDestructible() {
 		return false;
 	}
+	
+	@Override
+	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
+		return false;
+	}
 
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {

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

 
 import java.util.List;
 import java.util.Objects;
+import java.util.Set;
 import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 /**
 		return value.isDestructible();
 	}
 	
+	@Override
+	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
+		return value.isDestructible(scanning);
+	}
+	
 	@Override
 	public TypeID instanceUnstored(GenericMapper mapper) {
 		return mapper.registry.getGenericMap(value.instance(mapper), key);

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

 package org.openzen.zenscript.codemodel.type;
 
 import java.util.List;
+import java.util.Set;
 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.member.LocalMemberCache;
 
 		return false; // TODO: actually depends on the type..?
 	}
 	
+	@Override
+	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
+		return false; // TODO: actually depends on the type..?
+	}
+	
 	@Override
 	public boolean isGeneric() {
 		return true;

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

 package org.openzen.zenscript.codemodel.type;
 
 import java.util.List;
+import java.util.Set;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 /**
 	public boolean isDestructible() {
 		return false;
 	}
+	
+	@Override
+	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
+		return false;
+	}
 
 	@Override
 	public TypeID getNormalizedUnstored() {

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

 
 import java.util.Arrays;
 import java.util.List;
+import java.util.Set;
 import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 /**
 		return false;
 	}
 	
+	@Override
+	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
+		return false;
+	}
+	
 	@Override
 	public TypeID instanceUnstored(GenericMapper mapper) {
 		StoredType[] instanced = mapper.map(iteratorTypes);

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

 
 import java.util.List;
 import java.util.Objects;
+import java.util.Set;
 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;
 
 		return baseType.isDestructible();
 	}
 	
+	@Override
+	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
+		return baseType.isDestructible(scanning);
+	}
+	
 	@Override
 	public TypeID withoutOptional() {
 		return without(MODIFIER_OPTIONAL);

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

 package org.openzen.zenscript.codemodel.type;
 
 import java.util.List;
+import java.util.Set;
 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.ValueStorageTag;
 
 	
 	@Override
 	public boolean isDestructible() {
-		return false;
+		return baseType.isDestructible();
+	}
+	
+	@Override
+	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
+		return baseType.isDestructible(scanning);
 	}
 
 	@Override

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

 
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 		return type.isDestructible() && storage.isDestructible();
 	}
 	
+	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
+		return type.isDestructible(scanning) && storage.isDestructible();
+	}
+	
 	public boolean hasDefaultValue() {
 		return type.hasDefaultValue();
 	}

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

 package org.openzen.zenscript.codemodel.type;
 
 import java.util.List;
+import java.util.Set;
 import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.storage.AnyStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
 	public boolean isDestructible() {
 		return false;
 	}
+	
+	@Override
+	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
+		return false;
+	}
 
 	@Override
 	public TypeID instanceUnstored(GenericMapper mapper) {

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

 
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 	
 	boolean isDestructible();
 	
+	boolean isDestructible(Set<HighLevelDefinition> scanning);
+	
 	boolean hasDefaultValue();
 	
 	boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters);

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

 					new TypeParameter[] { mappedConstructorParameter },
 					VOID.stored,
 					null,
+					null,
 					new FunctionParameter(registry.getArray(registry.getGeneric(mappedConstructorParameter).stored(BorrowStorageTag.INVOCATION), dimension).stored(BorrowStorageTag.INVOCATION), "original"),
 					new FunctionParameter(registry.getFunction(mappedConstructorHeaderWithoutIndex).stored(BorrowStorageTag.INVOCATION), "projection"));
 			members.addConstructor(new ConstructorMember(
 					new TypeParameter[] { mappedConstructorParameter },
 					VOID.stored,
 					null,
+					null,
 					new FunctionParameter(registry.getArray(registry.getGeneric(mappedConstructorParameter).stored(BorrowStorageTag.INVOCATION), dimension).stored(BorrowStorageTag.INVOCATION), "original"),
 					new FunctionParameter(registry.getFunction(mappedConstructorHeaderWithIndex).stored(BorrowStorageTag.INVOCATION), "projection"));
 			constructor(definition, ARRAY_CONSTRUCTOR_PROJECTED_INDEXED, mappedConstructorFunctionWithIndex);
 		Map<TypeParameter, TypeID> parameterFilled = Collections.singletonMap(map.key, registry.getGeneric(functionParameter));
 		StoredType valueType = map.value.instance(new GenericMapper(registry, parameterFilled));
 		
-		FunctionHeader getOptionalHeader = new FunctionHeader(new TypeParameter[] { functionParameter }, registry.getOptional(valueType.type).stored(valueType.storage), null, new FunctionParameter[0]);
-		FunctionHeader putHeader = new FunctionHeader(new TypeParameter[] { functionParameter }, VOID.stored, null, new FunctionParameter(valueType));
-		FunctionHeader containsHeader = new FunctionHeader(new TypeParameter[] { functionParameter }, BOOL.stored, null, new FunctionParameter[0]);
+		FunctionHeader getOptionalHeader = new FunctionHeader(new TypeParameter[] { functionParameter }, registry.getOptional(valueType.type).stored(valueType.storage), null, null, new FunctionParameter[0]);
+		FunctionHeader putHeader = new FunctionHeader(new TypeParameter[] { functionParameter }, VOID.stored, null, null, new FunctionParameter(valueType));
+		FunctionHeader containsHeader = new FunctionHeader(new TypeParameter[] { functionParameter }, BOOL.stored, null, null, new FunctionParameter[0]);
 		
 		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT);
 		constructor(builtin, GENERICMAP_CONSTRUCTOR);

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

 				return castEquivalent(position, caster.member.cast(position, value, implicit), toType);
 		}
 		for (TypeMember<ImplementationMemberRef> implementation : implementations) {
-			if (implementation.member.implementsType.equals(toType))
-				return new InterfaceCastExpression(position, value, toType);
+			if (implementation.member.implementsType.equals(toType.type))
+				return castEquivalent(position, new InterfaceCastExpression(position, value, toType.type.stored(type.storage)), toType);
 		}
 		if (extendsType(toType.type))
 			return new SupertypeCastExpression(position, value, toType);

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

 
 	@Override
 	public StorageTag instance(CodePosition position, String[] arguments) {
-		if (arguments != null)
+		if (arguments.length > 0)
 			return new InvalidStorageTag(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/BorrowStorageType.java

 
 	@Override
 	public StorageTag instance(CodePosition position, String[] arguments) {
-		if (arguments != null) {
+		if (arguments.length > 0) {
 			if (arguments.length == 1 && arguments[0].equals("this"))
 				return BorrowStorageTag.THIS;
 			

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

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

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

 
 	@Override
 	public StorageTag instance(CodePosition position, String[] arguments) {
-		if (arguments != null)
+		if (arguments.length > 0)
 			return new InvalidStorageTag(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/StaticStorageType.java

 
 	@Override
 	public StorageTag instance(CodePosition position, String[] arguments) {
-		if (arguments != null)
+		if (arguments.length > 0)
 			return new InvalidStorageTag(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/UniqueStorageType.java

 
 	@Override
 	public StorageTag instance(CodePosition position, String[] arguments) {
-		if (arguments != null)
+		if (arguments.length > 0)
 			return new InvalidStorageTag(position, CompileExceptionCode.INVALID_STORAGE_TYPE_ARGUMENTS, "unique storage type doesn't take arguments");
 		
 		return UniqueStorageTag.INSTANCE;

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

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.context.LocalTypeResolutionContext;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.lexer.ZSToken;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.expression.ParsedExpression;
 import org.openzen.zenscript.parser.type.IParsedType;
+import org.openzen.zenscript.parser.type.ParsedStorageTag;
 import org.openzen.zenscript.parser.type.ParsedTypeBasic;
 
 /**
  */
 public class ParsedFunctionHeader {
 	public static ParsedFunctionHeader parse(ZSTokenParser tokens) throws ParseException {
+		CodePosition position = tokens.getPosition();
+		
+		ParsedStorageTag storage = ParsedStorageTag.parse(tokens);
+		
 		List<ParsedTypeParameter> genericParameters = null;
 		if (tokens.optional(ZSTokenType.T_LESS) != null) {
 			genericParameters = new ArrayList<>();
 			thrownType = IParsedType.parse(tokens);
 		}
 		
-		return new ParsedFunctionHeader(genericParameters, parameters, returnType, thrownType);
+		return new ParsedFunctionHeader(position, genericParameters, parameters, returnType, thrownType, storage);
 	}
 	
+	public final CodePosition position;
 	public final List<ParsedTypeParameter> genericParameters;
 	public final List<ParsedFunctionParameter> parameters;
 	public final IParsedType returnType;
 	public final IParsedType thrownType;
+	public final ParsedStorageTag storage;
 	
-	public ParsedFunctionHeader(List<ParsedFunctionParameter> parameters, IParsedType returnType, IParsedType thrownType) {
+	public ParsedFunctionHeader(CodePosition position, List<ParsedFunctionParameter> parameters, IParsedType returnType) {
+		this.position = position;
 		this.genericParameters = Collections.emptyList();
 		this.parameters = parameters;
 		this.returnType = returnType;
-		this.thrownType = thrownType;
+		this.thrownType = null;
+		this.storage = ParsedStorageTag.NULL;
 	}
 	
-	public ParsedFunctionHeader(List<ParsedTypeParameter> genericParameters, List<ParsedFunctionParameter> parameters, IParsedType returnType, IParsedType thrownType) {
+	public ParsedFunctionHeader(CodePosition position, List<ParsedTypeParameter> genericParameters, List<ParsedFunctionParameter> parameters, IParsedType returnType, IParsedType thrownType, ParsedStorageTag storage) {
+		this.position = position;
 		this.genericParameters = genericParameters;
 		this.parameters = parameters;
 		this.returnType = returnType;
 		this.thrownType = thrownType;
+		this.storage = storage;
 	}
 	
 	public FunctionHeader compile(TypeResolutionContext context) {
 		for (int i = 0; i < parameters.length; i++)
 			parameters[i] = this.parameters.get(i).compile(localContext);
 		
-		return new FunctionHeader(genericParameters, returnType, thrownType == null ? null : thrownType.compile(context), parameters);
+		StorageTag storage = this.storage.resolve(position, context);
+		return new FunctionHeader(genericParameters, returnType, thrownType == null ? null : thrownType.compile(context), storage, parameters);
 	}
 }

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

 						position,
 						parser.next().content);
 			case T_STRING_SQ:
-			case T_STRING_DQ:
+			case T_STRING_DQ: {
+				String quoted = parser.next().content;
 				return new ParsedExpressionString(
 						position,
-						StringExpansion.unescape(parser.next().content).orElse(error -> {
+						StringExpansion.unescape(quoted).orElse(error -> {
 							return "INVALID_STRING";
-						}));
+						}),
+						quoted.charAt(0) == '\'');
+			}
 			case T_IDENTIFIER: {
 				String name = parser.next().content;
 				List<IParsedType> genericParameters = IParsedType.parseTypeArguments(parser);

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

 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionParameter;
+import org.openzen.zenscript.parser.type.ParsedStorageTag;
 import org.openzen.zenscript.parser.type.ParsedTypeBasic;
 
 /**
 		for (ParsedExpression expression : expressions)
 			parameters.add(expression.toLambdaParameter());
 		
-		return new ParsedFunctionHeader(parameters, ParsedTypeBasic.UNDETERMINED, null);
+		return new ParsedFunctionHeader(position, parameters, ParsedTypeBasic.UNDETERMINED);
 	}
 
 	@Override

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

 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionParameter;
 import org.openzen.zenscript.parser.type.IParsedType;
+import org.openzen.zenscript.parser.type.ParsedStorageTag;
 import org.openzen.zenscript.parser.type.ParsedTypeBasic;
 
 /**
 		if (header.returnType != ParsedTypeBasic.UNDETERMINED)
 			throw new ParseException(position, "Lambda parameter already has a return type");
 		
-		return new ParsedFunctionHeader(header.genericParameters, header.parameters, type, null);
+		return new ParsedFunctionHeader(position, header.genericParameters, header.parameters, type, null, ParsedStorageTag.NULL);
 	}
 	
 	@Override

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

  */
 public class ParsedExpressionString extends ParsedExpression {
 	public final String value;
+	public final boolean singleQuote;
 	
-	public ParsedExpressionString(CodePosition position, String value) {
+	public ParsedExpressionString(CodePosition position, String value, boolean singleQuote) {
 		super(position);
 		
 		this.value = value;
+		this.singleQuote = singleQuote;
 	}
 
 	@Override
 	public IPartialExpression compile(ExpressionScope scope) {
-		if (value.length() == 1 && scope.hints.contains(BasicTypeID.CHAR.stored))
+		if (value.length() == 1 && (singleQuote || scope.hints.contains(BasicTypeID.CHAR.stored)))
 			return new ConstantCharExpression(position, value.charAt(0));
 		
 		return new ConstantStringExpression(position, value);

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

 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionParameter;
 import org.openzen.zenscript.parser.type.IParsedType;
+import org.openzen.zenscript.parser.type.ParsedStorageTag;
 import org.openzen.zenscript.parser.type.ParsedTypeBasic;
 
 /**
 	
 	@Override
 	public ParsedFunctionHeader toLambdaHeader() {
-		return new ParsedFunctionHeader(Collections.singletonList(toLambdaParameter()), ParsedTypeBasic.UNDETERMINED, null);
+		return new ParsedFunctionHeader(position, Collections.singletonList(toLambdaParameter()), ParsedTypeBasic.UNDETERMINED);
 	}
 	
 	@Override

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

 			return NULL;
 		
 		String name = parser.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
-		List<String> arguments = null;
-		if (parser.optional(ZSTokenType.T_BROPEN) != null) {
-			arguments = new ArrayList<>();
-			if (parser.optional(ZSTokenType.T_BRCLOSE) == null) {
-				do {
-					arguments.add(parser.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content);
-				} while (parser.optional(ZSTokenType.T_COMMA) == null);
-				parser.required(ZSTokenType.T_BRCLOSE, ") expected");
-			}
-		}
+		List<String> arguments = new ArrayList<>();
+		while (parser.optional(ZSTokenType.T_COLON) != null)
+			arguments.add(parser.next().content);
 		
 		return new ParsedStorageTag(name, arguments.toArray(new String[arguments.size()]));
 	}

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

 import org.openzen.zenscript.validator.Validator;
 import org.openzen.zenscript.validator.analysis.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.codemodel.type.storage.InvalidStorageTag;
 
 /**
  *
 		TypeValidator typeValidator = new TypeValidator(target, position);
 		typeValidator.validate(header.getReturnType());
 		
+		if (header.storage instanceof InvalidStorageTag) {
+			InvalidStorageTag invalid = (InvalidStorageTag)header.storage;
+			target.logError(INVALID_TYPE, invalid.position, invalid.message);
+		}
+		
 		Set<String> parameterNames = new HashSet<>();
 		int i = 0;
 		for (FunctionParameter parameter : header.parameters) {