Refine storage tag implementation

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

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

 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
 	
 	@Override
 	public StoredType getThisType() {
-		return type == null ? null : getTypeRegistry().getForMyDefinition(type.load()).stored(BorrowStorageTag.THIS);
+		if (type == null)
+			return null;
+		
+		TypeID self = getTypeRegistry().getForMyDefinition(type.load());
+		return self.stored(self.isValueType() ? ValueStorageTag.INSTANCE : BorrowStorageTag.THIS);
 	}
 }

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class EnumDefinition extends HighLevelDefinition {
+	public TypeID asType;
 	public List<EnumConstantMember> enumConstants = new ArrayList<>();
 	
 	public EnumDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {

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.TypeID;
-import org.openzen.zenscript.codemodel.type.storage.StaticStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
 	public final EnumConstantMember value;
 	
 	public EnumConstantExpression(CodePosition position, TypeID type, EnumConstantMember value) {
-		super(position, type.stored(StaticStorageTag.INSTANCE), null);
+		super(position, type.stored(ValueStorageTag.INSTANCE), null);
 		
 		this.value = value;
 	}
 	
 	public EnumConstantExpression(CodePosition position, GlobalTypeRegistry registry, EnumDefinition type, EnumConstantMember value) {
-		super(position, registry.getForDefinition(type).stored(StaticStorageTag.INSTANCE), null);
+		super(position, registry.getForDefinition(type).stored(ValueStorageTag.INSTANCE), null);
 		
 		this.value = value;
 	}

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.NewExpression;
 
 /**
 	public final String name;
 	public final int ordinal;
 	
-	public NewExpression constructor;
+	public Expression value = null;
+	public NewExpression constructor = null;
 	
 	public EnumConstantMember(CodePosition position, HighLevelDefinition definition, String name, int ordinal) {
 		this.position = position;

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

 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StaticExpressionStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
 		Map<TypeParameter, TypeID> typeParameters = new HashMap<>();
 		if (definition instanceof ExpansionDefinition) {
 			ExpansionDefinition expansion = (ExpansionDefinition)definition;
-			type = expansion.target.stored(BorrowStorageTag.THIS);
+			type = expansion.target.stored(expansion.target.isValueType() ? ValueStorageTag.INSTANCE : BorrowStorageTag.THIS);
 			
 			for (TypeParameter parameter : expansion.typeParameters) {
 				genericParameters.put(parameter.name, parameter);
 			}
 		} else {
 			DefinitionTypeID definitionType = outer.getTypeRegistry().getForMyDefinition(definition);
-			type = definitionType.stored(BorrowStorageTag.THIS);
+			type = definitionType.stored(definitionType.isValueType() ? ValueStorageTag.INSTANCE : BorrowStorageTag.THIS);
 			
 			while (definitionType != null) {
 				for (TypeParameter parameter : definitionType.definition.typeParameters) {

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

 		return false;
 	}
 	
+	@Override
+	public boolean isValueType() {
+		return false;
+	}
+	
 	@Override
 	public boolean isDestructible() {
 		return elementType.type.isDestructible();

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

 		return false;
 	}
 	
+	@Override
+	public boolean isValueType() {
+		return false;
+	}
+	
 	@Override
 	public boolean isDestructible() {
 		return keyType.isDestructible() || valueType.isDestructible();

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

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

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
+import org.openzen.zenscript.codemodel.definition.StructDefinition;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 	public boolean isConst() {
 		return false;
 	}
+	
+	@Override
+	public boolean isValueType() {
+		return definition instanceof StructDefinition || definition instanceof EnumDefinition;
+	}
 
 	@Override
 	public boolean isEnum() {

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

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

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

 		return false;
 	}
 	
+	@Override
+	public boolean isValueType() {
+		return false;
+	}
+	
 	@Override
 	public boolean isDestructible() {
 		return value.isDestructible();

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

 		return false;
 	}
 	
+	@Override
+	public boolean isValueType() {
+		return false;
+	}
+	
 	@Override
 	public boolean isDestructible() {
 		return false; // TODO: actually depends on the type..?

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

 		return false;
 	}
 	
+	@Override
+	public boolean isValueType() {
+		return false;
+	}
+	
 	@Override
 	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
 		return false;

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

 		return false;
 	}
 	
+	@Override
+	public boolean isValueType() {
+		return false;
+	}
+	
 	@Override
 	public TypeID instanceUnstored(GenericMapper mapper) {
 		StoredType[] instanced = mapper.map(iteratorTypes);

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

 		return (modifiers & MODIFIER_CONST) > 0;
 	}
 	
+	@Override
+	public boolean isValueType() {
+		return baseType.isValueType();
+	}
+	
 	@Override
 	public boolean isDestructible() {
 		return baseType.isDestructible();

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

 		return false;
 	}
 	
+	@Override
+	public boolean isValueType() {
+		return baseType.type.isValueType();
+	}
+	
 	@Override
 	public boolean isDestructible() {
 		return baseType.isDestructible();

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.storage.StaticExpressionStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
 	public final StorageTag storage;
 	
 	public StoredType(TypeID type, StorageTag storage) {
+		if (type.isValueType() && storage != ValueStorageTag.INSTANCE && storage != StaticExpressionStorageTag.INSTANCE)
+			throw new IllegalArgumentException("storage of a value type must be value");
+		if (!type.isValueType() && storage == ValueStorageTag.INSTANCE)
+			throw new IllegalArgumentException("storage of a nonvalue type cannot be value");
+		
 		this.type = type;
 		this.storage = storage;
 	}
 	
 	public StoredType instance(GenericMapper mapper) {
 		TypeID result = mapper.map(type);
-		return result == type ? this : new StoredType(result, storage);
+		return result == type ? this : new StoredType(result, result.isValueType() ? ValueStorageTag.INSTANCE : storage);
 	}
 	
 	public boolean isDestructible() {

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

 	public boolean isDestructible(Set<HighLevelDefinition> scanning) {
 		return false;
 	}
+	
+	@Override
+	public boolean isValueType() {
+		return false;
+	}
 
 	@Override
 	public TypeID instanceUnstored(GenericMapper mapper) {

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

 		return false;
 	}
 	
+	boolean isValueType();
+	
 	default TypeID withoutOptional() {
 		throw new UnsupportedOperationException("Not an optional type");
 	}

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

 			for (int i = 0; i < constValues.length; i++)
 				constValues[i] = new EnumConstantExpression(BUILTIN, definitionType, enumConstants.get(i));
 			
-			constant(definition, ENUM_VALUES, "values", new ArrayExpression(BUILTIN, constValues, registry.getArray(definitionType.stored(StaticStorageTag.INSTANCE), 1).stored(StaticStorageTag.INSTANCE)));
+			constant(definition, ENUM_VALUES, "values", new ArrayExpression(BUILTIN, constValues, registry.getArray(definitionType.stored(ValueStorageTag.INSTANCE), 1).stored(StaticStorageTag.INSTANCE)));
 			compare(definition, ENUM_COMPARE, type);
 			
 			if (!members.canCast(StringTypeID.STATIC)) {

DrawableGui/src/main/java/org/openzen/drawablegui/scroll/DScrollPane.java

 	
 	@Override
 	public void unmount() {
+		context = null;
+		
 		subSurface.close();
 		style.border.close();
 		

IDE/src/main/java/org/openzen/zenscript/ide/Arguments.java

  */
 public class Arguments {
 	public final File projectDirectory;
+	public final String defaultTarget;
 	
-	public Arguments(String[] arguments, File defaultProjectDir) {
-		File projectDir = defaultProjectDir;
+	public Arguments(String[] arguments) {
+		File projectDir = null;
+		String defaultTarget = null;
+		
 		int positional = 0;
 		for (int i = 0; i < arguments.length; i++) {
 			switch (positional) {
 				case 0:
 					projectDir = new File(arguments[0]);
 					break;
+				case 1:
+					defaultTarget = arguments[1];
+					break;
 				default:
 					throw new IllegalArgumentException("Too many arguments");
 			}
 			projectDir = projectDir.getParentFile();
 		
 		this.projectDirectory = projectDir;
+		this.defaultTarget = defaultTarget;
 	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/JavaBytecodeMain.java

  */
 package org.openzen.zenscript.ide;
 
-import java.io.File;
 import java.io.IOException;
-import org.openzen.zenscript.constructor.Project;
-import static org.openzen.zenscript.ide.Main.open;
-import org.openzen.zenscript.ide.host.DevelopmentHost;
-import org.openzen.zenscript.ide.host.local.LocalProjectDevelopmentHost;
 
 /**
  *
      * @param args the command line arguments
      */
     public static void main(String[] args) throws IOException {
-		Arguments arguments = new Arguments(args, new File("../../ZenCode")); // TODO: remove this and open a project chooser/creator instead
-		File directory = arguments.projectDirectory;
-		
-		Project project = new Project(directory);
-		DevelopmentHost host = new LocalProjectDevelopmentHost(project);
-		open(host, "SharedJavaBytecode");
+		Main.main("../../ZenCode", "SharedJavaBytecode");
     }
 }

IDE/src/main/java/org/openzen/zenscript/ide/Main.java

     /**
      * @param args the command line arguments
      */
-    public static void main(String[] args) throws IOException {
-		Arguments arguments = new Arguments(args, new File("../../ZenCode")); // TODO: remove this and open a project chooser/creator instead
+    public static void main(String... args) throws IOException {
+		if (args.length == 0) {
+			// testing environment - TODO project chooser/creator
+			args = new String[] { "../../ZenCode", "SharedJavaSource" };
+		}
+		
+		Arguments arguments = new Arguments(args);
 		File directory = arguments.projectDirectory;
 		
 		Project project = new Project(directory);
 		DevelopmentHost host = new LocalProjectDevelopmentHost(project);
-		open(host, "SharedJavaSource");
+		open(host, arguments.defaultTarget);
     }
 	
 	public static void open(DevelopmentHost host, String target) {
 		IDEPropertyStore properties = host.getPropertyStore();
 		
+		IDEPropertyDirectory runState = properties.getRoot().getSubdirectory("runState");
+		if (target == null)
+			target = runState.getString("target", null);
+		if (target == null && host.getTargets().size() > 0)
+			target = host.getTargets().get(0).getName();
+		
 		IDEWindow window = new IDEWindow(host, target);
 		WindowView root = new WindowView(window, host);
 		

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

 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
+import org.openzen.zenscript.parser.type.IParsedType;
 
 /**
  *
 public class ParsedEnum extends BaseParsedDefinition {
 	public static ParsedEnum parseEnum(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) throws ParseException {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
+		IParsedType asType = null;
+		if (tokens.optional(ZSTokenType.K_AS) != null)
+			asType = IParsedType.parse(tokens);
+		
 		tokens.required(ZSTokenType.T_AOPEN, "{ expected");
 		
-		ParsedEnum result = new ParsedEnum(pkg, position, modifiers, annotations, name, outerDefinition);
+		ParsedEnum result = new ParsedEnum(pkg, position, modifiers, annotations, name, outerDefinition, asType);
 		
 		while (!tokens.isNext(ZSTokenType.T_ACLOSE) && !tokens.isNext(ZSTokenType.T_SEMICOLON)) {
 			result.addEnumValue(ParsedEnumConstant.parse(tokens, result.compiled, result.enumValues.size()));
 	
 	private final List<ParsedEnumConstant> enumValues = new ArrayList<>();
 	
+	private final IParsedType asType;
 	private final EnumDefinition compiled;
 	
-	public ParsedEnum(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, HighLevelDefinition outerDefinition) {
+	public ParsedEnum(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, HighLevelDefinition outerDefinition, IParsedType asType) {
 		super(position, modifiers, pkg, annotations);
 		
+		this.asType = asType;
 		compiled = new EnumDefinition(position, pkg.module, pkg.getPackage(), name, modifiers, outerDefinition);
 	}
 	
 	
 	@Override
 	protected void linkTypesLocal(TypeResolutionContext context) {
+		if (asType != null)
+			compiled.asType = asType.compileUnstored(context);
+		
 		for (ParsedEnumConstant constant : enumValues) {
 			compiled.addEnumConstant(constant.getCompiled());
 		}

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

 import java.util.ArrayList;
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.expression.NewExpression;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
-import org.openzen.zenscript.codemodel.type.storage.StaticStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.expression.ParsedCallArguments;
 import org.openzen.zenscript.parser.expression.ParsedExpression;
 			}
 		}
 		
-		return new ParsedEnumConstant(position, definition, name.content, value, arguments);
+		ParsedExpression valueExpression = null;
+		if (tokens.optional(ZSTokenType.T_ASSIGN) != null)
+			valueExpression = ParsedExpression.parse(tokens);
+		
+		return new ParsedEnumConstant(position, definition, name.content, value, arguments, valueExpression);
 	}
 	
 	public final CodePosition position;
 	public final String name;
 	public final List<ParsedExpression> arguments;
+	public final ParsedExpression value;
 	
 	private final EnumConstantMember compiled;
 	
-	public ParsedEnumConstant(CodePosition position, HighLevelDefinition definition, String name, int value, List<ParsedExpression> arguments) {
+	public ParsedEnumConstant(CodePosition position, HighLevelDefinition definition, String name, int value, List<ParsedExpression> arguments, ParsedExpression expressionValue) {
 		this.position = position;
 		this.name = name;
 		this.arguments = arguments;
+		this.value = expressionValue;
 		
 		compiled = new EnumConstantMember(position, definition, name, value);
 	}
 		return compiled;
 	}
 	
-	public void compileCode(DefinitionTypeID type, ExpressionScope scope) {
+	public void compileCode(DefinitionTypeID type, ExpressionScope scope) throws CompileException {
 		ParsedCallArguments arguments = new ParsedCallArguments(null, this.arguments);
-		compiled.constructor = (NewExpression)ParsedNewExpression.compile(position, type.stored(StaticStorageTag.INSTANCE), arguments, scope);
+		compiled.constructor = (NewExpression)ParsedNewExpression.compile(position, type.stored(ValueStorageTag.INSTANCE), arguments, scope);
+		
+		if (value != null)
+			compiled.value = value.compile(scope).eval();
 	}
 }

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

 		for (int i = 0; i < parameters.length; i++)
 			parameters[i] = this.parameters.get(i).compile(localContext);
 		
-		StorageTag storage = this.storage.resolve(position, context);
+		StorageTag storage = this.storage == ParsedStorageTag.NULL ? null : 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/ParsedExpressionMember.java

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.parser.type.IParsedType;
 
 /**
 				scope,
 				scope.hints,
 				new GenericName(this.member, typeParameters));
-		if (member == null)
+		if (member == null) {
+			TypeMembers members = scope.getTypeMembers(cValue.eval().type);
 			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Member not found: " + this.member);
+		}
 		
 		return member;
 	}

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

 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
 			if (cSource.type.type instanceof DefinitionTypeID) {
 				DefinitionTypeID sourceType = (DefinitionTypeID)cSource.type.type;
 				if (sourceType.definition == result) {
-					return new TryRethrowAsResultExpression(position, sourceType.typeArguments[0].stored(cSource.type.storage), cSource);
+					return new TryRethrowAsResultExpression(position, sourceType.typeArguments[0].stored(sourceType.typeArguments[0].isValueType() ? ValueStorageTag.INSTANCE : cSource.type.storage), cSource);
 				}
 			}
 			

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

 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.codemodel.type.storage.SharedStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageType;
 
 /**
  *
 		for (ParsedNamePart namePart : name)
 			genericNames.add(namePart.compile(context));
 		
-		StorageTag storage = this.storage.resolve(position, context);
 		TypeID baseType = context.getType(position, genericNames);
 		if (baseType == null)
-			return new InvalidTypeID(position, CompileExceptionCode.NO_SUCH_TYPE, "Type not found: " + toString()).stored(storage);
+			return new InvalidTypeID(position, CompileExceptionCode.NO_SUCH_TYPE, "Type not found: " + toString()).stored(ValueStorageTag.INSTANCE);
 		
 		TypeID result = context.getTypeRegistry().getModified(modifiers, baseType);
 		if (result == null)
-			return new InvalidTypeID(position, CompileExceptionCode.NO_SUCH_TYPE, "Type not found: " + toString()).stored(storage);
+			return new InvalidTypeID(position, CompileExceptionCode.NO_SUCH_TYPE, "Type not found: " + toString()).stored(ValueStorageTag.INSTANCE);
 		
+		StorageTag storage;
+		if (this.storage == ParsedStorageTag.NULL) {
+			storage = result.isValueType() ? ValueStorageTag.INSTANCE : SharedStorageTag.INSTANCE;
+		} else {
+			storage = this.storage.resolve(position, context);
+		}
 		return result.stored(storage);
 	}
 	

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

 				result.append(tokens.getLastWhitespace());
 			}
 			
-			return new ParsedExpressionString(position.until(tokens.getPosition()), result.toString());
+			return new ParsedExpressionString(position.until(tokens.getPosition()), result.toString(), false);
 		}
 	}
 }

Validator/src/main/java/org/openzen/zenscript/validator/TypeContext.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.validator;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public enum TypeContext {
+	PARAMETER_TYPE("parameter type"),
+	RETURN_TYPE("return type"),
+	FIELD_TYPE("field type"),
+	GETTER_TYPE("getter type"),
+	SETTER_TYPE("setter type"),
+	CASTER_TYPE("caster type"),
+	ITERATOR_TYPE("iterator type"),
+	EXPANSION_TARGET_TYPE("expansion target type"),
+	OPTION_MEMBER_TYPE("option member type"),
+	CAST_TARGET_TYPE("cast target type"),
+	TYPE_CHECK_TYPE("type check type");
+	
+	public final String display;
+	
+	TypeContext(String display) {
+		this.display = display;
+	}
+}

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

 import org.openzen.zenscript.validator.analysis.ExpressionScope;
 import org.openzen.zenscript.validator.analysis.StatementScope;
 import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.validator.TypeContext;
 
 /**
  *
 					"Duplicate field name: " + member.name);
 		}
 		fieldNames.add(member.name);
-		new TypeValidator(validator, member.position).validate(member.type);
+		new TypeValidator(validator, member.position).validate(TypeContext.FIELD_TYPE, member.type);
 		
 		if (member.initializer != null) {
 			member.initializer.accept(new ExpressionValidator(validator, new FieldInitializerScope(member)));
 	@Override
 	public Void visitGetter(GetterMember member) {
 		ValidationUtils.validateIdentifier(validator, member.position, member.name);
-		new TypeValidator(validator, member.position).validate(member.type);
+		new TypeValidator(validator, member.position).validate(TypeContext.GETTER_TYPE, member.type);
 		validateGetter(member, new MethodStatementScope(new FunctionHeader(member.type)));
 		return null;
 	}
 	@Override
 	public Void visitSetter(SetterMember member) {
 		ValidationUtils.validateIdentifier(validator, member.position, member.name);
-		new TypeValidator(validator, member.position).validate(member.type);
+		new TypeValidator(validator, member.position).validate(TypeContext.SETTER_TYPE, member.type);
 		validateSetter(member, new MethodStatementScope(new FunctionHeader(BasicTypeID.VOID, member.parameter)));
 		return null;
 	}
 
 	@Override
 	public Void visitCaster(CasterMember member) {
-		new TypeValidator(validator, member.position).validate(member.toType);
+		new TypeValidator(validator, member.position).validate(TypeContext.CASTER_TYPE, member.toType);
 		validateFunctional(member, new MethodStatementScope(member.header));
 		return null;
 	}
 	public Void visitCustomIterator(IteratorMember member) {
 		TypeValidator typeValidator = new TypeValidator(validator, member.position);
 		for (StoredType type : member.getLoopVariableTypes())
-			typeValidator.validate(type);
+			typeValidator.validate(TypeContext.ITERATOR_TYPE, type);
 		
 		validateFunctional(member, new MethodStatementScope(new FunctionHeader(scope.getTypeRegistry().getIterator(member.getLoopVariableTypes()).stored(UniqueStorageTag.INSTANCE))));
 		return null;

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

 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
+import org.openzen.zenscript.validator.TypeContext;
 import org.openzen.zenscript.validator.Validator;
 import org.openzen.zenscript.validator.analysis.StatementScope;
 
 				definition.position,
 				"Invalid expansion modifier");
 		
-		definition.target.accept(new TypeValidator(validator, definition.position));
+		new TypeValidator(validator, definition.position).validate(TypeContext.EXPANSION_TARGET_TYPE, definition.target);
 		validateMembers(definition, DefinitionMemberContext.EXPANSION);
 		return null;
 	}
 		ValidationUtils.validateIdentifier(validator, option.position, option.name);
 		TypeValidator typeValidator = new TypeValidator(validator, option.position);
 		for (StoredType type : option.types)
-			typeValidator.validate(type);
+			typeValidator.validate(TypeContext.OPTION_MEMBER_TYPE, type);
 	}
 	
 	private class SimpleTypeScope implements TypeScope {

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

 import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
+import org.openzen.zenscript.validator.TypeContext;
 import org.openzen.zenscript.validator.ValidationLogEntry;
 import org.openzen.zenscript.validator.Validator;
 import org.openzen.zenscript.validator.analysis.ExpressionScope;
 	@Override
 	public Void visitInterfaceCast(InterfaceCastExpression expression) {
 		expression.value.accept(this);
-		new TypeValidator(validator, expression.position).validate(expression.type);
+		new TypeValidator(validator, expression.position).validate(TypeContext.CAST_TARGET_TYPE, expression.type);
 		return null;
 	}
 	
 	@Override
 	public Void visitIs(IsExpression expression) {
 		expression.value.accept(this);
-		expression.isType.accept(new TypeValidator(validator, expression.position));
+		new TypeValidator(validator, expression.position).validate(TypeContext.TYPE_CHECK_TYPE, expression.isType);
 		return null;
 	}
 

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

 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.validator.ValidationLogEntry;
 import org.openzen.zenscript.validator.Validator;
-import org.openzen.zenscript.codemodel.type.TypeVisitor;
+import org.openzen.zenscript.codemodel.type.TypeVisitorWithContext;
 import org.openzen.zenscript.codemodel.type.storage.InvalidStorageTag;
+import org.openzen.zenscript.validator.TypeContext;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class TypeValidator implements TypeVisitor<Void> {
+public class TypeValidator implements TypeVisitorWithContext<TypeContext, Void, RuntimeException> {
 	private final Validator validator;
 	private final CodePosition position;
 	
 		this.position = position;
 	}
 	
-	public void validate(StoredType type) {
+	public void validate(TypeContext context, StoredType type) {
 		if (type.storage instanceof InvalidStorageTag) {
 			InvalidStorageTag storage = (InvalidStorageTag)type.storage;
 			validator.logError(ValidationLogEntry.Code.INVALID_TYPE, storage.position, storage.message);
 		}
 		
-		validate(type.type);
+		validate(context, type.type);
 	}
 	
-	public void validate(TypeID type) {
-		type.accept(this);
+	public void validate(TypeContext context, TypeID type) {
+		type.accept(context, this);
 	}
 
 	@Override
-	public Void visitBasic(BasicTypeID basic) {
+	public Void visitBasic(TypeContext context, BasicTypeID basic) {
 		if (basic == BasicTypeID.UNDETERMINED)
-			validator.logError(ValidationLogEntry.Code.INVALID_TYPE, position, "type could not be determined");
+			validator.logError(ValidationLogEntry.Code.INVALID_TYPE, position, context.display + " could not be determined");
 		
 		return null;
 	}
 	
 	@Override
-	public Void visitString(StringTypeID string) {
+	public Void visitString(TypeContext context, StringTypeID string) {
 		return null;
 	}
 
 	@Override
-	public Void visitArray(ArrayTypeID array) {
+	public Void visitArray(TypeContext context, ArrayTypeID array) {
 		if (array.dimension < 1) {
 			validator.logError(ValidationLogEntry.Code.INVALID_TYPE, position, "array dimension must be at least 1");
 		} else if (array.dimension > 16) {
 			validator.logError(ValidationLogEntry.Code.INVALID_TYPE, position, "array dimension must be at most 16");
 		}
 		
-		validate(array.elementType);
+		validate(context, array.elementType);
 		return null;
 	}
 
 	@Override
-	public Void visitAssoc(AssocTypeID assoc) {
-		validate(assoc.keyType);
-		validate(assoc.valueType);
+	public Void visitAssoc(TypeContext context, AssocTypeID assoc) {
+		validate(context, assoc.keyType);
+		validate(context, assoc.valueType);
 		
 		// TODO: does the keytype have == and hashcode operators?
 		return null;
 	}
 	
 	@Override
-	public Void visitInvalid(InvalidTypeID type) {
+	public Void visitInvalid(TypeContext context, InvalidTypeID type) {
 		validator.logError(ValidationLogEntry.Code.INVALID_TYPE, type.position, type.message);
 		return null;
 	}
 
 	@Override
-	public Void visitIterator(IteratorTypeID iterator) {
+	public Void visitIterator(TypeContext context, IteratorTypeID iterator) {
 		for (StoredType type : iterator.iteratorTypes)
-			validate(type);
+			validate(context, type);
 		
 		return null;
 	}
 
 	@Override
-	public Void visitFunction(FunctionTypeID function) {
+	public Void visitFunction(TypeContext context, FunctionTypeID function) {
 		ValidationUtils.validateHeader(validator, position, function.header);
 		return null;
 	}
 
 	@Override
-	public Void visitDefinition(DefinitionTypeID definition) {
+	public Void visitDefinition(TypeContext context, DefinitionTypeID definition) {
 		ValidationUtils.validateTypeArguments(validator, position, definition.definition.typeParameters, definition.typeArguments);
 		return null;
 	}
 
 	@Override
-	public Void visitGeneric(GenericTypeID generic) {
+	public Void visitGeneric(TypeContext context, GenericTypeID generic) {
 		return null;
 	}
 
 	@Override
-	public Void visitRange(RangeTypeID range) {
-		validate(range.baseType);
+	public Void visitRange(TypeContext context, RangeTypeID range) {
+		validate(context, range.baseType);
 		return null;
 	}
 
 	@Override
-	public Void visitModified(ModifiedTypeID type) {
+	public Void visitModified(TypeContext context, ModifiedTypeID type) {
 		// TODO: detect duplicate const
-		validate(type.baseType);
+		validate(context, type.baseType);
 		return null;
 	}
 
 	@Override
-	public Void visitGenericMap(GenericMapTypeID map) {
-		validate(map.value);
+	public Void visitGenericMap(TypeContext context, GenericMapTypeID map) {
+		validate(context, map.value);
 		return null;
 	}
 }

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

 import org.openzen.zenscript.validator.analysis.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.storage.InvalidStorageTag;
+import org.openzen.zenscript.validator.TypeContext;
 
 /**
  *
 	
 	public static void validateHeader(Validator target, CodePosition position, FunctionHeader header) {
 		TypeValidator typeValidator = new TypeValidator(target, position);
-		typeValidator.validate(header.getReturnType());
+		typeValidator.validate(TypeContext.RETURN_TYPE, header.getReturnType());
 		
 		if (header.storage instanceof InvalidStorageTag) {
 			InvalidStorageTag invalid = (InvalidStorageTag)header.storage;
 			}
 			
 			parameterNames.add(parameter.name);
-			typeValidator.validate(parameter.type);
+			typeValidator.validate(TypeContext.PARAMETER_TYPE, parameter.type);
 			
 			if (parameter.defaultValue != null) {
 				parameter.defaultValue.accept(new ExpressionValidator(target, new DefaultParameterValueExpressionScope()));