- 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

@@ -5,9 +5,13 @@
  */
 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;
 
 /**
@@ -28,4 +32,12 @@ public class ScriptBlock extends Taggable {
 		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

@@ -9,6 +9,7 @@ import java.util.ArrayList;
 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;
@@ -83,19 +84,25 @@ public class PreconditionForMethod implements MemberAnnotation {
 		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

@@ -25,7 +25,6 @@ import org.openzen.zenscript.codemodel.type.storage.StaticStorageTag;
  */
 public class FunctionDefinition extends HighLevelDefinition {
 	public FunctionHeader header;
-	public Statement statement;
 	public CallerMember caller;
 	public final TypeMemberGroup callerGroup;
 	
@@ -46,7 +45,6 @@ public class FunctionDefinition extends HighLevelDefinition {
 	}
 	
 	public void setCode(Statement statement) {
-		this.statement = statement;
 		caller.setBody(statement);
 	}
 

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

@@ -45,12 +45,14 @@ public class VariantDefinition extends HighLevelDefinition {
 	}
 	
 	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

@@ -9,10 +9,10 @@ import java.util.HashMap;
 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;
@@ -50,13 +50,13 @@ public class ZSPackage {
 		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

@@ -11,6 +11,7 @@ import java.util.Objects;
 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;
@@ -116,7 +117,7 @@ public abstract class Expression implements IPartialExpression {
 	}
 	
 	@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

@@ -64,7 +64,7 @@ public class ExpressionBuilder {
 				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

@@ -9,7 +9,6 @@ import org.openzen.zencode.shared.CodePosition;
 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;
 
 /**
@@ -27,10 +26,6 @@ public class InvalidExpression extends Expression {
 		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

@@ -16,6 +16,7 @@ import org.openzen.zenscript.codemodel.statement.Statement;
 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;
 
@@ -65,7 +66,7 @@ public class MatchExpression extends Expression {
 	}
 	
 	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

@@ -7,6 +7,7 @@ package org.openzen.zenscript.codemodel.expression;
 
 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;
@@ -35,7 +36,7 @@ public class VariantValueExpression extends Expression {
 	}
 	
 	@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);
 		
@@ -62,7 +63,7 @@ public class VariantValueExpression extends Expression {
 	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

@@ -8,6 +8,7 @@ package org.openzen.zenscript.codemodel.partial;
 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;
@@ -29,15 +30,15 @@ public interface IPartialExpression {
 		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();
 	
@@ -50,11 +51,11 @@ public interface IPartialExpression {
 		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

@@ -7,6 +7,7 @@ package org.openzen.zenscript.codemodel.partial;
 
 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;
@@ -35,27 +36,27 @@ public class PartialGlobalExpression implements IPartialExpression {
 	}
 	
 	@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

@@ -68,7 +68,7 @@ public class PartialMemberGroupExpression implements IPartialExpression {
 	}
 
 	@Override
-	public Expression eval() {
+	public Expression eval() throws CompileException {
 		return group.getter(position, scope, target, allowStaticUsage);
 	}
 	
@@ -107,22 +107,22 @@ public class PartialMemberGroupExpression implements IPartialExpression {
 	}
 
 	@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

@@ -8,12 +8,12 @@ package org.openzen.zenscript.codemodel.partial;
 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;
@@ -33,8 +33,8 @@ public class PartialPackageExpression implements IPartialExpression {
 	}
 	
 	@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
@@ -48,13 +48,13 @@ public class PartialPackageExpression implements IPartialExpression {
 	}
 
 	@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

@@ -9,6 +9,7 @@ import java.util.Collections;
 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;
@@ -46,7 +47,7 @@ public class PartialStaticMemberGroupExpression implements IPartialExpression {
 	}
 	
 	@Override
-	public Expression eval() {
+	public Expression eval() throws CompileException {
 		return group.staticGetter(position, scope);
 	}
 
@@ -64,17 +65,17 @@ public class PartialStaticMemberGroupExpression implements IPartialExpression {
 	}
 
 	@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

@@ -8,6 +8,7 @@ package org.openzen.zenscript.codemodel.partial;
 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;
@@ -62,7 +63,7 @@ public class PartialTypeExpression implements IPartialExpression {
 	}
 
 	@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

@@ -9,6 +9,7 @@ import java.util.Arrays;
 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;
@@ -58,8 +59,8 @@ public class PartialVariantOptionExpression implements IPartialExpression {
 	}
 
 	@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

@@ -5,8 +5,8 @@
  */
 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;
@@ -21,7 +21,7 @@ import org.openzen.zenscript.codemodel.type.member.TypeMembers;
  * @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);
 	
@@ -37,7 +37,11 @@ public abstract class BaseScope implements TypeScope {
 		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

@@ -6,12 +6,11 @@
 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;
@@ -38,7 +37,7 @@ public class BlockScope extends StatementScope {
 	}
 	
 	@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;
@@ -72,12 +71,12 @@ public class BlockScope extends StatementScope {
 	}
 
 	@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

@@ -8,12 +8,11 @@ package org.openzen.zenscript.codemodel.scope;
 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;
@@ -47,7 +46,7 @@ public class CompileTypeScope extends BaseScope {
 	}
 
 	@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);
 
@@ -83,7 +82,7 @@ public class CompileTypeScope extends BaseScope {
 	}
 
 	@Override
-	public Function<CodePosition, Expression> getDollar() {
+	public DollarEvaluator getDollar() {
 		return outer.getDollar();
 	}
 

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

@@ -8,9 +8,9 @@ package org.openzen.zenscript.codemodel.scope;
 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;
 
@@ -19,7 +19,6 @@ import org.openzen.zenscript.codemodel.FunctionHeader;
 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;
@@ -93,7 +92,7 @@ public class DefinitionScope extends BaseScope {
 	}
 
 	@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);
@@ -150,14 +149,14 @@ public class DefinitionScope extends BaseScope {
 	}
 
 	@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

@@ -11,6 +11,7 @@ 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;
@@ -36,7 +37,7 @@ import org.openzen.zenscript.codemodel.type.TypeID;
  */
 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;
@@ -66,7 +67,7 @@ public class ExpressionScope extends BaseScope {
 	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;
@@ -100,7 +101,7 @@ public class ExpressionScope extends BaseScope {
 		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);
 	}
 	
@@ -121,7 +122,7 @@ public class ExpressionScope extends BaseScope {
 	}
 	
 	@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);
 		
@@ -154,12 +155,12 @@ public class ExpressionScope extends BaseScope {
 	}
 
 	@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

@@ -8,16 +8,14 @@ package org.openzen.zenscript.codemodel.scope;
 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;
@@ -114,13 +112,13 @@ public class FileScope extends BaseScope {
 	}
 
 	@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

@@ -6,12 +6,11 @@
 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;
@@ -43,7 +42,7 @@ public class ForeachScope extends StatementScope {
 	}
 
 	@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))
@@ -92,12 +91,12 @@ public class ForeachScope extends StatementScope {
 	}
 
 	@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

@@ -6,13 +6,12 @@
 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;
@@ -62,7 +61,7 @@ public class FunctionScope extends StatementScope {
 	}
 
 	@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;
@@ -110,7 +109,7 @@ public class FunctionScope extends StatementScope {
 	}
 
 	@Override
-	public Function<CodePosition, Expression> getDollar() {
+	public DollarEvaluator getDollar() {
 		for (FunctionParameter parameter : header.parameters)
 			if (parameter.name.equals("$"))
 				return position -> new GetFunctionParameterExpression(position, parameter);
@@ -119,7 +118,7 @@ public class FunctionScope extends StatementScope {
 	}
 	
 	@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

@@ -8,12 +8,11 @@ package org.openzen.zenscript.codemodel.scope;
 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;
@@ -47,7 +46,7 @@ public class GenericFunctionScope extends BaseScope {
 	}
 
 	@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);
 		
@@ -83,12 +82,12 @@ public class GenericFunctionScope extends BaseScope {
 	}
 
 	@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

@@ -6,12 +6,11 @@
 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;
@@ -38,7 +37,7 @@ public class GlobalScriptScope extends StatementScope {
 	}
 	
 	@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;
@@ -72,7 +71,7 @@ public class GlobalScriptScope extends StatementScope {
 	}
 
 	@Override
-	public Function<CodePosition, Expression> getDollar() {
+	public DollarEvaluator getDollar() {
 		return null; // script arguments?
 	}
 

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

@@ -6,12 +6,11 @@
 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;
@@ -49,7 +48,7 @@ public class ImplementationScope extends BaseScope {
 	}
 
 	@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))
@@ -92,7 +91,7 @@ public class ImplementationScope extends BaseScope {
 	}
 
 	@Override
-	public Function<CodePosition, Expression> getDollar() {
+	public DollarEvaluator getDollar() {
 		return outer.getDollar();
 	}
 

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

@@ -6,13 +6,12 @@
 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;
@@ -45,7 +44,7 @@ public class LambdaScope extends StatementScope {
 	}
 	
 	@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()) {
@@ -87,8 +86,8 @@ public class LambdaScope extends StatementScope {
 	}
 
 	@Override
-	public Function<CodePosition, Expression> getDollar() {
-		Function<CodePosition, Expression> outerDollar = outer.getDollar();
+	public DollarEvaluator getDollar() {
+		DollarEvaluator outerDollar = outer.getDollar();
 		if (outerDollar == null)
 			return null;
 		
@@ -96,7 +95,7 @@ public class LambdaScope extends StatementScope {
 	}
 	
 	@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

@@ -6,12 +6,11 @@
 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;
@@ -40,7 +39,7 @@ public class LoopScope extends StatementScope {
 	}
 
 	@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;
@@ -80,12 +79,12 @@ public class LoopScope extends StatementScope {
 	}
 
 	@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

@@ -8,6 +8,7 @@ package org.openzen.zenscript.codemodel.scope;
 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;
@@ -25,7 +26,7 @@ public abstract class StatementScope extends BaseScope {
 	}
 	
 	@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

@@ -77,6 +77,10 @@ public class IfStatement extends Statement {
 
 	@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

@@ -21,14 +21,16 @@ public class VarStatement extends Statement {
 	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;
 	}
 
@@ -50,17 +52,17 @@ public class VarStatement extends Statement {
 	@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

@@ -11,6 +11,8 @@ import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
@@ -107,7 +109,27 @@ public class FunctionTypeID implements TypeID {
 	
 	@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

@@ -10,8 +10,6 @@ import org.openzen.zencode.shared.CodePosition;
 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;
 
 /**
  *
@@ -67,4 +65,9 @@ public class InvalidTypeID implements TypeID {
 	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

@@ -9,6 +9,7 @@ import java.util.List;
 import java.util.Objects;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 /**
  *
@@ -140,4 +141,17 @@ public class ModifiedTypeID implements TypeID {
 			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

@@ -122,10 +122,7 @@ public class StoredType {
 	
 	@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

@@ -11,6 +11,7 @@ import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
+import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
@@ -80,4 +81,11 @@ public interface TypeID {
 	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

@@ -60,6 +60,11 @@ public class TypeMatcher implements TypeVisitorWithContext<TypeMatcher.Matching,
 			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

@@ -6,7 +6,6 @@
 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;
@@ -68,6 +67,7 @@ import org.openzen.zenscript.codemodel.Module;
 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;
@@ -413,6 +413,11 @@ public class TypeMemberBuilder implements TypeVisitorWithContext<Void, Void, Run
 		return null;
 	}
 	
+	@Override
+	public Void visitInvalid(Void context, InvalidTypeID invalid) {
+		return null;
+	}
+	
 	@Override
 	public Void visitIterator(Void context, IteratorTypeID iterator) {
 		return null;
@@ -766,6 +771,7 @@ public class TypeMemberBuilder implements TypeVisitorWithContext<Void, Void, Run
 		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);
@@ -846,6 +852,7 @@ public class TypeMemberBuilder implements TypeVisitorWithContext<Void, Void, Run
 		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

@@ -32,7 +32,6 @@ import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 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;
 
@@ -160,116 +159,100 @@ public class TypeMemberGroup {
 		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");
 		}
 	}
 	
@@ -302,35 +285,27 @@ public class TypeMemberGroup {
 		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(
@@ -338,24 +313,17 @@ public class TypeMemberGroup {
 			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

@@ -49,6 +49,7 @@ import org.openzen.zenscript.codemodel.type.GenericName;
 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;
 
 /**
@@ -352,7 +353,7 @@ public final class TypeMembers {
 		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()) {
@@ -372,7 +373,7 @@ public final class TypeMembers {
 		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);
 	}
@@ -458,13 +459,19 @@ public final class TypeMembers {
 	}
 	
 	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;
@@ -500,8 +507,8 @@ public final class TypeMembers {
 			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

@@ -31,7 +31,7 @@ public class SharedStorageTag implements StorageTag {
 
 	@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

@@ -88,12 +88,13 @@ public class SemanticModule {
 		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

@@ -1778,7 +1778,10 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 	@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);
@@ -2242,7 +2245,7 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 		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

@@ -29,7 +29,7 @@ public class JavaForeachWriter {
 		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();
@@ -41,17 +41,17 @@ public class JavaForeachWriter {
 	}
 
 	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

@@ -221,7 +221,7 @@ public class JavaPreDecrementVisitor implements ExpressionVisitor<Void> {
 	
 	@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

@@ -224,7 +224,7 @@ public class JavaPreIncrementVisitor implements ExpressionVisitor<Void> {
 
 	@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

@@ -103,7 +103,7 @@ public class JavaStatementVisitor implements StatementVisitor<Boolean> {
             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);
         }
 
@@ -311,7 +311,7 @@ public class JavaStatementVisitor implements StatementVisitor<Boolean> {
 		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

@@ -2,7 +2,6 @@ package org.openzen.zenscript.javabytecode.compiler;
 
 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

@@ -145,7 +145,7 @@ public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 		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

@@ -1695,7 +1695,7 @@ public class JavaSourceExpressionFormatter implements ExpressionVisitor<Expressi
 								.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

@@ -13,6 +13,7 @@ import org.openzen.zenscript.codemodel.expression.Expression;
 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;
@@ -115,7 +116,7 @@ public class JavaSourceStatementScope {
 		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

@@ -78,7 +78,7 @@ public class ParsedFunction extends ParsedDefinition {
 		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

@@ -1,8 +1,10 @@
 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;
@@ -43,7 +45,11 @@ public class ParsedFunctionParameter {
 	
 	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

@@ -39,6 +39,7 @@ public class ParsedVariant extends BaseParsedDefinition {
 		
 		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) {
@@ -48,7 +49,7 @@ public class ParsedVariant extends BaseParsedDefinition {
 				}
 				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

@@ -6,6 +6,7 @@
 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;
@@ -16,11 +17,13 @@ import org.openzen.zenscript.parser.type.IParsedType;
  * @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;
@@ -31,6 +34,6 @@ public class ParsedVariantOption {
 		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

@@ -210,7 +210,7 @@ public class ParsedCallArguments {
 		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

@@ -5,14 +5,12 @@
  */
 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;
 
 /**
  *
@@ -24,12 +22,11 @@ public class ParsedDollarExpression extends ParsedExpression {
 	}
 
 	@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

@@ -577,9 +577,9 @@ public abstract class ParsedExpression {
 	 * @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

@@ -7,10 +7,10 @@
 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;
@@ -34,13 +34,13 @@ public class ParsedExpressionAndAnd extends ParsedExpression {
 	}
 
 	@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

@@ -8,6 +8,7 @@ package org.openzen.zenscript.parser.expression;
 
 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;
@@ -32,7 +33,7 @@ public class ParsedExpressionArray extends ParsedExpression {
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		StoredType asBaseType = null;
 		StoredType asType = null;
 		boolean couldHintType = false;
@@ -55,13 +56,17 @@ public class ParsedExpressionArray extends ParsedExpression {
 			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);
@@ -71,7 +76,7 @@ public class ParsedExpressionArray extends ParsedExpression {
 	}
 
 	@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

@@ -8,6 +8,7 @@ package org.openzen.zenscript.parser.expression;
 
 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;
@@ -29,7 +30,7 @@ public class ParsedExpressionAssign extends ParsedExpression {
 	}
 
 	@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

@@ -7,6 +7,7 @@
 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;
@@ -32,7 +33,7 @@ public class ParsedExpressionBinary extends ParsedExpression {
 	}
 
 	@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

@@ -8,8 +8,8 @@ package org.openzen.zenscript.parser.expression;
 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;
@@ -31,9 +31,9 @@ public class ParsedExpressionBracket extends ParsedExpression {
 	}
 	
 	@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

@@ -46,7 +46,7 @@ public class ParsedExpressionCall extends ParsedExpression {
 	}
 
 	@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) {
@@ -64,40 +64,36 @@ public class ParsedExpressionCall extends ParsedExpression {
 			}
 		}
 		
-		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

@@ -7,6 +7,7 @@
 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;
@@ -35,7 +36,7 @@ public class ParsedExpressionCast extends ParsedExpression {
 	}
 
 	@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

@@ -32,7 +32,7 @@ public class ParsedExpressionCoalesce extends ParsedExpression {
 	}
 
 	@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

@@ -7,6 +7,7 @@
 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;
@@ -34,7 +35,7 @@ public class ParsedExpressionCompare extends ParsedExpression {
 	}
 
 	@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

@@ -7,10 +7,10 @@
 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;
@@ -35,7 +35,7 @@ public class ParsedExpressionConditional extends ParsedExpression {
 	}
 
 	@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();
 		
@@ -45,7 +45,7 @@ public class ParsedExpressionConditional extends ParsedExpression {
 		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;
 			}
@@ -55,7 +55,7 @@ public class ParsedExpressionConditional extends ParsedExpression {
 			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

@@ -48,7 +48,7 @@ public class ParsedExpressionFloat extends ParsedExpression {
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		if (scope.hints.isEmpty())
 			return new ConstantDoubleExpression(position, value);
 		
@@ -87,9 +87,9 @@ public class ParsedExpressionFloat extends ParsedExpression {
 				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

@@ -8,6 +8,7 @@ package org.openzen.zenscript.parser.expression;
 
 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;
@@ -25,7 +26,8 @@ import org.openzen.zenscript.codemodel.scope.StatementScope;
 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;
 
@@ -45,9 +47,10 @@ public class ParsedExpressionFunction extends ParsedExpression {
 	}
 
 	@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;
@@ -56,6 +59,7 @@ public class ParsedExpressionFunction extends ParsedExpression {
 						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;
 				}
 			}
 		}
@@ -70,22 +74,22 @@ public class ParsedExpressionFunction extends ParsedExpression {
 		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

@@ -8,6 +8,7 @@ package org.openzen.zenscript.parser.expression;
 
 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;
@@ -36,7 +37,7 @@ public class ParsedExpressionIndex extends ParsedExpression {
 	}
 
 	@Override
-	public IPartialExpression compile(ExpressionScope scope) {
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		return new PartialIndexedExpression(scope);
 	}
 
@@ -49,13 +50,13 @@ public class ParsedExpressionIndex extends ParsedExpression {
 		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()];
@@ -66,27 +67,27 @@ public class ParsedExpressionIndex extends ParsedExpression {
 		}
 
 		@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);
 			
@@ -105,7 +106,7 @@ public class ParsedExpressionIndex extends ParsedExpression {
 			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

@@ -110,7 +110,7 @@ public class ParsedExpressionInt extends ParsedExpression {
 	}
 	
 	@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"))
@@ -182,7 +182,7 @@ public class ParsedExpressionInt extends ParsedExpression {
 			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

@@ -6,6 +6,7 @@
 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;
@@ -30,7 +31,7 @@ public class ParsedExpressionIs extends ParsedExpression {
 	}
 
 	@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

@@ -44,7 +44,7 @@ public class ParsedExpressionMap extends ParsedExpression {
 	}
 
 	@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<>();
@@ -74,15 +74,11 @@ public class ParsedExpressionMap extends ParsedExpression {
 		}
 		
 		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) {
@@ -90,7 +86,7 @@ public class ParsedExpressionMap extends ParsedExpression {
 			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);
@@ -101,7 +97,7 @@ public class ParsedExpressionMap extends ParsedExpression {
 
 		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();
@@ -119,7 +115,7 @@ public class ParsedExpressionMap extends ParsedExpression {
 			}
 		}
 		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);
@@ -136,7 +132,7 @@ public class ParsedExpressionMap extends ParsedExpression {
 			}
 		}
 		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

@@ -8,8 +8,8 @@ package org.openzen.zenscript.parser.expression;
 
 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;
@@ -34,7 +34,7 @@ public class ParsedExpressionMember extends ParsedExpression {
 	}
 
 	@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(
@@ -43,7 +43,7 @@ public class ParsedExpressionMember extends ParsedExpression {
 				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

@@ -7,6 +7,7 @@
 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;
@@ -14,7 +15,6 @@ import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 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;
 
 /**
  *
@@ -34,7 +34,7 @@ public class ParsedExpressionOpAssign extends ParsedExpression {
 	}
 
 	@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

@@ -7,6 +7,7 @@
 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;
@@ -29,7 +30,7 @@ public class ParsedExpressionOrOr extends ParsedExpression {
 	}
 
 	@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

@@ -6,8 +6,8 @@
 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;
@@ -27,10 +27,10 @@ public class ParsedExpressionOuter extends ParsedExpression {
 	}
 
 	@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

@@ -7,6 +7,7 @@
 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;
@@ -28,7 +29,7 @@ public class ParsedExpressionPostCall extends ParsedExpression {
 	}
 
 	@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

@@ -8,6 +8,7 @@ package org.openzen.zenscript.parser.expression;
 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;
@@ -31,7 +32,7 @@ public class ParsedExpressionRange extends ParsedExpression {
 	}
 
 	@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

@@ -7,6 +7,7 @@
 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;
@@ -35,7 +36,7 @@ public class ParsedExpressionSame extends ParsedExpression {
 	}
 
 	@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

@@ -34,17 +34,8 @@ public class ParsedExpressionString extends ParsedExpression {
 
 	@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

@@ -24,11 +24,11 @@ public class ParsedExpressionSuper extends ParsedExpression {
 	}
 	
 	@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

@@ -7,6 +7,7 @@
 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;
@@ -28,7 +29,7 @@ public class ParsedExpressionUnary extends ParsedExpression {
 	}
 
 	@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

@@ -14,7 +14,6 @@ import org.openzen.zencode.shared.CompileExceptionCode;
 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;
@@ -49,7 +48,7 @@ public class ParsedExpressionVariable extends ParsedExpression {
 	}
 
 	@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()];
@@ -71,7 +70,7 @@ public class ParsedExpressionVariable extends ParsedExpression {
 					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

@@ -10,13 +10,11 @@ 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.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;
 
 /**
@@ -35,27 +33,23 @@ public class ParsedMatchExpression extends ParsedExpression {
 	}
 
 	@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

@@ -6,6 +6,7 @@
 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;
@@ -25,7 +26,7 @@ public class ParsedPanicExpression extends ParsedExpression {
 	}
 	
 	@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

@@ -6,6 +6,7 @@
 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;
@@ -27,7 +28,7 @@ public class ParsedThrowExpression extends ParsedExpression {
 	}
 
 	@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

@@ -6,6 +6,7 @@
 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;
@@ -29,10 +30,10 @@ public class ParsedTryConvertExpression extends ParsedExpression {
 	}
 
 	@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) {
@@ -40,7 +41,7 @@ public class ParsedTryConvertExpression extends ParsedExpression {
 			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

@@ -6,10 +6,10 @@
 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;
@@ -31,7 +31,7 @@ public class ParsedTryRethrowExpression extends ParsedExpression {
 	}
 
 	@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();
@@ -55,9 +55,9 @@ public class ParsedTryRethrowExpression extends ParsedExpression {
 			}
 			
 			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

@@ -6,12 +6,11 @@
 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;
@@ -20,6 +19,7 @@ import org.openzen.zenscript.codemodel.statement.VarStatement;
 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;
@@ -44,7 +44,7 @@ public class ParsedCatchClause {
 	}
 	
 	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));
 	}
@@ -59,7 +59,7 @@ public class ParsedCatchClause {
 		}
 	
 		@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);
 
@@ -97,12 +97,12 @@ public class ParsedCatchClause {
 		}
 
 		@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

@@ -5,6 +5,7 @@
  */
 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;
@@ -13,6 +14,7 @@ import org.openzen.zenscript.codemodel.statement.Statement;
 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;
 
 /**
@@ -28,15 +30,19 @@ public class ParsedLambdaFunctionBody implements ParsedFunctionBody {
 	
 	@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

@@ -6,8 +6,10 @@
 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;
@@ -36,10 +38,15 @@ public class ParsedStatementDoWhile extends ParsedStatement {
 
 	@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

@@ -1,13 +1,14 @@
 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 {
@@ -21,6 +22,10 @@ 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

@@ -1,6 +1,7 @@
 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;
@@ -13,6 +14,7 @@ import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 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;
@@ -32,21 +34,25 @@ public class ParsedStatementForeach extends ParsedStatement {
 
 	@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

@@ -1,8 +1,10 @@
 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;
@@ -26,7 +28,13 @@ public class ParsedStatementIf extends ParsedStatement {
 
 	@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

@@ -6,12 +6,14 @@
 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;
 
@@ -32,8 +34,12 @@ public class ParsedStatementLock extends ParsedStatement {
 
 	@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);
+		}
 	}
 }