- Made important modifications to error reporting so it provides meaningful info

- Fix various normalization bugs
- Fixed bugs with the new stored type system

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

  */
 package org.openzen.zenscript.codemodel;
 
+import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zencode.shared.ConcatMap;
 import org.openzen.zencode.shared.Taggable;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 
 /**
 		result.addAllTagsFrom(this);
 		return result;
 	}
+	
+	public ScriptBlock normalize(TypeScope scope) {
+		List<Statement> result = new ArrayList<>();
+		for (Statement statement : statements) {
+			result.add(statement.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class)));
+		}
+		return new ScriptBlock(pkg, result);
+	}
 }

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

 import java.util.Arrays;
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.context.StatementContext;
 import org.openzen.zenscript.codemodel.context.TypeContext;
 import org.openzen.zenscript.codemodel.expression.Expression;
 		if (body == null)
 			return body;
 		
-		ExpressionScope expressionScope = new ExpressionScope(scope, BasicTypeID.BOOL.stored);
-		List<Statement> statements = new ArrayList<>();
-		ExpressionBuilder expressionBuilder = new ExpressionBuilder(position, expressionScope);
-		Expression inverseCondition = expressionBuilder.not(condition);
-		Statement throwStatement = new ExpressionStatement(position, new PanicExpression(position, BasicTypeID.VOID.stored, message));
-		statements.add(new IfStatement(position, inverseCondition, throwStatement, null));
-		
-		if (body instanceof BlockStatement) {
-			statements.addAll(Arrays.asList(((BlockStatement)body).statements));
-		} else {
-			statements.add(body);
+		try {
+			ExpressionScope expressionScope = new ExpressionScope(scope, BasicTypeID.BOOL.stored);
+			List<Statement> statements = new ArrayList<>();
+			ExpressionBuilder expressionBuilder = new ExpressionBuilder(position, expressionScope);
+			Expression inverseCondition = expressionBuilder.not(condition);
+			Statement throwStatement = new ExpressionStatement(position, new PanicExpression(position, BasicTypeID.VOID.stored, message));
+			statements.add(new IfStatement(position, inverseCondition, throwStatement, null));
+
+			if (body instanceof BlockStatement) {
+				statements.addAll(Arrays.asList(((BlockStatement)body).statements));
+			} else {
+				statements.add(body);
+			}
+			return new BlockStatement(position, statements.toArray(new Statement[statements.size()]));
+		} catch (CompileException ex) {
+			// TODO
+			ex.printStackTrace();
+			return body;
 		}
-		return new BlockStatement(position, statements.toArray(new Statement[statements.size()]));
 	}
 
 	@Override

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

  */
 public class FunctionDefinition extends HighLevelDefinition {
 	public FunctionHeader header;
-	public Statement statement;
 	public CallerMember caller;
 	public final TypeMemberGroup callerGroup;
 	
 	}
 	
 	public void setCode(Statement statement) {
-		this.statement = statement;
 		caller.setBody(statement);
 	}
 

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

 	}
 	
 	public static class Option extends Taggable {
+		public final CodePosition position;
 		public final VariantDefinition variant;
 		public final String name;
 		public final int ordinal;
 		public final StoredType[] types;
 		
-		public Option(VariantDefinition variant, String name, int ordinal, StoredType[] types) {
+		public Option(CodePosition position, VariantDefinition variant, String name, int ordinal, StoredType[] types) {
+			this.position = position;
 			this.variant = variant;
 			this.name = name;
 			this.ordinal = ordinal;

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

 import java.util.List;
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
-import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialPackageExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
 		subPackages.put(name, subPackage);
 	}
 	
-	public IPartialExpression getMember(CodePosition position, GlobalTypeRegistry registry, GenericName name) {
+	public IPartialExpression getMember(CodePosition position, GlobalTypeRegistry registry, GenericName name) throws CompileException {
 		if (subPackages.containsKey(name.name) && name.hasNoArguments())
 			return new PartialPackageExpression(position, subPackages.get(name.name));
 		
 		if (types.containsKey(name.name)) {
 			if (types.get(name.name).typeParameters.length != name.getNumberOfArguments())
-				return new InvalidExpression(position, CompileExceptionCode.TYPE_ARGUMENTS_INVALID_NUMBER, "Invalid number of type arguments");
+				throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_INVALID_NUMBER, "Invalid number of type arguments");
 			
 			return new PartialTypeExpression(position, registry.getForDefinition(types.get(name.name), name.arguments), name.arguments);
 		}

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

 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.OperatorType;
 	}
 	
 	@Override
-	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) {
+	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException {
 		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).call(position, scope, this, arguments, false);
 	}
 	

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

 				compiledArguments.getNumberOfTypeArguments() == 0 ? member.getHeader() : member.getHeader().fillGenericArguments(scope.getTypeRegistry(), compiledArguments.typeArguments, scope.getLocalTypeParameters()));
 	}
 	
-	public Expression not(Expression value) {
+	public Expression not(Expression value) throws CompileException {
 		TypeMembers members = scope.getTypeMembers(value.type);
 		return members.getOrCreateGroup(OperatorType.NOT)
 				.call(position, scope, value, CallArguments.EMPTY, false);

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

 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
 		this.message = message;
 	}
 	
-	public InvalidExpression(CodePosition position, CompileExceptionCode code, String message) {
-		this(position, BasicTypeID.UNDETERMINED.stored, code, message);
-	}
-	
 	public InvalidExpression(StoredType type, CompileException cause) {
 		this(cause.position, type, cause.code, cause.getMessage());
 	}

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

 import org.openzen.zenscript.codemodel.statement.SwitchCase;
 import org.openzen.zenscript.codemodel.statement.SwitchStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
+import org.openzen.zenscript.codemodel.statement.VariableID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 
 	}
 	
 	public SwitchedMatch convertToSwitch(String tempVariable) {
-		VarStatement result = new VarStatement(position, tempVariable, type, null, false);
+		VarStatement result = new VarStatement(position, new VariableID(), tempVariable, type, null, false);
 		SwitchStatement switchStatement = new SwitchStatement(position, null, value);
 		boolean hasDefault = false;
 		for (MatchExpression.Case matchCase : cases) {

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

 
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
 	}
 	
 	@Override
-	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) {
+	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException {
 		if (arguments != null)
 			return super.call(position, scope, hints, arguments);
 		
 	public Expression normalize(TypeScope scope) {
 		Expression[] normalized = new Expression[arguments.length];
 		for (int i = 0; i < normalized.length; i++)
-			normalized[i] = arguments[i].normalize(scope);
+			normalized[i] = arguments[i].normalize(scope).castImplicit(position, scope, option.types[i]);
 		return new VariantValueExpression(position, type, option, normalized);
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/IPartialExpression.java

 import java.util.Collections;
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 		return Collections.emptyList();
 	}
 	
-	Expression eval();
+	Expression eval() throws CompileException;
 	
-	List<StoredType>[] predictCallTypes(TypeScope scope, List<StoredType> hints, int arguments);
+	List<StoredType>[] predictCallTypes(TypeScope scope, List<StoredType> hints, int arguments) throws CompileException;
 	
-	List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments);
+	List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) throws CompileException;
 	
-	IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name);
+	IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) throws CompileException;
 	
-	Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments);
+	Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException;
 	
 	TypeID[] getGenericCallTypes();
 	
 		return null;
 	}
 	
-	default Expression assign(CodePosition position, TypeScope scope, Expression value) {
+	default Expression assign(CodePosition position, TypeScope scope, Expression value) throws CompileException {
 		return new InvalidExpression(position, value.type, CompileExceptionCode.CANNOT_ASSIGN, "This expression is not assignable");
 	}
 	
-	default IPartialExpression capture(CodePosition position, LambdaClosure closure) {
-		return new InvalidExpression(position, CompileExceptionCode.UNAVAILABLE_IN_CLOSURE, "expression not allowed in closure");
+	default IPartialExpression capture(CodePosition position, LambdaClosure closure) throws CompileException {
+		throw new CompileException(position, CompileExceptionCode.UNAVAILABLE_IN_CLOSURE, "expression not allowed in closure");
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialGlobalExpression.java

 
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 	}
 	
 	@Override
-	public Expression eval() {
+	public Expression eval() throws CompileException {
 		return new GlobalExpression(position, name, resolution.eval());
 	}
 
 	@Override
-	public List<StoredType>[] predictCallTypes(TypeScope scope, List<StoredType> hints, int arguments) {
+	public List<StoredType>[] predictCallTypes(TypeScope scope, List<StoredType> hints, int arguments) throws CompileException {
 		return resolution.predictCallTypes(scope, hints, arguments);
 	}
 
 	@Override
-	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) {
+	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) throws CompileException {
 		return resolution.getPossibleFunctionHeaders(scope, hints, arguments);
 	}
 
 	@Override
-	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) {
+	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) throws CompileException {
 		return eval().getMember(position, scope, hints, name);
 	}
 
 	@Override
-	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) {
+	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException {
 		return new GlobalCallExpression(position, name, arguments, resolution.call(position, scope, hints, arguments));
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialMemberGroupExpression.java

 	}
 
 	@Override
-	public Expression eval() {
+	public Expression eval() throws CompileException {
 		return group.getter(position, scope, target, allowStaticUsage);
 	}
 	
 	}
 
 	@Override
-	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) {
+	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) throws CompileException {
 		return eval().getMember(position, scope, hints, name);
 	}
 
 	@Override
-	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) {
+	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException {
 		return group.call(position, scope, target, arguments, allowStaticUsage);
 	}
 	
 	@Override
-	public Expression assign(CodePosition position, TypeScope scope, Expression value) {
+	public Expression assign(CodePosition position, TypeScope scope, Expression value) throws CompileException {
 		return group.setter(position, scope, target, value, allowStaticUsage);
 	}
 	
 	@Override
-	public IPartialExpression capture(CodePosition position, LambdaClosure closure) {
+	public IPartialExpression capture(CodePosition position, LambdaClosure closure) throws CompileException {
 		return new PartialMemberGroupExpression(position, scope, target.capture(position, closure).eval(), group, typeArguments, allowStaticUsage);
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialPackageExpression.java

 import java.util.Collections;
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
 	}
 	
 	@Override
-	public Expression eval() {
-		return new InvalidExpression(position, CompileExceptionCode.USING_PACKAGE_AS_EXPRESSION, "Cannot evaluate a package as expression");
+	public Expression eval() throws CompileException {
+		throw new CompileException(position, CompileExceptionCode.USING_PACKAGE_AS_EXPRESSION, "Cannot evaluate a package as expression");
 	}
 
 	@Override
 	}
 
 	@Override
-	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) {
+	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) throws CompileException {
 		return pkg.getMember(position, scope.getTypeRegistry(), name);
 	}
 
 	@Override
-	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) {
-		return new InvalidExpression(position, CompileExceptionCode.USING_PACKAGE_AS_CALL_TARGET, "Cannot call a package");
+	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException {
+		throw new CompileException(position, CompileExceptionCode.USING_PACKAGE_AS_CALL_TARGET, "Cannot call a package");
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialStaticMemberGroupExpression.java

 import java.util.List;
 import java.util.stream.Collectors;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 	}
 	
 	@Override
-	public Expression eval() {
+	public Expression eval() throws CompileException {
 		return group.staticGetter(position, scope);
 	}
 
 	}
 
 	@Override
-	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) {
+	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) throws CompileException {
 		return eval().getMember(position, scope, hints, name);
 	}
 
 	@Override
-	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) {
+	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException {
 		return group.callStatic(position, target, scope, arguments);
 	}
 	
 	@Override
-	public Expression assign(CodePosition position, TypeScope scope, Expression value) {
+	public Expression assign(CodePosition position, TypeScope scope, Expression value) throws CompileException {
 		return group.staticSetter(position, scope, value);
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialTypeExpression.java

 import java.util.List;
 import java.util.stream.Collectors;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.OperatorType;
 	}
 
 	@Override
-	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) {
+	public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException {
 		if (arguments.getNumberOfTypeArguments() == 0 && (typeParameters != null && typeParameters.length > 0))
 			arguments = new CallArguments(typeParameters, arguments.arguments);
 		

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialVariantOptionExpression.java

 import java.util.Collections;
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 	}
 
 	@Override
-	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) {
-		return new InvalidExpression(position, CompileExceptionCode.NO_SUCH_MEMBER, "Variant options don't have members");
+	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) throws CompileException {
+		throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Variant options don't have members");
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.scope;
 
-import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
  * @author Hoofdgebruiker
  */
 public abstract class BaseScope implements TypeScope {
-	public abstract IPartialExpression get(CodePosition position, GenericName name);
+	public abstract IPartialExpression get(CodePosition position, GenericName name) throws CompileException;
 	
 	public abstract LoopStatement getLoop(String name);
 	
 		return getMemberCache().getRegistry();
 	}
 	
-	public abstract Function<CodePosition, Expression> getDollar();
+	public abstract DollarEvaluator getDollar();
 	
-	public abstract IPartialExpression getOuterInstance(CodePosition position);
+	public abstract IPartialExpression getOuterInstance(CodePosition position) throws CompileException;
+	
+	public interface DollarEvaluator {
+		Expression apply(CodePosition position) throws CompileException;
+	}
 }

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

 package org.openzen.zenscript.codemodel.scope;
 
 import java.util.List;
-import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.GenericName;
 	}
 	
 	@Override
-	public IPartialExpression get(CodePosition position, GenericName name) {
+	public IPartialExpression get(CodePosition position, GenericName name) throws CompileException {
 		IPartialExpression fromSuper = super.get(position, name);
 		if (fromSuper != null)
 			return fromSuper;
 	}
 
 	@Override
-	public Function<CodePosition, Expression> getDollar() {
+	public DollarEvaluator getDollar() {
 		return parent.getDollar();
 	}
 	
 	@Override
-	public IPartialExpression getOuterInstance(CodePosition position) {
+	public IPartialExpression getOuterInstance(CodePosition position) throws CompileException {
 		return parent.getOuterInstance(position);
 	}
 

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

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
-import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
 	}
 
 	@Override
-	public IPartialExpression get(CodePosition position, GenericName name) {
+	public IPartialExpression get(CodePosition position, GenericName name) throws CompileException {
 		if (typeParameters.containsKey(name.name) && !name.hasArguments())
 			return new PartialTypeExpression(position, getTypeRegistry().getGeneric(typeParameters.get(name.name)), name.arguments);
 
 	}
 
 	@Override
-	public Function<CodePosition, Expression> getDollar() {
+	public DollarEvaluator getDollar() {
 		return outer.getDollar();
 	}
 

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

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.function.Function;
 import java.util.function.Supplier;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
-import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 	}
 
 	@Override
-	public IPartialExpression get(CodePosition position, GenericName name) {
+	public IPartialExpression get(CodePosition position, GenericName name) throws CompileException {
 		if (members != null) {
 			if (members.hasInnerType(name.name))
 				return new PartialTypeExpression(position, members.getInnerType(position, name), name.arguments);
 	}
 
 	@Override
-	public Function<CodePosition, Expression> getDollar() {
+	public DollarEvaluator getDollar() {
 		return outer.getDollar();
 	}
 	
 	@Override
-	public IPartialExpression getOuterInstance(CodePosition position) {
+	public IPartialExpression getOuterInstance(CodePosition position) throws CompileException {
 		if (!definition.isInnerDefinition()) {
-			return new InvalidExpression(position, CompileExceptionCode.NO_OUTER_BECAUSE_NOT_INNER, "Type is not an inner type; cannot access outer type");
+			throw new CompileException(position, CompileExceptionCode.NO_OUTER_BECAUSE_NOT_INNER, "Type is not an inner type; cannot access outer type");
 		} else if (definition.isStatic()) {
 			return new InvalidExpression(position, outer.getThisType(), CompileExceptionCode.NO_OUTER_BECAUSE_STATIC, "Inner type is static; cannot access outer type reference");
 		} else {

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

 import java.util.Map;
 import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
  */
 public class ExpressionScope extends BaseScope {
 	private final BaseScope outer;
-	private final Function<CodePosition, Expression> dollar;
+	private final DollarEvaluator dollar;
 	
 	public final List<StoredType> hints;
 	public final Map<TypeParameter, TypeID> genericInferenceMap;
 	private ExpressionScope(
 			BaseScope scope,
 			List<StoredType> hints,
-			Function<CodePosition, Expression> dollar,
+			DollarEvaluator dollar,
 			Map<TypeParameter, TypeID> genericInferenceMap,
 			Map<String, Function<CodePosition, Expression>> innerVariables) {
 		this.outer = scope;
 		return new ExpressionScope(outer, hints, dollar, genericInferenceMap, innerVariables);
 	}
 	
-	public ExpressionScope createInner(List<StoredType> hints, Function<CodePosition, Expression> dollar) {
+	public ExpressionScope createInner(List<StoredType> hints, DollarEvaluator dollar) {
 		return new ExpressionScope(outer, hints, dollar, genericInferenceMap, innerVariables);
 	}
 	
 	}
 	
 	@Override
-	public IPartialExpression get(CodePosition position, GenericName name) {
+	public IPartialExpression get(CodePosition position, GenericName name) throws CompileException {
 		if (name.hasNoArguments() && innerVariables.containsKey(name.name))
 			return innerVariables.get(name.name).apply(position);
 		
 	}
 
 	@Override
-	public Function<CodePosition, Expression> getDollar() {
+	public DollarEvaluator getDollar() {
 		return dollar == null ? outer.getDollar() : dollar;
 	}
 	
 	@Override
-	public IPartialExpression getOuterInstance(CodePosition position) {
+	public IPartialExpression getOuterInstance(CodePosition position) throws CompileException {
 		return outer.getOuterInstance(position);
 	}
 

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

 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
-import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
-import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialGlobalExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
 	}
 
 	@Override
-	public Function<CodePosition, Expression> getDollar() {
+	public DollarEvaluator getDollar() {
 		return null;
 	}
 	
 	@Override
-	public IPartialExpression getOuterInstance(CodePosition position) {
-		return new InvalidExpression(position, CompileExceptionCode.NO_OUTER_BECAUSE_OUTSIDE_TYPE, "Not in an inner type");
+	public IPartialExpression getOuterInstance(CodePosition position) throws CompileException {
+		throw new CompileException(position, CompileExceptionCode.NO_OUTER_BECAUSE_OUTSIDE_TYPE, "Not in an inner type");
 	}
 
 	@Override

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

 package org.openzen.zenscript.codemodel.scope;
 
 import java.util.List;
-import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.ForeachStatement;
 	}
 
 	@Override
-	public IPartialExpression get(CodePosition position, GenericName name) {
+	public IPartialExpression get(CodePosition position, GenericName name) throws CompileException {
 		if (name.hasNoArguments()) {
 			for (VarStatement loopVariable : statement.loopVariables) {
 				if (loopVariable.name.equals(name.name))
 	}
 
 	@Override
-	public Function<CodePosition, Expression> getDollar() {
+	public DollarEvaluator getDollar() {
 		return outer.getDollar();
 	}
 	
 	@Override
-	public IPartialExpression getOuterInstance(CodePosition position) {
+	public IPartialExpression getOuterInstance(CodePosition position) throws CompileException {
 		return outer.getOuterInstance(position);
 	}
 

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

 package org.openzen.zenscript.codemodel.scope;
 
 import java.util.List;
-import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 	}
 
 	@Override
-	public IPartialExpression get(CodePosition position, GenericName name) {
+	public IPartialExpression get(CodePosition position, GenericName name) throws CompileException {
 		IPartialExpression fromSuper = super.get(position, name);
 		if (fromSuper != null)
 			return fromSuper;
 	}
 
 	@Override
-	public Function<CodePosition, Expression> getDollar() {
+	public DollarEvaluator getDollar() {
 		for (FunctionParameter parameter : header.parameters)
 			if (parameter.name.equals("$"))
 				return position -> new GetFunctionParameterExpression(position, parameter);
 	}
 	
 	@Override
-	public IPartialExpression getOuterInstance(CodePosition position) {
+	public IPartialExpression getOuterInstance(CodePosition position) throws CompileException {
 		return outer.getOuterInstance(position);
 	}
 

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

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
 	}
 
 	@Override
-	public IPartialExpression get(CodePosition position, GenericName name) {
+	public IPartialExpression get(CodePosition position, GenericName name) throws CompileException {
 		if (parameters.containsKey(name.name) && name.hasNoArguments())
 			return new PartialTypeExpression(position, getTypeRegistry().getGeneric(parameters.get(name.name)), name.arguments);
 		
 	}
 
 	@Override
-	public Function<CodePosition, Expression> getDollar() {
+	public DollarEvaluator getDollar() {
 		return outer.getDollar();
 	}
 	
 	@Override
-	public IPartialExpression getOuterInstance(CodePosition position) {
+	public IPartialExpression getOuterInstance(CodePosition position) throws CompileException {
 		return outer.getOuterInstance(position);
 	}
 

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

 package org.openzen.zenscript.codemodel.scope;
 
 import java.util.List;
-import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.GenericName;
 	}
 	
 	@Override
-	public IPartialExpression get(CodePosition position, GenericName name) {
+	public IPartialExpression get(CodePosition position, GenericName name) throws CompileException {
 		IPartialExpression result = super.get(position, name);
 		if (result != null)
 			return result;
 	}
 
 	@Override
-	public Function<CodePosition, Expression> getDollar() {
+	public DollarEvaluator getDollar() {
 		return null; // script arguments?
 	}
 

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

 package org.openzen.zenscript.codemodel.scope;
 
 import java.util.List;
-import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 	}
 
 	@Override
-	public IPartialExpression get(CodePosition position, GenericName name) {
+	public IPartialExpression get(CodePosition position, GenericName name) throws CompileException {
 		if (members.hasInnerType(name.name))
 			return new PartialTypeExpression(position, members.getInnerType(position, name), name.arguments);
 		if (members.hasMember(name.name))
 	}
 
 	@Override
-	public Function<CodePosition, Expression> getDollar() {
+	public DollarEvaluator getDollar() {
 		return outer.getDollar();
 	}
 

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

 package org.openzen.zenscript.codemodel.scope;
 
 import java.util.List;
-import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
 import org.openzen.zenscript.codemodel.expression.LambdaClosure;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 	}
 	
 	@Override
-	public IPartialExpression get(CodePosition position, GenericName name) {
+	public IPartialExpression get(CodePosition position, GenericName name) throws CompileException {
 		IPartialExpression outer = this.outer.get(position, name);
 		if (outer == null) {
 			if (name.hasNoArguments()) {
 	}
 
 	@Override
-	public Function<CodePosition, Expression> getDollar() {
-		Function<CodePosition, Expression> outerDollar = outer.getDollar();
+	public DollarEvaluator getDollar() {
+		DollarEvaluator outerDollar = outer.getDollar();
 		if (outerDollar == null)
 			return null;
 		
 	}
 	
 	@Override
-	public IPartialExpression getOuterInstance(CodePosition position) {
+	public IPartialExpression getOuterInstance(CodePosition position) throws CompileException {
 		return outer.getOuterInstance(position);
 	}
 

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

 package org.openzen.zenscript.codemodel.scope;
 
 import java.util.List;
-import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.GenericName;
 	}
 
 	@Override
-	public IPartialExpression get(CodePosition position, GenericName name) {
+	public IPartialExpression get(CodePosition position, GenericName name) throws CompileException {
 		IPartialExpression result = super.get(position, name);
 		if (result != null)
 			return result;
 	}
 
 	@Override
-	public Function<CodePosition, Expression> getDollar() {
+	public DollarEvaluator getDollar() {
 		return outer.getDollar();
 	}
 	
 	@Override
-	public IPartialExpression getOuterInstance(CodePosition position) {
+	public IPartialExpression getOuterInstance(CodePosition position) throws CompileException {
 		return outer.getOuterInstance(position);
 	}
 

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

 import java.util.HashMap;
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 	}
 	
 	@Override
-	public IPartialExpression get(CodePosition position, GenericName name) {
+	public IPartialExpression get(CodePosition position, GenericName name) throws CompileException {
 		if (variables.containsKey(name.name) && name.hasNoArguments())
 			return new GetLocalVariableExpression(position, variables.get(name.name));
 		

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/IfStatement.java

 
 	@Override
 	public Statement normalize(TypeScope scope, ConcatMap<LoopStatement, LoopStatement> modified) {
-		return new IfStatement(position, condition.normalize(scope), onThen.normalize(scope, modified), onElse == null ? null : onElse.normalize(scope, modified));
+		return new IfStatement(
+				position,
+				condition.normalize(scope),
+				onThen.normalize(scope, modified),
+				onElse == null ? null : onElse.normalize(scope, modified));
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/VarStatement.java

 	public final String name;
 	public final StoredType type;
 	public final Expression initializer;
+	public final VariableID variable;
 	public final boolean isFinal;
 	
-	public VarStatement(CodePosition position, String name, StoredType type, Expression initializer, boolean isFinal) {
+	public VarStatement(CodePosition position, VariableID variable, String name, StoredType type, Expression initializer, boolean isFinal) {
 		super(position, initializer == null ? null : initializer.thrownType);
 		
 		this.name = name;
 		this.type = type;
 		this.initializer = initializer;
+		this.variable = variable;
 		this.isFinal = isFinal;
 	}
 
 	@Override
 	public VarStatement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
 		Expression tInitializer = initializer == null ? null : initializer.transform(transformer);
-		return tInitializer == initializer ? this : new VarStatement(position, name, type, tInitializer, isFinal);
+		return tInitializer == initializer ? this : new VarStatement(position, variable, name, type, tInitializer, isFinal);
 	}
 
 	@Override
 	public VarStatement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
 		Expression tInitializer = initializer == null ? null : initializer.transform(transformer);
-		return tInitializer == initializer ? this : new VarStatement(position, name, type, tInitializer, isFinal);
+		return tInitializer == initializer ? this : new VarStatement(position, variable, name, type, tInitializer, isFinal);
 	}
 
 	@Override
 	public VarStatement normalize(TypeScope scope, ConcatMap<LoopStatement, LoopStatement> modified) {
-		return new VarStatement(position, name, type.getNormalized(), initializer == null ? null : initializer.normalize(scope), isFinal);
+		return new VarStatement(position, variable, name, type.getNormalized(), initializer == null ? null : initializer.normalize(scope), isFinal);
 	}
 }

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

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
 	
 	@Override
 	public String toString() {
+		return toString(null);
+	}
+	
+	@Override
+	public String toString(StorageTag storage) {
 		StringBuilder result = new StringBuilder();
+		result.append("function");
+		if (header.typeParameters.length > 0) {
+			result.append('<');
+			for (int i = 0; i < header.typeParameters.length; i++) {
+				if (i > 0)
+					result.append(", ");
+				
+				result.append(header.typeParameters[i].toString());
+			}
+			result.append('>');
+		}
+		if (storage != null && storage != ValueStorageTag.INSTANCE) {
+			result.append('`');
+			result.append(storage);
+		}
 		result.append('(');
 		for (int i = 0; i < header.parameters.length; i++) {
 			if (i > 0)

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

 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.storage.StorageTag;
-import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 
 /**
  *
 	public <C, R, E extends Exception> R accept(C context, TypeVisitorWithContext<C, R, E> visitor) throws E {
 		return visitor.visitInvalid(context, this);
 	}
+	
+	@Override
+	public String toString() {
+		return "invalid";
+	}
 }

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

 import java.util.Objects;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
 			result.append("?");
 		return result.toString();
 	}
+	
+	@Override
+	public String toString(StorageTag storage) {
+		StringBuilder result = new StringBuilder();
+		if ((modifiers & MODIFIER_IMMUTABLE) > 0)
+			result.append("immutable ");
+		if ((modifiers & MODIFIER_CONST) > 0)
+			result.append("const ");
+		result.append(baseType.toString(storage));
+		if ((modifiers & MODIFIER_OPTIONAL) > 0)
+			result.append("?");
+		return result.toString();
+	}
 }

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

 	
 	@Override
 	public String toString() {
-		if (storage == ValueStorageTag.INSTANCE)
-			return type.toString();
-		
-		return type.toString() + "`" + storage.toString();
+		return type.toString(storage);
 	}
 	
 	public static class MatchingTypeVisitor implements TypeVisitor<Boolean> {

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

 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
 	default boolean isEnum() {
 		return false;
 	}
+	
+	default String toString(StorageTag storage) {
+		if (storage == ValueStorageTag.INSTANCE)
+			return toString();
+		
+		return toString() + "`" + storage.toString();
+	}
 }

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

 			return false;
 		}
 	}
+	
+	@Override
+	public Boolean visitInvalid(Matching context, InvalidTypeID invalid) {
+		return false;
+	}
 
 	@Override
 	public Boolean visitIterator(Matching context, IteratorTypeID iterator) {

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

 package org.openzen.zenscript.codemodel.type.member;
 
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
 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.InvalidTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.codemodel.type.TypeVisitorWithContext;
 		return null;
 	}
 	
+	@Override
+	public Void visitInvalid(Void context, InvalidTypeID invalid) {
+		return null;
+	}
+	
 	@Override
 	public Void visitIterator(Void context, IteratorTypeID iterator) {
 		return null;
 		dec(builtin, INT_INC, INT);
 
 		add(builtin, INT_ADD_INT, INT, INT);
+		add(builtin, LONG_ADD_LONG, USIZE, LONG, INT_TO_LONG);
 		add(builtin, LONG_ADD_LONG, LONG, LONG, INT_TO_LONG);
 		add(builtin, FLOAT_ADD_FLOAT, FLOAT, FLOAT, INT_TO_FLOAT);
 		add(builtin, DOUBLE_ADD_DOUBLE, DOUBLE, DOUBLE, INT_TO_DOUBLE);
 		dec(builtin, UINT_INC, INT);
 
 		add(builtin, UINT_ADD_UINT, UINT, UINT);
+		add(builtin, ULONG_ADD_ULONG, USIZE, ULONG, UINT_TO_ULONG);
 		add(builtin, ULONG_ADD_ULONG, ULONG, ULONG, UINT_TO_ULONG);
 		add(builtin, FLOAT_ADD_FLOAT, FLOAT, FLOAT, UINT_TO_FLOAT);
 		add(builtin, DOUBLE_ADD_DOUBLE, DOUBLE, DOUBLE, UINT_TO_DOUBLE);

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

 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 
 		methods.add(new TypeMember<>(priority, method));
 	}
 	
-	public Expression getter(CodePosition position, TypeScope scope, Expression target, boolean allowStaticUsage) {
-		try {
-			if (getter != null) {
-				if (getter.member.isStatic()) {
-					if (!allowStaticUsage)
-						return new InvalidExpression(position, getter.member.getType(), CompileExceptionCode.USING_STATIC_ON_INSTANCE, "This field is static");
+	public Expression getter(CodePosition position, TypeScope scope, Expression target, boolean allowStaticUsage) throws CompileException {
+		if (getter != null) {
+			if (getter.member.isStatic()) {
+				if (!allowStaticUsage)
+					return new InvalidExpression(position, getter.member.getType(), CompileExceptionCode.USING_STATIC_ON_INSTANCE, "This field is static");
 
-					return getter.member.getStatic(position);
-				}
-
-				scope.getPreparer().prepare(getter.member.member);
-				return getter.member.get(position, target);
-			} else if (field != null) {
-				if (field.member.isStatic()) {
-					if (!allowStaticUsage)
-						return new InvalidExpression(position, field.member.getType(), CompileExceptionCode.USING_STATIC_ON_INSTANCE, "This field is static");
+				return getter.member.getStatic(position);
+			}
 
-					return new GetStaticFieldExpression(position, field.member);
-				}
+			scope.getPreparer().prepare(getter.member.member);
+			return getter.member.get(position, target);
+		} else if (field != null) {
+			if (field.member.isStatic()) {
+				if (!allowStaticUsage)
+					return new InvalidExpression(position, field.member.getType(), CompileExceptionCode.USING_STATIC_ON_INSTANCE, "This field is static");
 
-				scope.getPreparer().prepare(field.member.member);
-				return new GetFieldExpression(position, target, field.member);
-			} else {
-				return new InvalidExpression(position, CompileExceptionCode.MEMBER_NO_GETTER, "Value is not a property");
+				return new GetStaticFieldExpression(position, field.member);
 			}
-		} catch (CompileException ex) {
-			return new InvalidExpression(BasicTypeID.UNDETERMINED.stored, ex);
+
+			scope.getPreparer().prepare(field.member.member);
+			return new GetFieldExpression(position, target, field.member);
+		} else {
+			throw new CompileException(position, CompileExceptionCode.MEMBER_NO_GETTER, "Value is not a property");
 		}
 	}
 	
-	public Expression setter(CodePosition position, TypeScope scope, Expression target, Expression value, boolean allowStaticUsage) {
-		try {
-			if (setter != null) {
-				if (setter.member.isStatic()) {
-					if (!allowStaticUsage)
-						return new InvalidExpression(position, setter.member.getType(), CompileExceptionCode.USING_STATIC_ON_INSTANCE, "This field is static");
-
-					scope.getPreparer().prepare(setter.member.member);
-					return new StaticSetterExpression(position, setter.member, value.castImplicit(position, scope, setter.member.getType()));
-				}
+	public Expression setter(CodePosition position, TypeScope scope, Expression target, Expression value, boolean allowStaticUsage) throws CompileException {
+		if (setter != null) {
+			if (setter.member.isStatic()) {
+				if (!allowStaticUsage)
+					return new InvalidExpression(position, setter.member.getType(), CompileExceptionCode.USING_STATIC_ON_INSTANCE, "This field is static");
 
 				scope.getPreparer().prepare(setter.member.member);
-				return new SetterExpression(position, target, setter.member, value.castImplicit(position, scope, setter.member.getType()));
-			} else if (field != null) {
-				// TODO: perform proper checks on val fields
-				//if (field.isFinal)
-				//	throw new CompileException(position, "This field cannot be modified");
-				if (field.member.isStatic()) {
-					if (!allowStaticUsage)
-						return new InvalidExpression(position, field.member.getType(), CompileExceptionCode.USING_STATIC_ON_INSTANCE, "This field is static");
+				return new StaticSetterExpression(position, setter.member, value.castImplicit(position, scope, setter.member.getType()));
+			}
 
-					scope.getPreparer().prepare(field.member.member);
-					return new SetStaticFieldExpression(position, field.member, value.castImplicit(position, scope, field.member.getType()));
-				}
+			scope.getPreparer().prepare(setter.member.member);
+			return new SetterExpression(position, target, setter.member, value.castImplicit(position, scope, setter.member.getType()));
+		} else if (field != null) {
+			// TODO: perform proper checks on val fields
+			//if (field.isFinal)
+			//	throw new CompileException(position, "This field cannot be modified");
+			if (field.member.isStatic()) {
+				if (!allowStaticUsage)
+					return new InvalidExpression(position, field.member.getType(), CompileExceptionCode.USING_STATIC_ON_INSTANCE, "This field is static");
 
 				scope.getPreparer().prepare(field.member.member);
-				return new SetFieldExpression(position, target, field.member, value.castImplicit(position, scope, field.member.getType()));
-			} else {
-				return new InvalidExpression(position, CompileExceptionCode.MEMBER_NO_SETTER, "Value is not settable");
+				return new SetStaticFieldExpression(position, field.member, value.castImplicit(position, scope, field.member.getType()));
 			}
-		} catch (CompileException ex) {
-			return new InvalidExpression(BasicTypeID.UNDETERMINED.stored, ex);
+
+			scope.getPreparer().prepare(field.member.member);
+			return new SetFieldExpression(position, target, field.member, value.castImplicit(position, scope, field.member.getType()));
+		} else {
+			throw new CompileException(position, CompileExceptionCode.MEMBER_NO_SETTER, "Value is not settable");
 		}
 	}
 	
-	public Expression staticGetter(CodePosition position, TypeScope scope) {
-		try {
-			if (constant != null) {
-				return new ConstExpression(position, constant.member);
-			} else if (getter != null) {
-				if (!getter.member.isStatic())
-					return new InvalidExpression(position, getter.member.getType(), CompileExceptionCode.MEMBER_NOT_STATIC, "This getter is not static");
+	public Expression staticGetter(CodePosition position, TypeScope scope) throws CompileException {
+		if (constant != null) {
+			return new ConstExpression(position, constant.member);
+		} else if (getter != null) {
+			if (!getter.member.isStatic())
+				return new InvalidExpression(position, getter.member.getType(), CompileExceptionCode.MEMBER_NOT_STATIC, "This getter is not static");
 
-				scope.getPreparer().prepare(getter.member.member);
-				return getter.member.getStatic(position);
-			} else if (field != null) {
-				if (!field.member.isStatic())
-					return new InvalidExpression(position, field.member.getType(), CompileExceptionCode.MEMBER_NOT_STATIC, "This field is not static");
+			scope.getPreparer().prepare(getter.member.member);
+			return getter.member.getStatic(position);
+		} else if (field != null) {
+			if (!field.member.isStatic())
+				return new InvalidExpression(position, field.member.getType(), CompileExceptionCode.MEMBER_NOT_STATIC, "This field is not static");
 
-				scope.getPreparer().prepare(field.member.member);
-				return new GetStaticFieldExpression(position, field.member);
-			} else {
-				return new InvalidExpression(position, CompileExceptionCode.MEMBER_NO_GETTER, "Member is not gettable");
-			}
-		} catch (CompileException ex) {
-			return new InvalidExpression(BasicTypeID.UNDETERMINED.stored, ex);
+			scope.getPreparer().prepare(field.member.member);
+			return new GetStaticFieldExpression(position, field.member);
+		} else {
+			throw new CompileException(position, CompileExceptionCode.MEMBER_NO_GETTER, "Member is not gettable");
 		}
 	}
 	
-	public Expression staticSetter(CodePosition position, TypeScope scope, Expression value) {
-		try {
-			if (getter != null) {
-				if (!getter.member.isStatic())
-					return new InvalidExpression(position, getter.member.getType(), CompileExceptionCode.MEMBER_NOT_STATIC, "This getter is not static");
+	public Expression staticSetter(CodePosition position, TypeScope scope, Expression value) throws CompileException {
+		if (getter != null) {
+			if (!getter.member.isStatic())
+				return new InvalidExpression(position, getter.member.getType(), CompileExceptionCode.MEMBER_NOT_STATIC, "This getter is not static");
 
-				scope.getPreparer().prepare(setter.member.member);
-				return new StaticSetterExpression(position, setter.member, value.castImplicit(position, scope, setter.member.getType()));
-			} else if (field != null) {
-				//if (field.member.isFinal)
-				//	throw new CompileException(position, CompileExceptionCode.MEMBER_IS_FINAL, "This field cannot be modified");
-				if (!field.member.isStatic())
-					return new InvalidExpression(position, field.member.getType(), CompileExceptionCode.MEMBER_NOT_STATIC, "This field is not static");
+			scope.getPreparer().prepare(setter.member.member);
+			return new StaticSetterExpression(position, setter.member, value.castImplicit(position, scope, setter.member.getType()));
+		} else if (field != null) {
+			//if (field.member.isFinal)
+			//	throw new CompileException(position, CompileExceptionCode.MEMBER_IS_FINAL, "This field cannot be modified");
+			if (!field.member.isStatic())
+				return new InvalidExpression(position, field.member.getType(), CompileExceptionCode.MEMBER_NOT_STATIC, "This field is not static");
 
-				scope.getPreparer().prepare(field.member.member);
-				return new SetStaticFieldExpression(position, field.member, value.castImplicit(position, scope, field.member.getType()));
-			} else {
-				return new InvalidExpression(position, CompileExceptionCode.MEMBER_NO_SETTER, "Member is not settable");
-			}
-		} catch (CompileException ex) {
-			return new InvalidExpression(BasicTypeID.UNDETERMINED.stored, ex);
+			scope.getPreparer().prepare(field.member.member);
+			return new SetStaticFieldExpression(position, field.member, value.castImplicit(position, scope, field.member.getType()));
+		} else {
+			throw new CompileException(position, CompileExceptionCode.MEMBER_NO_SETTER, "Member is not settable");
 		}
 	}
 	
 		return result;
 	}
 	
-	public Expression call(CodePosition position, TypeScope scope, Expression target, CallArguments arguments, boolean allowStaticUsage) {
-		try {
-			FunctionalMemberRef method = selectMethod(position, scope, arguments, true, allowStaticUsage);
-			FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
-			for (int i = 0; i < arguments.arguments.length; i++) {
-				arguments.arguments[i] = arguments.arguments[i].castImplicit(position, scope, instancedHeader.parameters[i].type);
-			}
-
-			scope.getPreparer().prepare(method.getTarget());
-			return method.call(position, target, instancedHeader, arguments, scope);
-		} catch (CompileException ex) {
-			return new InvalidExpression(position, ex.code, ex.getMessage());
+	public Expression call(CodePosition position, TypeScope scope, Expression target, CallArguments arguments, boolean allowStaticUsage) throws CompileException {
+		FunctionalMemberRef method = selectMethod(position, scope, arguments, true, allowStaticUsage);
+		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
+		for (int i = 0; i < arguments.arguments.length; i++) {
+			arguments.arguments[i] = arguments.arguments[i].castImplicit(position, scope, instancedHeader.parameters[i].type);
 		}
+
+		scope.getPreparer().prepare(method.getTarget());
+		return method.call(position, target, instancedHeader, arguments, scope);
 	}
 	
-	public Expression callPostfix(CodePosition position, TypeScope scope, Expression target) {
+	public Expression callPostfix(CodePosition position, TypeScope scope, Expression target) throws CompileException {
 		if (methods.isEmpty())
-			return new InvalidExpression(position, CompileExceptionCode.NO_SUCH_MEMBER, "There is no such operator");
+			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "There is no such operator");
 		
 		FunctionalMemberRef method = methods.get(0).member;
 		if (!method.isOperator())
-			return new InvalidExpression(position, CompileExceptionCode.NO_SUCH_MEMBER, "Member is not an operator");
+			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Member is not an operator");
 		
-		try {
-			scope.getPreparer().prepare(method.getTarget());
-			return new PostCallExpression(position, target, method, method.getHeader());
-		} catch (CompileException ex) {
-			return new InvalidExpression(BasicTypeID.UNDETERMINED.stored, ex);
-		}
+		scope.getPreparer().prepare(method.getTarget());
+		return new PostCallExpression(position, target, method, method.getHeader());
 	}
 	
 	public Expression callWithComparator(
 			TypeScope scope,
 			Expression target,
 			CallArguments arguments,
-			CompareType compareType) {
-		try {
-			FunctionalMemberRef method = selectMethod(position, scope, arguments, true, false);
-			FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
-			return method.callWithComparator(position, compareType, target, instancedHeader, arguments, scope);
-		} catch (CompileException ex) {
-			return new InvalidExpression(position, ex.code, ex.getMessage());
-		}
+			CompareType compareType) throws CompileException
+	{
+		FunctionalMemberRef method = selectMethod(position, scope, arguments, true, false);
+		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
+		return method.callWithComparator(position, compareType, target, instancedHeader, arguments, scope);
 	}
 	
-	public Expression callStatic(CodePosition position, TypeID target, TypeScope scope, CallArguments arguments) {
-		try {
-			FunctionalMemberRef method = selectMethod(position, scope, arguments, false, true);
-			FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
-			return method.callStatic(position, target, instancedHeader, arguments, scope);
-		} catch (CompileException ex) {
-			return new InvalidExpression(position, ex.code, ex.getMessage());
-		}
+	public Expression callStatic(CodePosition position, TypeID target, TypeScope scope, CallArguments arguments) throws CompileException {
+		FunctionalMemberRef method = selectMethod(position, scope, arguments, false, true);
+		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
+		return method.callStatic(position, target, instancedHeader, arguments, scope);
 	}
 	
 	public FunctionalMemberRef selectMethod(CodePosition position, TypeScope scope, CallArguments arguments, boolean allowNonStatic, boolean allowStatic) throws CompileException {

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

 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
 		return variantOptions.get(name);
 	}
 	
-	public Expression compare(CodePosition position, TypeScope scope, CompareType operator, Expression left, Expression right) {
+	public Expression compare(CodePosition position, TypeScope scope, CompareType operator, Expression left, Expression right) throws CompileException {
 		if (operator == CompareType.EQ) {
 			TypeMemberGroup equal = getOrCreateGroup(OperatorType.EQUALS);
 			for (TypeMember<FunctionalMemberRef> member : equal.getMethodMembers()) {
 		return compare.callWithComparator(position, scope, left, new CallArguments(right), operator);
 	}
 	
-	public Expression unary(CodePosition position, TypeScope scope, OperatorType operator, Expression value) {
+	public Expression unary(CodePosition position, TypeScope scope, OperatorType operator, Expression value) throws CompileException {
 		TypeMemberGroup members = getOrCreateGroup(operator);
 		return members.call(position, scope, value, new CallArguments(Expression.NONE), false);
 	}
 	}
 	
 	private Expression castEquivalent(CodePosition position, Expression value, StoredType toType) {
-		if (toType == value.type)
+		if (toType.equals(value.type))
 			return value;
 		
+		if (!(toType.type instanceof StringTypeID))
+			System.out.println(position + ": " + value.type.storage + " -> " + toType.storage);
+		
 		return new StorageCastExpression(position, value, toType);
 	}
 	
 	public Expression castImplicit(CodePosition position, Expression value, StoredType toType, boolean implicit) {
+		if (toType == null)
+			throw new NullPointerException();
+		
 		toType = toType.getNormalized();
 		if (toType.type == BasicTypeID.UNDETERMINED)
 			return value;
 			return castImplicit(position, value, toType, false);
 		
 		for (TypeMember<CasterMemberRef> caster : casters)
-			if (toType == caster.member.toType)
-				return caster.member.cast(position, value, false);
+			if (areEquivalent(caster.member.toType, toType))
+				return castEquivalent(position, caster.member.cast(position, value, false), toType);
 		
 		return new InvalidExpression(position, toType, CompileExceptionCode.INVALID_CAST, "Cannot cast " + toString() + " to " + toType + ", even explicitly");
 	}

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

 
 	@Override
 	public boolean canCastFrom(StorageTag other) {
-		return other == this || other == UniqueStorageTag.INSTANCE;
+		return other == this || other == UniqueStorageTag.INSTANCE || other == StaticStorageTag.INSTANCE;
 	}
 
 	@Override

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

 		ModuleTypeResolutionContext context = new ModuleTypeResolutionContext(compilationUnit.globalTypeRegistry, annotations, storageTypes, rootPackage, null, globals);
 		AnnotationProcessor annotationProcessor = new AnnotationProcessor(context, expansions);
 		List<ScriptBlock> processedScripts = new ArrayList<>();
+		FileScope fileScope = new FileScope(context, expansions, globals, member -> {});
+			
 		for (ScriptBlock block : scripts)
-			processedScripts.add(annotationProcessor.process(block));
+			processedScripts.add(annotationProcessor.process(block).normalize(fileScope));
+		
 		for (HighLevelDefinition definition : definitions.getAll()) {
 			annotationProcessor.process(definition);
-			
-			FileScope fileScope = new FileScope(context, expansions, globals, member -> {});
 			definition.normalize(fileScope);
 		}
 		

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

 	@Override
 	public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
 		final Label label = new Label();
-		final JavaLocalVariableInfo tag = expression.variable.getTag(JavaLocalVariableInfo.class);
+		final JavaLocalVariableInfo tag = expression.variable.variable.getTag(JavaLocalVariableInfo.class);
+		if (tag == null)
+			throw new RuntimeException("Missing tag @ " + expression.position);
+		
 		tag.end = label;
 		javaWriter.load(tag.type, tag.local);
 		javaWriter.label(label);
 		expression.value.accept(this);
 		Label label = new Label();
 		javaWriter.label(label);
-		final JavaLocalVariableInfo tag = expression.variable.getTag(JavaLocalVariableInfo.class);
+		final JavaLocalVariableInfo tag = expression.variable.variable.getTag(JavaLocalVariableInfo.class);
 		tag.end = label;
 
 		javaWriter.store(tag.type, tag.local);

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

 		javaWriter.swap();
 		javaWriter.getField("zsynthetic/IntRange", "from", "I");
 
-		final int z = variables[0].getTag(JavaLocalVariableInfo.class).local;
+		final int z = variables[0].variable.getTag(JavaLocalVariableInfo.class).local;
 		javaWriter.storeInt(z);
 		javaWriter.label(startLabel);
 		javaWriter.dup();
 	}
 
 	public void visitArrayValueIterator() {
-		handleArray(javaWriter.local(int.class), variables[0].getTag(JavaLocalVariableInfo.class));
+		handleArray(javaWriter.local(int.class), variables[0].variable.getTag(JavaLocalVariableInfo.class));
 	}
 
 	public void visitArrayKeyValueIterator() {
-		handleArray(variables[0].getTag(JavaLocalVariableInfo.class).local, variables[1].getTag(JavaLocalVariableInfo.class));
+		handleArray(variables[0].variable.getTag(JavaLocalVariableInfo.class).local, variables[1].variable.getTag(JavaLocalVariableInfo.class));
 	}
 
 	public void visitStringCharacterIterator() {
 		//TODO UNTESTED!
 		javaWriter.invokeSpecial("java/lang/String", "toCharArray()", "()[C");
-		handleArray(javaWriter.local(int.class), variables[0].getTag(JavaLocalVariableInfo.class));
+		handleArray(javaWriter.local(int.class), variables[0].variable.getTag(JavaLocalVariableInfo.class));
 	}
 
 	private void handleArray(final int z, final JavaLocalVariableInfo arrayTypeInfo) {

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

 	
 	@Override
 	public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
-		javaWriter.idec(expression.variable.getTag(JavaLocalVariableInfo.class).local);
+		javaWriter.idec(expression.variable.variable.getTag(JavaLocalVariableInfo.class).local);
 		return null;
 	}
 

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

 
 	@Override
 	public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
-		JavaLocalVariableInfo localVariable = expression.variable.getTag(JavaLocalVariableInfo.class);
+		JavaLocalVariableInfo localVariable = expression.variable.variable.getTag(JavaLocalVariableInfo.class);
 		javaWriter.iinc(localVariable.local);
 		javaWriter.load(localVariable);
 		return null;

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

             final Label variableStart = new Label();
             final JavaLocalVariableInfo info = new JavaLocalVariableInfo(type, javaWriter.local(type), variableStart, variable.name);
             info.end = end;
-            variable.setTag(JavaLocalVariableInfo.class, info);
+            variable.variable.setTag(JavaLocalVariableInfo.class, info);
             javaWriter.addVariableInfo(info);
         }
 
 		final Label variableStart = new Label();
 		javaWriter.label(variableStart);
 		final JavaLocalVariableInfo info = new JavaLocalVariableInfo(type, local, variableStart, statement.name);
-		statement.setTag(JavaLocalVariableInfo.class, info);
+		statement.variable.setTag(JavaLocalVariableInfo.class, info);
 		javaWriter.addVariableInfo(info);
 		return false;
 	}

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

 
 import org.objectweb.asm.*;
 
-import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaDefinitionVisitor.java

 		final JavaWriter writer = new JavaWriter(outerWriter, true, method, definition, signature, null);
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, writer);
         statementVisitor.start();
-		boolean returns = definition.statement.accept(statementVisitor);
+		boolean returns = definition.caller.body.accept(statementVisitor);
 		if (!returns) {
 			StoredType type = definition.header.getReturnType();
 			if (CompilerUtils.isPrimitive(type.type))

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

 								.append(newArray(type.elementType, size))
 								.append(";")
 								.toString());
-					VarStatement tempI = new VarStatement(expression.position, scope.createTempVariable(), BasicTypeID.INT.stored, null, true);
+					VarStatement tempI = new VarStatement(expression.position, new VariableID(), scope.createTempVariable(), BasicTypeID.INT.stored, null, true);
 					target.writeLine(new StringBuilder()
 								.append("for (int ")
 								.append(tempI.name)

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/scope/JavaSourceStatementScope.java

 import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
+import org.openzen.zenscript.codemodel.statement.VariableID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.formattershared.ExpressionString;
 		if (!shouldHoist)
 			return expression;
 		
-		VarStatement temp = new VarStatement(expression.position, createTempVariable(), expression.type, expression, true);
+		VarStatement temp = new VarStatement(expression.position, new VariableID(), createTempVariable(), expression.type, expression, true);
 		new JavaSourceStatementFormatter(this).formatVar(target, temp);
 		return new GetLocalVariableExpression(expression.position, temp);
 	}

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

 		compiled.setCode(body.compile(innerScope, compiled.header));
 		
 		if (compiled.header.getReturnType().isBasic(BasicTypeID.UNDETERMINED))
-			compiled.header.setReturnType(compiled.statement.getReturnType());
+			compiled.header.setReturnType(compiled.caller.body.getReturnType());
 	}
 
 	@Override

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

 package org.openzen.zenscript.parser.definitions;
 
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
 	
 	public void compileInitializer(BaseScope scope, PrecompilationState state) {
 		if (defaultValue != null) {
-			compiled.defaultValue = defaultValue.compile(new ExpressionScope(scope, compiled.type)).eval();
+			try {
+				compiled.defaultValue = defaultValue.compile(new ExpressionScope(scope, compiled.type)).eval();
+			} catch (CompileException ex) {
+				compiled.defaultValue = new InvalidExpression(compiled.type, ex);
+			}
 		}
 	}
 }

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

 		
 		int ordinal = 0;
 		while (!tokens.isNext(ZSTokenType.T_ACLOSE) && !tokens.isNext(ZSTokenType.T_SEMICOLON)) {
+			CodePosition optionPosition = tokens.getPosition();
 			String optionName = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 			List<IParsedType> types = new ArrayList<>();
 			if (tokens.optional(ZSTokenType.T_BROPEN) != null) {
 				}
 				tokens.required(ZSTokenType.T_BRCLOSE, ") expected");
 			}
-			result.addVariant(new ParsedVariantOption(optionName, ordinal++, types));
+			result.addVariant(new ParsedVariantOption(optionPosition, optionName, ordinal++, types));
 			if (tokens.optional(ZSTokenType.T_COMMA) == null)
 				break;
 		}

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

 package org.openzen.zenscript.parser.definitions;
 
 import java.util.List;
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.type.StoredType;
  * @author Hoofdgebruiker
  */
 public class ParsedVariantOption {
+	public final CodePosition position;
 	public final String name;
 	public final int ordinal;
 	public final List<IParsedType> types;
 	
-	public ParsedVariantOption(String name, int ordinal, List<IParsedType> types) {
+	public ParsedVariantOption(CodePosition position, String name, int ordinal, List<IParsedType> types) {
+		this.position = position;
 		this.name = name;
 		this.ordinal = ordinal;
 		this.types = types;
 		for (int i = 0; i < cTypes.length; i++)
 			cTypes[i] = types.get(i).compile(context);
 		
-		return new VariantDefinition.Option(variant, name, ordinal, cTypes);
+		return new VariantDefinition.Option(position, variant, name, ordinal, cTypes);
 	}
 }

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

 		return new CallArguments(typeArguments2, cArguments);
 	}
 	
-	private CallArguments compileCallNaive(CodePosition position, ExpressionScope scope) {
+	private CallArguments compileCallNaive(CodePosition position, ExpressionScope scope) throws CompileException {
 		Expression[] cArguments = new Expression[arguments.size()];
 		for (int i = 0; i < cArguments.length; i++) {
 			IPartialExpression cArgument = arguments.get(i).compile(scope);

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

  */
 package org.openzen.zenscript.parser.expression;
 
-import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
-import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
+import org.openzen.zenscript.codemodel.scope.BaseScope.DollarEvaluator;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
  *
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
-		Function<CodePosition, Expression> dollar = scope.getDollar();
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
+		DollarEvaluator dollar = scope.getDollar();
 		if (dollar == null)
-			return new InvalidExpression(
+			throw new CompileException(
 					position,
-					scope.hints.isEmpty() ? BasicTypeID.UNDETERMINED.stored : scope.hints.get(0),
 					CompileExceptionCode.NO_DOLLAR_HERE,
 					"No dollar expression available in this context");
 		

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

 	 * @param scope
 	 * @return 
 	 */
-	public abstract IPartialExpression compile(ExpressionScope scope);
+	public abstract IPartialExpression compile(ExpressionScope scope) throws CompileException;
 
-	public Expression compileKey(ExpressionScope scope) {
+	public Expression compileKey(ExpressionScope scope) throws CompileException {
 		return compile(scope).eval();
 	}
 	

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

 package org.openzen.zenscript.parser.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.expression.AndAndExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		Expression left = this.left.compile(scope).eval();
 		Expression right = this.right.compile(scope).eval();
 		
 		StoredType resultType = scope.getTypeMembers(left.type).union(right.type);
 		if (resultType == null)
-			return new InvalidExpression(position, CompileExceptionCode.TYPE_CANNOT_UNITE, "These types could not be unified: " + left.type + " and " + right.type);
+			throw new CompileException(position, CompileExceptionCode.TYPE_CANNOT_UNITE, "These types could not be unified: " + left.type + " and " + right.type);
 		
 		left = left.castImplicit(position, scope, resultType);
 		right = right.castImplicit(position, scope, resultType);

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

 
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.expression.ArrayExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		StoredType asBaseType = null;
 		StoredType asType = null;
 		boolean couldHintType = false;
 			for (int i = 0; i < contents.size(); i++)
 				cContents[i] = contents.get(i).compile(contentScope).eval().castImplicit(position, scope, asBaseType);
 		} else if (contents.isEmpty()) {
-			return new InvalidExpression(position, CompileExceptionCode.UNTYPED_EMPTY_ARRAY, "Empty array with unknown type");
+			throw new CompileException(position, CompileExceptionCode.UNTYPED_EMPTY_ARRAY, "Empty array with unknown type");
 		} else {
 			ExpressionScope contentScope = scope.withoutHints();
 			StoredType resultType = null;
 			for (int i = 0; i < contents.size(); i++) {
 				cContents[i] = contents.get(i).compileKey(contentScope).eval();
-				resultType = resultType == null ? cContents[i].type : scope.getTypeMembers(resultType).union(cContents[i].type);
+				StoredType joinedType = resultType == null ? cContents[i].type : scope.getTypeMembers(resultType).union(cContents[i].type);
+				if (joinedType == null)
+					throw new CompileException(position, CompileExceptionCode.TYPE_CANNOT_UNITE, "Could not combine " + resultType + " with " + cContents[i].type);
+				
+				resultType = joinedType;
 			}
 			for (int i = 0; i < contents.size(); i++)
 				cContents[i] = cContents[i].castImplicit(position, scope, resultType);
 	}
 
 	@Override
-	public Expression compileKey(ExpressionScope scope) {
+	public Expression compileKey(ExpressionScope scope) throws CompileException {
 		if (contents.size() == 1) {
 			return contents.get(0).compile(scope).eval();
 		} else {

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

 
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		IPartialExpression cLeft = left.compile(scope);
 		List<StoredType> resultHints = cLeft.getAssignHints();
 		

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

 package org.openzen.zenscript.parser.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		Expression cLeft = left.compile(scope).eval();
 		TypeMemberGroup members = scope.getTypeMembers(cLeft.type).getOrCreateGroup(this.operator);
 		ExpressionScope innerScope = scope.withHints(members.predictCallTypes(scope, scope.getResultTypeHints(), 1)[0]);

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

 import java.util.ArrayList;
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
-import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.lexer.ParseException;
 	}
 	
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		if (expressions.size() != 1) {
-			return new InvalidExpression(position, CompileExceptionCode.BRACKET_MULTIPLE_EXPRESSIONS, "Bracket expression may have only one expression");
+			throw new CompileException(position, CompileExceptionCode.BRACKET_MULTIPLE_EXPRESSIONS, "Bracket expression may have only one expression");
 		} else {
 			return expressions.get(0).compile(scope);
 		}

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

 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		if (receiver instanceof ParsedExpressionVariable) {
 			ParsedExpressionVariable variable = (ParsedExpressionVariable) receiver;
 			for (StoredType hint : scope.hints) {
 			}
 		}
 		
-		try {
-			if (receiver instanceof ParsedExpressionSuper) {
-				// super call (intended as first call in constructor)
-				StoredType targetType = scope.getThisType().getSuperType(scope.getTypeRegistry());
-				if (targetType == null)
-					return new InvalidExpression(position, CompileExceptionCode.SUPER_CALL_NO_SUPERCLASS, "Class has no superclass");
+		if (receiver instanceof ParsedExpressionSuper) {
+			// super call (intended as first call in constructor)
+			StoredType targetType = scope.getThisType().getSuperType(scope.getTypeRegistry());
+			if (targetType == null)
+				throw new CompileException(position, CompileExceptionCode.SUPER_CALL_NO_SUPERCLASS, "Class has no superclass");
 
-				TypeMemberGroup memberGroup = scope.getTypeMembers(targetType).getOrCreateGroup(OperatorType.CONSTRUCTOR);
-				CallArguments callArguments = arguments.compileCall(position, scope, null, memberGroup);
-				FunctionalMemberRef member = memberGroup.selectMethod(position, scope, callArguments, true, true);
-				if (!member.isConstructor())
-					return new InvalidExpression(position, CompileExceptionCode.INTERNAL_ERROR, "Constructor is not a constructor!");
+			TypeMemberGroup memberGroup = scope.getTypeMembers(targetType).getOrCreateGroup(OperatorType.CONSTRUCTOR);
+			CallArguments callArguments = arguments.compileCall(position, scope, null, memberGroup);
+			FunctionalMemberRef member = memberGroup.selectMethod(position, scope, callArguments, true, true);
+			if (!member.isConstructor())
+				throw new CompileException(position, CompileExceptionCode.INTERNAL_ERROR, "Constructor is not a constructor!");
 
-				return new ConstructorSuperCallExpression(position, targetType, member, callArguments);
-			} else if (receiver instanceof ParsedExpressionThis) {
-				// this call (intended as first call in constructor)
-				StoredType targetType = scope.getThisType();
+			return new ConstructorSuperCallExpression(position, targetType, member, callArguments);
+		} else if (receiver instanceof ParsedExpressionThis) {
+			// this call (intended as first call in constructor)
+			StoredType targetType = scope.getThisType();
 
-				TypeMemberGroup memberGroup = scope.getTypeMembers(targetType).getOrCreateGroup(OperatorType.CONSTRUCTOR);
-				CallArguments callArguments = arguments.compileCall(position, scope, null, memberGroup);
-				FunctionalMemberRef member = memberGroup.selectMethod(position, scope, callArguments, true, true);
-				if (!member.isConstructor())
-					return new InvalidExpression(position, CompileExceptionCode.INTERNAL_ERROR, "Constructor is not a constructor!");
+			TypeMemberGroup memberGroup = scope.getTypeMembers(targetType).getOrCreateGroup(OperatorType.CONSTRUCTOR);
+			CallArguments callArguments = arguments.compileCall(position, scope, null, memberGroup);
+			FunctionalMemberRef member = memberGroup.selectMethod(position, scope, callArguments, true, true);
+			if (!member.isConstructor())
+				throw new CompileException(position, CompileExceptionCode.INTERNAL_ERROR, "Constructor is not a constructor!");
 
-				return new ConstructorThisCallExpression(position, scope.getThisType(), member, callArguments);
-			}
-
-			IPartialExpression cReceiver = receiver.compile(scope.withoutHints());
-			List<FunctionHeader> headers = cReceiver.getPossibleFunctionHeaders(scope, scope.hints, arguments.arguments.size());
-			CallArguments callArguments = arguments.compileCall(position, scope, cReceiver.getGenericCallTypes(), headers);
-			return cReceiver.call(position, scope, scope.hints, callArguments);
-		} catch (CompileException ex) {
-			return new InvalidExpression(BasicTypeID.UNDETERMINED.stored, ex);
+			return new ConstructorThisCallExpression(position, scope.getThisType(), member, callArguments);
 		}
+
+		IPartialExpression cReceiver = receiver.compile(scope.withoutHints());
+		List<FunctionHeader> headers = cReceiver.getPossibleFunctionHeaders(scope, scope.hints, arguments.arguments.size());
+		CallArguments callArguments = arguments.compileCall(position, scope, cReceiver.getGenericCallTypes(), headers);
+		return cReceiver.call(position, scope, scope.hints, callArguments);
 	}
 	
 	@Override

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

 package org.openzen.zenscript.parser.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		StoredType type = this.type.compile(scope);
 		return value.compile(scope.withHint(type))
 				.eval()

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

 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		Expression cLeft = left.compile(scope).eval();
 		StoredType cLeftType = cLeft.type;
 		if (!cLeftType.isOptional())

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

 package org.openzen.zenscript.parser.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		Expression cLeft = left.compile(scope.withoutHints()).eval();
 		Expression cRight = right.compile(scope.withHint(cLeft.type)).eval();
 		return scope.getTypeMembers(cLeft.type).compare(position, scope, type, cLeft, cRight);

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

 package org.openzen.zenscript.parser.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.expression.ConditionalExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		Expression cIfThen = ifThen.compile(scope).eval();
 		Expression cIfElse = ifElse.compile(scope).eval();
 		
 		for (StoredType hint : scope.hints) {
 			if (thenMembers.canCastImplicit(hint) && elseMembers.canCastImplicit(hint)) {
 				if (resultType != null)
-					return new InvalidExpression(position, CompileExceptionCode.MULTIPLE_MATCHING_HINTS, "Not sure which type to use");
+					throw new CompileException(position, CompileExceptionCode.MULTIPLE_MATCHING_HINTS, "Not sure which type to use");
 				
 				resultType = hint;
 			}
 			resultType = thenMembers.union(cIfElse.type);
 		
 		if (resultType == null)
-			return new InvalidExpression(position, CompileExceptionCode.TYPE_CANNOT_UNITE, "These types could not be unified: " + cIfThen.type + " and " + cIfElse.type);
+			throw new CompileException(position, CompileExceptionCode.TYPE_CANNOT_UNITE, "These types could not be unified: " + cIfThen.type + " and " + cIfElse.type);
 		
 		cIfThen = cIfThen.castImplicit(position, scope, resultType);
 		cIfElse = cIfElse.castImplicit(position, scope, resultType);

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

 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		if (scope.hints.isEmpty())
 			return new ConstantDoubleExpression(position, value);
 		
 				types.append(scope.hints.get(i).toString());
 			}
 
-			return new InvalidExpression(position, CompileExceptionCode.INVALID_CAST, "Cannot cast a floating-point value to any of these types: " + types);
+			throw new CompileException(position, CompileExceptionCode.INVALID_CAST, "Cannot cast a floating-point value to any of these types: " + types);
 		} else {
-			return new InvalidExpression(position, CompileExceptionCode.INVALID_SUFFIX, "Invalid suffix: " + suffix);
+			throw new CompileException(position, CompileExceptionCode.INVALID_SUFFIX, "Invalid suffix: " + suffix);
 		}
 	}
 

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

 
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
-import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.SharedStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 import org.openzen.zenscript.parser.statements.ParsedFunctionBody;
 
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		FunctionHeader definedHeader = header.compile(scope);
 		FunctionHeader header = definedHeader;
+		StorageTag storage = SharedStorageTag.INSTANCE;
 		for (StoredType hint : scope.hints) {
 			if (hint.getNormalized().type instanceof FunctionTypeID) {
 				FunctionTypeID functionHint = (FunctionTypeID) hint.getNormalized().type;
 						return new InvalidExpression(position, hint, CompileExceptionCode.MULTIPLE_MATCHING_HINTS, "Ambiguity trying to resolve function types, can't decide for the type");
 					
 					header = functionHint.header.forLambda(definedHeader);
+					storage = hint.storage;
 				}
 			}
 		}
 		StatementScope innerScope = new LambdaScope(scope, closure, header);
 		Statement statements = body.compile(innerScope, header);
 		
-		if (header.getReturnType().isBasic(BasicTypeID.UNDETERMINED)) {
+		if (header.getReturnType().isBasic(BasicTypeID.UNDETERMINED))
 			header.setReturnType(statements.getReturnType());
-		}
+		
 		if (!scope.genericInferenceMap.isEmpty()) {
 			// perform type parameter inference
 			StoredType returnType = statements.getReturnType();
 			Map<TypeParameter, TypeID> inferredTypes = returnType.type.inferTypeParameters(scope.getMemberCache(), genericHeader.getReturnType().type);
 			if (inferredTypes == null)
-				return new InvalidExpression(position, CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE, "Could not infer generic type parameters");
+				throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE, "Could not infer generic type parameters");
 			
 			scope.genericInferenceMap.putAll(inferredTypes);
 		}
 		
 		StoredType functionType = scope.getTypeRegistry()
 				.getFunction(genericHeader.withGenericArguments(scope.getTypeRegistry(), new GenericMapper(scope.getTypeRegistry(), scope.genericInferenceMap)))
-				.stored(UniqueStorageTag.INSTANCE);
+				.stored(storage);
 		return new FunctionExpression(position, functionType, closure, header, statements);
 	}
 	

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

 
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		return new PartialIndexedExpression(scope);
 	}
 
 		private final ExpressionScope scope;
 		private final Expression target;
 		
-		private PartialIndexedExpression(ExpressionScope scope) {
+		private PartialIndexedExpression(ExpressionScope scope) throws CompileException {
 			this.scope = scope;
 			target = value.compile(scope.withoutHints()).eval();
 		}
 		
 		@Override
-		public Expression eval() {
+		public Expression eval() throws CompileException {
 			TypeMemberGroup members = scope.getTypeMembers(target.type).getOrCreateGroup(OperatorType.INDEXGET);
 			List<StoredType>[] predictedTypes = members.predictCallTypes(scope, scope.hints, indexes.size());
 			Expression[] arguments = new Expression[indexes.size()];
 		}
 
 		@Override
-		public List<StoredType>[] predictCallTypes(TypeScope scope, List<StoredType> hints, int arguments) {
+		public List<StoredType>[] predictCallTypes(TypeScope scope, List<StoredType> hints, int arguments) throws CompileException {
 			return eval().predictCallTypes(scope, hints, arguments);
 		}
 		
 		@Override
-		public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) {
+		public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) throws CompileException {
 			return eval().getPossibleFunctionHeaders(scope, hints, arguments);
 		}
 
 		@Override
-		public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) {
+		public IPartialExpression getMember(CodePosition position, TypeScope scope, List<StoredType> hints, GenericName name) throws CompileException {
 			return eval().getMember(position, scope, hints, name);
 		}
 
 		@Override
-		public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) {
+		public Expression call(CodePosition position, TypeScope scope, List<StoredType> hints, CallArguments arguments) throws CompileException {
 			return eval().call(position, scope, hints, arguments);
 		}
 		
 		@Override
-		public Expression assign(CodePosition position, TypeScope scope, Expression value) {
+		public Expression assign(CodePosition position, TypeScope scope, Expression value) throws CompileException {
 			TypeMemberGroup members = scope.getTypeMembers(target.type).getOrCreateGroup(OperatorType.INDEXSET);
 			List<StoredType>[] predictedTypes = members.predictCallTypes(scope, this.scope.hints, indexes.size() + 1);
 			
 			return predictedTypes[indexes.size()];
 		}
 		
-		private Expression getLength(CodePosition position) {
+		private Expression getLength(CodePosition position) throws CompileException {
 			return target.getMember(position, scope, scope.hints, new GenericName("length")).eval();
 		}
 

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

 	}
 	
 	@Override
-	public Expression compile(ExpressionScope scope) {
+	public Expression compile(ExpressionScope scope) throws CompileException {
 		if (suffix.equals("L") || suffix.equals("l"))
 			return new ConstantLongExpression(position, value);
 		if (suffix.equals("UL") || suffix.equals("ul"))
 			else
 				return new ConstantLongExpression(position, value);
 		} else {
-			return new InvalidExpression(position, CompileExceptionCode.INVALID_SUFFIX, "Invalid suffix: " + suffix);
+			throw new CompileException(position, CompileExceptionCode.INVALID_SUFFIX, "Invalid suffix: " + suffix);
 		}
 	}
 	

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

 package org.openzen.zenscript.parser.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.IsExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		TypeID isType = type.compileUnstored(scope);
 		Expression expression = this.expression.compile(scope.withHint(isType.stored(BorrowStorageTag.INVOCATION))).eval();
 		return new IsExpression(position, expression, isType);

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

 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		StoredType usedHint = null;
 		List<StoredType> keyHints = new ArrayList<>();
 		List<StoredType> valueHints = new ArrayList<>();
 		}
 		
 		if (keys.isEmpty() && keyHints.size() == 1) {
-			try {
-				FunctionalMemberRef constructor = scope
-							.getTypeMembers(usedHint)
-							.getOrCreateGroup(OperatorType.CONSTRUCTOR)
-							.selectMethod(position, scope, CallArguments.EMPTY, true, true);
-					return new NewExpression(position, usedHint, constructor, CallArguments.EMPTY);
-			} catch (CompileException ex) {
-				return new InvalidExpression(ex.position, ex.code, ex.getMessage());
-			}
+			FunctionalMemberRef constructor = scope
+					.getTypeMembers(usedHint)
+					.getOrCreateGroup(OperatorType.CONSTRUCTOR)
+					.selectMethod(position, scope, CallArguments.EMPTY, true, true);
+			return new NewExpression(position, usedHint, constructor, CallArguments.EMPTY);
 		}
 		
 		if (!hasAssocHint && scope.hints.size() == 1) {
 			StoredType hint = scope.hints.get(0);
 			for (int i = 0; i < keys.size(); i++) {
 				if (keys.get(i) != null)
-					return new InvalidExpression(position, CompileExceptionCode.UNSUPPORTED_NAMED_ARGUMENTS, "Named constructor arguments not yet supported");
+					throw new CompileException(position, CompileExceptionCode.UNSUPPORTED_NAMED_ARGUMENTS, "Named constructor arguments not yet supported");
 			}
 			ParsedCallArguments arguments = new ParsedCallArguments(null, values);
 			return ParsedNewExpression.compile(position, hint, arguments, scope);
 
 		for (int i = 0; i < keys.size(); i++) {
 			if (keys.get(i) == null)
-				return new InvalidExpression(position, CompileExceptionCode.MISSING_MAP_KEY, "Missing key");
+				throw new CompileException(position, CompileExceptionCode.MISSING_MAP_KEY, "Missing key");
 			
 			cKeys[i] = keys.get(i).compileKey(scope.withHints(keyHints));
 			cValues[i] = values.get(i).compile(scope.withHints(valueHints)).eval();
 			}
 		}
 		if (keyType == null)
-			return new InvalidExpression(position, CompileExceptionCode.UNTYPED_EMPTY_MAP, "Empty map without known type");
+			throw new CompileException(position, CompileExceptionCode.UNTYPED_EMPTY_MAP, "Empty map without known type");
 		
 		for (int i = 0; i < cKeys.length; i++)
 			cKeys[i] = cKeys[i].castImplicit(position, scope, keyType);
 			}
 		}
 		if (valueType == null)
-			return new InvalidExpression(position, CompileExceptionCode.UNTYPED_EMPTY_MAP, "Empty map without known type");
+			throw new CompileException(position, CompileExceptionCode.UNTYPED_EMPTY_MAP, "Empty map without known type");
 		
 		for (int i = 0; i < cValues.length; i++)
 			cValues[i] = cValues[i].castImplicit(position, scope, valueType);

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

 
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
-import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		IPartialExpression cValue = value.compile(scope.withoutHints());
 		TypeID[] typeParameters = IParsedType.compileList(genericParameters, scope);
 		IPartialExpression member = cValue.getMember(
 				scope.hints,
 				new GenericName(this.member, typeParameters));
 		if (member == null)
-			return new InvalidExpression(position, CompileExceptionCode.NO_SUCH_MEMBER, "Member not found: " + this.member);
+			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Member not found: " + this.member);
 		
 		return member;
 	}

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

 package org.openzen.zenscript.parser.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberGroup;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
-import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		Expression cLeft = left.compile(scope).eval();
 		TypeMembers typeMembers = scope.getTypeMembers(cLeft.type);
 		TypeMemberGroup members = typeMembers.getOrCreateGroup(operator);

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

 package org.openzen.zenscript.parser.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.OrOrExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		Expression cLeft = left.compile(scope.withHints(BasicTypeID.HINT_BOOL)).eval().castImplicit(position, scope, BasicTypeID.BOOL.stored);
 		Expression cRight = right.compile(scope.withHints(BasicTypeID.HINT_BOOL)).eval().castImplicit(position, scope, BasicTypeID.BOOL.stored);
 		return new OrOrExpression(position, cLeft, cRight);

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

 package org.openzen.zenscript.parser.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
-import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		StoredType thisType = scope.getThisType();
 		if (thisType == null || !(thisType.type instanceof DefinitionTypeID))
-			return new InvalidExpression(position, CompileExceptionCode.USING_THIS_OUTSIDE_TYPE, "Not in a type");
+			throw new CompileException(position, CompileExceptionCode.USING_THIS_OUTSIDE_TYPE, "Not in a type");
 		
 		return scope.getOuterInstance(position);
 	}

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

 package org.openzen.zenscript.parser.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		Expression cValue = value.compile(scope).eval();
 		return scope.getTypeMembers(cValue.type).getOrCreateGroup(operator).callPostfix(position, scope, cValue);
 	}

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionRange.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.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.RangeExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		List<StoredType> fromHints = new ArrayList<>();
 		List<StoredType> toHints = new ArrayList<>();
 		

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

 package org.openzen.zenscript.parser.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		Expression cLeft = left.compile(scope.withoutHints()).eval();
 		Expression cRight = right.compile(scope.withHint(cLeft.type)).eval();
 		return scope.getTypeMembers(cLeft.type)

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

 
 	@Override
 	public IPartialExpression compile(ExpressionScope scope) {
-		if (value.length() == 1) {
-			if (scope.hints.contains(BasicTypeID.CHAR)) {
-				return new ConstantCharExpression(position, value.charAt(0));
-			} else {
-				for (StoredType type : scope.hints)
-					if (type.type instanceof StringTypeID)
-						return new ConstantStringExpression(position, value);
-				
-				return new ConstantCharExpression(position, value.charAt(0));
-			}
-		}
+		if (value.length() == 1 && 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/ParsedExpressionSuper.java

 	}
 	
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		StoredType type = scope.getThisType();
 		StoredType targetType = type.getSuperType(scope.getTypeRegistry());
 		if (targetType == null)
-			return new InvalidExpression(position, CompileExceptionCode.SUPER_CALL_NO_SUPERCLASS, "Type has no superclass");
+			throw new CompileException(position, CompileExceptionCode.SUPER_CALL_NO_SUPERCLASS, "Type has no superclass");
 		
 		return new PartialTypeExpression(position, targetType.type, null);
 	}

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

 package org.openzen.zenscript.parser.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		Expression cValue = value.compile(scope).eval();
 		return scope.getTypeMembers(cValue.type)
 				.unary(position, scope, operator, cValue);

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

 import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
 import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
 import org.openzen.zenscript.codemodel.expression.switchvalue.EnumConstantSwitchValue;
 import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		TypeID[] genericArguments = TypeID.NONE;
 		if (genericParameters != null) {
 			genericArguments = new TypeID[genericParameters.size()];
 					return new VariantValueExpression(position, hint, option);
 			}
 			
-			return new InvalidExpression(position, CompileExceptionCode.UNDEFINED_VARIABLE, "No such symbol: " + name);
+			throw new CompileException(position, CompileExceptionCode.UNDEFINED_VARIABLE, "No such symbol: " + name);
 		} else {
 			return result;
 		}

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

 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.expression.MatchExpression;
 import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
 import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
-		try {
-			Expression cValue = value.compile(scope).eval();
-			MatchExpression.Case[] cCases = new MatchExpression.Case[cases.size()];
-			for (int i = 0; i < cases.size(); i++) {
-				Case matchCase = cases.get(i);
-				cCases[i] = matchCase.compile(cValue.type, scope);
-			}
-
-			StoredType result = cCases[0].value.type;
-			for (int i = 1; i < cCases.length; i++) {
-				StoredType oldResult = result;
-				result = scope.getTypeMembers(result).union(cCases[i].value.type);
-				if (result == null)
-					return new InvalidExpression(position, CompileExceptionCode.TYPE_CANNOT_UNITE, "Matches have different types: " + oldResult + " and " + cCases[i].value.type);
-			}
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
+		Expression cValue = value.compile(scope).eval();
+		MatchExpression.Case[] cCases = new MatchExpression.Case[cases.size()];
+		for (int i = 0; i < cases.size(); i++) {
+			Case matchCase = cases.get(i);
+			cCases[i] = matchCase.compile(cValue.type, scope);
+		}
 
-			return new MatchExpression(position, cValue, result, cCases);
-		} catch (CompileException ex) {
-			return new InvalidExpression(BasicTypeID.UNDETERMINED.stored, ex);
+		StoredType result = cCases[0].value.type;
+		for (int i = 1; i < cCases.length; i++) {
+			StoredType oldResult = result;
+			result = scope.getTypeMembers(result).union(cCases[i].value.type);
+			if (result == null)
+				throw new CompileException(position, CompileExceptionCode.TYPE_CANNOT_UNITE, "Matches have different types: " + oldResult + " and " + cCases[i].value.type);
 		}
+
+		return new MatchExpression(position, cValue, result, cCases);
 	}
 
 	@Override

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

 package org.openzen.zenscript.parser.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.expression.PanicExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 	}
 	
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		return new PanicExpression(position, scope.getResultTypeHints().isEmpty() ? BasicTypeID.VOID.stored : scope.getResultTypeHints().get(0), value.compile(scope).eval());
 	}
 

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

 package org.openzen.zenscript.parser.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ThrowExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		Expression cValue = value.compile(scope).eval();
 		StoredType resultType = BasicTypeID.VOID.stored;
 		if (scope.getResultTypeHints().size() == 1)

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

 package org.openzen.zenscript.parser.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		Expression cValue = value.compile(scope).eval();
 		if (scope.getFunctionHeader() == null)
-			return new InvalidExpression(position, CompileExceptionCode.TRY_CONVERT_OUTSIDE_FUNCTION, "try? can only be used inside functions");
+			throw new CompileException(position, CompileExceptionCode.TRY_CONVERT_OUTSIDE_FUNCTION, "try? can only be used inside functions");
 		
 		HighLevelDefinition result = scope.getTypeRegistry().stdlib.getDefinition("Result");
 		if (cValue.thrownType != null) {
 			DefinitionTypeID resultType = scope.getTypeRegistry().getForDefinition(result, cValue.type.type, cValue.thrownType.type);
 			return new TryConvertExpression(position, resultType.stored(cValue.type.storage), cValue);
 		} else {
-			return new InvalidExpression(position, CompileExceptionCode.TRY_CONVERT_ILLEGAL_TARGET, "try? can only be used on expressions that throw");
+			throw new CompileException(position, CompileExceptionCode.TRY_CONVERT_ILLEGAL_TARGET, "try? can only be used on expressions that throw");
 		}
 	}
 

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

 package org.openzen.zenscript.parser.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.expression.TryRethrowAsExceptionExpression;
 import org.openzen.zenscript.codemodel.expression.TryRethrowAsResultExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		HighLevelDefinition result = scope.getTypeRegistry().stdlib.getDefinition("Result");
 		
 		Expression cSource = source.compile(scope).eval();
 			}
 			
 			if (scope.getFunctionHeader() == null)
-				return new InvalidExpression(position, CompileExceptionCode.TRY_RETHROW_NOT_A_RESULT, "type is not a Result type, cannot convert");
+				throw new CompileException(position, CompileExceptionCode.TRY_RETHROW_NOT_A_RESULT, "type is not a Result type, cannot convert");
 			
-			return new InvalidExpression(position, CompileExceptionCode.TRY_RETHROW_NOT_A_RESULT, "this expression doesn't throw an exception nor returns a result");
+			throw new CompileException(position, CompileExceptionCode.TRY_RETHROW_NOT_A_RESULT, "this expression doesn't throw an exception nor returns a result");
 		}
 	}
 

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedCatchClause.java

 package org.openzen.zenscript.parser.statements;
 
 import java.util.List;
-import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.CatchClause;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.statement.VariableID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 	}
 	
 	public CatchClause compile(StatementScope scope) {
-		VarStatement exceptionVariable = new VarStatement(position, exceptionName, exceptionType.compile(scope), null, true);
+		VarStatement exceptionVariable = new VarStatement(position, new VariableID(), exceptionName, exceptionType.compile(scope), null, true);
 		CatchScope localScope = new CatchScope(scope, exceptionVariable);
 		return new CatchClause(position, exceptionVariable, content.compile(localScope));
 	}
 		}
 	
 		@Override
-		public IPartialExpression get(CodePosition position, GenericName name) {
+		public IPartialExpression get(CodePosition position, GenericName name) throws CompileException {
 			if (name.hasNoArguments() && exceptionVariable.name.equals(name.name))
 				return new GetLocalVariableExpression(position, exceptionVariable);
 
 		}
 
 		@Override
-		public Function<CodePosition, Expression> getDollar() {
+		public DollarEvaluator getDollar() {
 			return outer.getDollar();
 		}
 
 		@Override
-		public IPartialExpression getOuterInstance(CodePosition position) {
+		public IPartialExpression getOuterInstance(CodePosition position) throws CompileException {
 			return outer.getOuterInstance(position);
 		}
 

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedLambdaFunctionBody.java

  */
 package org.openzen.zenscript.parser.statements;
 
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.statement.InvalidStatement;
 import org.openzen.zenscript.parser.expression.ParsedExpression;
 
 /**
 	
 	@Override
 	public Statement compile(StatementScope scope, FunctionHeader header) {
-		if (header.getReturnType().isBasic(BasicTypeID.VOID)) {
-			Expression value = this.value.compile(new ExpressionScope(scope)).eval();
-			return new ExpressionStatement(value.position, value);
-		} else {
-			Expression returnValue = value
-					.compile(new ExpressionScope(scope, header.getReturnType()))
-					.eval()
-					.castImplicit(value.position, scope, header.getReturnType());
-			return new ReturnStatement(value.position, returnValue);
+		try {
+			if (header.getReturnType().isBasic(BasicTypeID.VOID)) {
+				Expression value = this.value.compile(new ExpressionScope(scope)).eval();
+				return new ExpressionStatement(value.position, value);
+			} else {
+				Expression returnValue = value
+						.compile(new ExpressionScope(scope, header.getReturnType()))
+						.eval()
+						.castImplicit(value.position, scope, header.getReturnType());
+				return new ReturnStatement(value.position, returnValue);
+			}
+		} catch (CompileException ex) {
+			return new InvalidStatement(ex);
 		}
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedStatementDoWhile.java

 package org.openzen.zenscript.parser.statements;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.statement.DoWhileStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 	@Override
 	public Statement compile(StatementScope scope) {
-		Expression condition = this.condition
+		Expression condition;
+		try {
+			condition = this.condition
 				.compile(new ExpressionScope(scope, BasicTypeID.HINT_BOOL))
 				.eval()
 				.castImplicit(position, scope, BasicTypeID.BOOL.stored);
+		} catch (CompileException ex) {
+			condition = new InvalidExpression(BasicTypeID.BOOL.stored, ex);
+		}
 		
 		DoWhileStatement result = new DoWhileStatement(position, label, condition);
 		LoopScope innerScope = new LoopScope(result, scope);

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedStatementExpression.java

 package org.openzen.zenscript.parser.statements;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.statement.InvalidStatement;
 import org.openzen.zenscript.parser.ParsedAnnotation;
-import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.expression.ParsedExpression;
 
 public class ParsedStatementExpression extends ParsedStatement {
 
 	@Override
 	public Statement compile(StatementScope scope) {
-		return result(new ExpressionStatement(position, this.expression.compile(new ExpressionScope(scope)).eval()), scope);
+		try {
+			return result(new ExpressionStatement(position, this.expression.compile(new ExpressionScope(scope)).eval()), scope);
+		} catch (CompileException ex) {
+			return result(new InvalidStatement(ex), scope);
+		}
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedStatementForeach.java

 package org.openzen.zenscript.parser.statements;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.scope.ForeachScope;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
 import org.openzen.zenscript.codemodel.statement.InvalidStatement;
+import org.openzen.zenscript.codemodel.statement.VariableID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.expression.ParsedExpression;
 
 	@Override
 	public Statement compile(StatementScope scope) {
-		Expression list = this.list.compile(new ExpressionScope(scope)).eval();
-		
-		TypeMembers members = scope.getTypeMembers(list.type);
-		IteratorMemberRef iterator = members.getIterator(varnames.length);
-		if (iterator == null)
-			return new InvalidStatement(position, CompileExceptionCode.NO_SUCH_ITERATOR, list.type + " doesn't have an iterator with " + varnames.length + " variables");
-		
-		StoredType[] loopTypes = iterator.types;
-		VarStatement[] variables = new VarStatement[varnames.length];
-		for (int i = 0; i < variables.length; i++)
-			variables[i] = new VarStatement(position, varnames[i], loopTypes[i], null, true);
-		
-		ForeachStatement statement = new ForeachStatement(position, variables, iterator, list);
-		ForeachScope innerScope = new ForeachScope(statement, scope);
-		statement.content = this.body.compile(innerScope);
-		return result(statement, scope);
+		try {
+			Expression list = this.list.compile(new ExpressionScope(scope)).eval();
+
+			TypeMembers members = scope.getTypeMembers(list.type);
+			IteratorMemberRef iterator = members.getIterator(varnames.length);
+			if (iterator == null)
+				return new InvalidStatement(position, CompileExceptionCode.NO_SUCH_ITERATOR, list.type + " doesn't have an iterator with " + varnames.length + " variables");
+
+			StoredType[] loopTypes = iterator.types;
+			VarStatement[] variables = new VarStatement[varnames.length];
+			for (int i = 0; i < variables.length; i++)
+				variables[i] = new VarStatement(position, new VariableID(), varnames[i], loopTypes[i], null, true);
+
+			ForeachStatement statement = new ForeachStatement(position, variables, iterator, list);
+			ForeachScope innerScope = new ForeachScope(statement, scope);
+			statement.content = this.body.compile(innerScope);
+			return result(statement, scope);
+		} catch (CompileException ex) {
+			return result(new InvalidStatement(ex), scope);
+		}
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedStatementIf.java

 package org.openzen.zenscript.parser.statements;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.statement.IfStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 	@Override
 	public Statement compile(StatementScope scope) {
-		Expression condition = this.condition.compile(new ExpressionScope(scope, BasicTypeID.HINT_BOOL)).eval();
+		Expression condition;
+		try {
+			condition = this.condition.compile(new ExpressionScope(scope, BasicTypeID.HINT_BOOL)).eval();
+		} catch (CompileException ex) {
+			condition = new InvalidExpression(BasicTypeID.BOOL.stored, ex);
+		}
+		
 		Statement onThen = this.onThen.compile(scope);
 		Statement onElse = this.onElse == null ? null : this.onElse.compile(scope);
  		return result(new IfStatement(position, condition, onThen, onElse), scope);

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedStatementLock.java

 package org.openzen.zenscript.parser.statements;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.statement.LockStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.statement.InvalidStatement;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.expression.ParsedExpression;
 
 
 	@Override
 	public Statement compile(StatementScope scope) {
-		Expression object = this.object.compile(new ExpressionScope(scope)).eval();
-		Statement content = this.content.compile(scope);
-		return result(new LockStatement(position, object, content), scope);
+		try {
+			Expression object = this.object.compile(new ExpressionScope(scope)).eval();
+			Statement content = this.content.compile(scope);
+			return result(new LockStatement(position, object, content), scope);
+		} catch (CompileException ex) {
+			return result(new InvalidStatement(ex), scope);
+		}
 	}
 }