- Added try! and try? operators

- WIP on exception handling

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/ExpressionFormatter.java

 import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
 import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
+import org.openzen.zenscript.codemodel.expression.TryConvertExpression;
+import org.openzen.zenscript.codemodel.expression.TryRethrowAsExceptionExpression;
+import org.openzen.zenscript.codemodel.expression.TryRethrowAsResultExpression;
+import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
 import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.shared.StringUtils;
 		return new ExpressionString("this", OperatorPriority.PRIMARY);
 	}
 
+	@Override
+	public ExpressionString visitTryConvert(TryConvertExpression expression) {
+		ExpressionString value = expression.accept(this);
+		return new ExpressionString("try?" + value.value, value.priority);
+	}
+
+	@Override
+	public ExpressionString visitTryRethrowAsException(TryRethrowAsExceptionExpression expression) {
+		ExpressionString value = expression.accept(this);
+		return new ExpressionString("try!" + value.value, value.priority);
+	}
+
+	@Override
+	public ExpressionString visitTryRethrowAsResult(TryRethrowAsResultExpression expression) {
+		ExpressionString value = expression.accept(this);
+		return new ExpressionString("try!" + value.value, value.priority);
+	}
+	
+	@Override
+	public ExpressionString visitVariantValue(VariantValueExpression expression) {
+		StringBuilder result = new StringBuilder();
+		result.append("new ");
+		// TODO: finish this
+		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+	}
+
 	@Override
 	public ExpressionString visitWrapOptional(WrapOptionalExpression expression) {
 		return expression.value.accept(this);

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/StatementFormatter.java

 				output.append(indent)
 						.append(settings.indent)
 						.append("case ")
-						.append(switchCase.value.accept(expressionFormatter))
+						.append(switchCase.value.accept(new SwitchValueFormatter(settings)))
 						.append(":\n");
 			}
 			for (Statement s : switchCase.statements)

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/SwitchValueFormatter.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.formatter;
+
+import org.openzen.zenscript.codemodel.expression.switchvalue.CharSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.EnumConstantSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.IntSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.StringSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValueVisitor;
+import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
+import org.openzen.zenscript.shared.StringUtils;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SwitchValueFormatter implements SwitchValueVisitor<String> {
+	private final FormattingSettings settings;
+	
+	public SwitchValueFormatter(FormattingSettings settings) {
+		this.settings = settings;
+	}
+
+	@Override
+	public String acceptInt(IntSwitchValue value) {
+		return Integer.toString(value.value);
+	}
+
+	@Override
+	public String acceptChar(CharSwitchValue value) {
+		return StringUtils.escape(new String(new char[] { value.value }), '\'', true);
+	}
+
+	@Override
+	public String acceptString(StringSwitchValue value) {
+		return StringUtils.escape(value.value, settings.useSingleQuotesForStrings ? '\'' : '"', true);
+	}
+
+	@Override
+	public String acceptEnumConstant(EnumConstantSwitchValue value) {
+		return value.constant.name;
+	}
+
+	@Override
+	public String acceptVariantOption(VariantOptionSwitchValue value) {
+		StringBuilder result = new StringBuilder();
+		result.append(value.option.name);
+		result.append("(");
+		for (int i = 0; i < value.parameters.length; i++) {
+			if (i > 0)
+				result.append(", ");
+			result.append(value.parameters[i]);
+		}
+		result.append(")");
+		return result.toString();
+	}
+}

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

 	public final TypeParameter[] typeParameters;
 	public final ITypeID returnType;
 	public final FunctionParameter[] parameters;
+	public final ITypeID thrownType;
 	
 	public FunctionHeader(ITypeID returnType) {
 		this.typeParameters = null;
 		this.returnType = returnType;
 		this.parameters = NO_PARAMETERS;
+		this.thrownType = null;
 	}
 	
 	public FunctionHeader(ITypeID returnType, ITypeID... parameterTypes) {
 		this.typeParameters = null;
 		this.returnType = returnType;
 		this.parameters = new FunctionParameter[parameterTypes.length];
+		this.thrownType = null;
 		
 		for (int i = 0; i < parameterTypes.length; i++)
 			parameters[i] = new FunctionParameter(parameterTypes[i], null);
 		this.typeParameters = null;
 		this.returnType = returnType;
 		this.parameters = parameters;
+		this.thrownType = null;
 	}
 	
-	public FunctionHeader(TypeParameter[] genericParameters, ITypeID returnType, FunctionParameter... parameters) {
+	public FunctionHeader(TypeParameter[] genericParameters, ITypeID returnType, ITypeID thrownType, FunctionParameter... parameters) {
 		this.typeParameters = genericParameters;
 		this.returnType = returnType;
 		this.parameters = parameters;
+		this.thrownType = thrownType;
 	}
 	
 	public int getNumberOfTypeParameters() {
 		for (int i = 0; i < parameters.length; i++)
 			parameters[i] = this.parameters[i].withGenericArguments(registry, mapping);
 		
-		return new FunctionHeader(genericParameters, returnType, parameters);
+		return new FunctionHeader(genericParameters, returnType, thrownType == null ? null : thrownType.withGenericArguments(registry, mapping), parameters);
 	}
 	
 	public ITypeID[] inferTypes(LocalMemberCache cache, CallArguments arguments, List<ITypeID> resultHint) {
 			ITypeID modified = this.parameters[i].type.withGenericArguments(registry, arguments);
 			parameters[i] = modified == this.parameters[i].type ? this.parameters[i] : new FunctionParameter(modified, this.parameters[i].name);
 		}
-		return new FunctionHeader(typeParameters, returnType, parameters);
+		return new FunctionHeader(typeParameters, returnType, thrownType == null ? null : thrownType.withGenericArguments(registry, arguments), parameters);
 	}
 	
 	public FunctionHeader withGenericArguments(GlobalTypeRegistry registry, ITypeID[] arguments) {
 		for (int i = 0; i < lambdaHeader.parameters.length; i++)
 			parameters[i] = new FunctionParameter(this.parameters[i].type, lambdaHeader.parameters[i].name);
 		
-		return new FunctionHeader(typeParameters, returnType, parameters);
-		//return this;
+		return new FunctionHeader(typeParameters, returnType, thrownType, parameters);
 	}
 	
 	public FunctionParameter getVariadicParameter() {
 			return parameters.length + " parameters expected but " + arguments.arguments.length + " given.";
 		
 		if (getNumberOfTypeParameters() != arguments.getNumberOfTypeArguments())
-			return typeParameters.length + " type parameters expected but " + arguments.typeArguments.length + " given.";
+			return getNumberOfTypeParameters() + " type parameters expected but " + arguments.getNumberOfTypeArguments() + " given.";
 		
 		for (int i = 0; i < parameters.length; i++) {
-			if (!scope.getTypeMembers(arguments.arguments[i].getType()).canCastImplicit(parameters[i].type)) {
-				return "Parameter " + i + ": cannot cast " + arguments.arguments[i].getType() + " to " + parameters[i].type;
+			if (!scope.getTypeMembers(arguments.arguments[i].type).canCastImplicit(parameters[i].type)) {
+				return "Parameter " + i + ": cannot cast " + arguments.arguments[i].type + " to " + parameters[i].type;
 			}
 		}
 		

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

 	public void setHeader(FunctionHeader header) {
 		this.header = header;
 		this.genericParameters = header.typeParameters;
-		header = new FunctionHeader(null, header.returnType, header.parameters);
+		header = new FunctionHeader(null, header.returnType, header.thrownType, header.parameters);
 		addMember(caller = new OperatorMember(position, this, modifiers | Modifiers.STATIC, OperatorType.CALL, header));
 		callerGroup.addMethod(caller, TypeMemberPriority.SPECIFIED);
 	}

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

 		return types.containsKey(name) || subPackages.containsKey(name);
 	}
 	
+	public HighLevelDefinition getDefinition(String name) {
+		return types.get(name);
+	}
+	
 	public HighLevelDefinition getImport(List<String> name, int depth) {
 		if (depth >= name.size())
 			return null;
 		return null;
 	}
 	
-	public ITypeID getType(CodePosition position, TypeScope scope, List<GenericName> nameParts, int depth) {
+	public ITypeID getType(CodePosition position, TypeScope scope, List<GenericName> nameParts) {
+		return getType(position, scope, nameParts, 0);
+	}
+	
+	public ITypeID getType(CodePosition position, TypeScope scope, GenericName name) {
+		if (types.containsKey(name.name)) {
+			return scope.getTypeRegistry().getForDefinition(types.get(name.name), name.arguments);
+		}
+		
+		return null;
+	}
+	
+	private ITypeID getType(CodePosition position, TypeScope scope, List<GenericName> nameParts, int depth) {
 		if (depth >= nameParts.size())
 			return null;
 		

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

 	public final Expression right;
 	
 	public AndAndExpression(CodePosition position, Expression left, Expression right) {
-		super(position, BasicTypeID.BOOL);
+		super(position, BasicTypeID.BOOL, binaryThrow(position, left.thrownType, right.thrownType));
 		
 		this.left = left;
 		this.right = right;

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

 	public final ArrayTypeID arrayType;
 	
 	public ArrayExpression(CodePosition position, Expression[] expressions, ArrayTypeID type) {
-		super(position, type);
+		super(position, type, multiThrow(position, expressions));
 		
 		this.expressions = expressions;
 		this.arrayType = type;

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

 	public final CompareType operator;
 	
 	public BasicCompareExpression(CodePosition position, Expression left, Expression right, CompareType operator) {
-		super(position, BasicTypeID.BOOL);
+		super(position, BasicTypeID.BOOL, binaryThrow(position, left.thrownType, right.thrownType));
 		
 		this.left = left;
 		this.right = right;

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

 	public final FunctionHeader instancedHeader;
 	
 	public CallExpression(CodePosition position, Expression target, FunctionalMember member, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
-		super(position, instancedHeader.returnType);
+		super(position, instancedHeader.returnType, multiThrow(position, arguments.arguments));
 		
 		this.target = target;
 		this.member = member;

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

 	public final FunctionHeader instancedHeader;
 	
 	public CallStaticExpression(CodePosition position, ITypeID target, FunctionalMember member, CallArguments arguments, FunctionHeader instancedHeader, TypeScope scope) {
-		super(position, member.header.returnType);
+		super(position, member.header.returnType, multiThrow(position, arguments.arguments));
 		
 		this.member = member;
 		this.target = target;

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

 	public final LambdaClosure closure;
 	
 	public CapturedExpression(CodePosition position, ITypeID type, LambdaClosure closure) {
-		super(position, type);
+		super(position, type, null);
 		
 		this.closure = closure;
 	}

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

 	public final boolean isImplicit;
 	
 	public CastExpression(CodePosition position, Expression target, CasterMember member, boolean isImplicit) {
-		super(position, member.getTargetType());
+		super(position, member.getTargetType(), binaryThrow(position, target.thrownType, member.header.thrownType));
 		
 		this.target = target;
 		this.member = member;

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

 	public final Expression value;
 	
 	public CheckNullExpression(CodePosition position, Expression value) {
-		super(position, value.type.unwrap());
+		super(position, value.type.unwrap(), value.thrownType);
 		
 		this.value = value;
 	}

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

 	public final Expression right;
 	
 	public CoalesceExpression(CodePosition position, Expression left, Expression right) {
-		super(position, right.type);
+		super(position, right.type, binaryThrow(position, left.thrownType, right.thrownType));
 		
 		this.left = left;
 		this.right = right;

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

 			Expression ifThen,
 			Expression ifElse,
 			ITypeID type) {
-		super(position, ifThen.type);
+		super(position, ifThen.type, binaryThrow(position, condition.thrownType, binaryThrow(position, ifThen.thrownType, ifElse.thrownType)));
 		
 		if (ifThen.type != ifElse.type)
 			throw new AssertionError();

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

 	public final boolean value;
 	
 	public ConstantBoolExpression(CodePosition position, boolean value) {
-		super(position, BasicTypeID.BOOL);
+		super(position, BasicTypeID.BOOL, null);
 		
 		this.value = value;
 	}

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

 	public final byte value;
 	
 	public ConstantByteExpression(CodePosition position, byte value) {
-		super(position, BasicTypeID.BYTE);
+		super(position, BasicTypeID.BYTE, null);
 		
 		this.value = value;
 	}

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

 	public final char value;
 	
 	public ConstantCharExpression(CodePosition position, char value) {
-		super(position, BasicTypeID.CHAR);
+		super(position, BasicTypeID.CHAR, null);
 		
 		this.value = value;
 	}

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

 	public final double value;
 	
 	public ConstantDoubleExpression(CodePosition position, double value) {
-		super(position, BasicTypeID.DOUBLE);
+		super(position, BasicTypeID.DOUBLE, null);
 		
 		this.value = value;
 	}

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

 	public final float value;
 	
 	public ConstantFloatExpression(CodePosition position, float value) {
-		super(position, BasicTypeID.FLOAT);
+		super(position, BasicTypeID.FLOAT, null);
 		
 		this.value = value;
 	}

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

 	public final int value;
 	
 	public ConstantIntExpression(CodePosition position, int value) {
-		super(position, BasicTypeID.INT);
+		super(position, BasicTypeID.INT, null);
 		
 		this.value = value;
 	}

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

 	public final long value;
 	
 	public ConstantLongExpression(CodePosition position, long value) {
-		super(position, BasicTypeID.LONG);
+		super(position, BasicTypeID.LONG, null);
 		
 		this.value = value;
 	}

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

 	public final byte value;
 	
 	public ConstantSByteExpression(CodePosition position, byte value) {
-		super(position, BasicTypeID.SBYTE);
+		super(position, BasicTypeID.SBYTE, null);
 		
 		this.value = value;
 	}

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

 	public final short value;
 	
 	public ConstantShortExpression(CodePosition position, short value) {
-		super(position, BasicTypeID.SHORT);
+		super(position, BasicTypeID.SHORT, null);
 		
 		this.value = value;
 	}

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

 	public final String value;
 	
 	public ConstantStringExpression(CodePosition position, String value) {
-		super(position, BasicTypeID.STRING);
+		super(position, BasicTypeID.STRING, null);
 		
 		this.value = value;
 	}

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

 	public final int value;
 	
 	public ConstantUIntExpression(CodePosition position, int value) {
-		super(position, BasicTypeID.UINT);
+		super(position, BasicTypeID.UINT, null);
 		
 		this.value = value;
 	}

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

 	public final long value;
 	
 	public ConstantULongExpression(CodePosition position, long value) {
-		super(position, BasicTypeID.ULONG);
+		super(position, BasicTypeID.ULONG, null);
 		
 		this.value = value;
 	}

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

 	public final short value;
 	
 	public ConstantUShortExpression(CodePosition position, short value) {
-		super(position, BasicTypeID.USHORT);
+		super(position, BasicTypeID.USHORT, null);
 		
 		this.value = value;
 	}

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

 	public final CallArguments arguments;
 	
 	public ConstructorSuperCallExpression(CodePosition position, ITypeID type, ConstructorMember constructor, CallArguments arguments, TypeScope scope) {
-		super(position, BasicTypeID.VOID);
+		super(position, BasicTypeID.VOID, binaryThrow(position, constructor.header.thrownType, multiThrow(position, arguments.arguments)));
 		
 		this.objectType = type;
 		this.constructor = constructor;

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

 	public final CallArguments arguments;
 	
 	public ConstructorThisCallExpression(CodePosition position, ITypeID type, ConstructorMember constructor, CallArguments arguments, TypeScope scope) {
-		super(position, BasicTypeID.VOID);
+		super(position, BasicTypeID.VOID, binaryThrow(position, constructor.header.thrownType, multiThrow(position, arguments.arguments)));
 		
 		arguments = arguments.normalize(position, scope, constructor.header);
 		

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

 	public final EnumConstantMember value;
 	
 	public EnumConstantExpression(CodePosition position, ITypeID type, EnumConstantMember value) {
-		super(position, type);
+		super(position, type, null);
 		
 		this.value = value;
 	}
 	
 	public EnumConstantExpression(CodePosition position, GlobalTypeRegistry registry, EnumDefinition type, EnumConstantMember value) {
-		super(position, registry.getForDefinition(type, null));
+		super(position, registry.getForDefinition(type), null);
 		
 		this.value = value;
 	}

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

 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.shared.CompileException;
+import org.openzen.zenscript.shared.CompileExceptionCode;
 
 /**
  *
 public abstract class Expression implements IPartialExpression {
 	public final CodePosition position;
 	public final ITypeID type;
+	public final ITypeID thrownType;
 	
-	public Expression(CodePosition position, ITypeID type) {
+	public Expression(CodePosition position, ITypeID type, ITypeID thrownType) {
 		this.position = position;
 		this.type = type;
-	}
-	
-	public ITypeID getType() {
-		return type;
+		this.thrownType = thrownType;
 	}
 	
 	public abstract <T> T accept(ExpressionVisitor<T> visitor);
 	public ITypeID[] getGenericCallTypes() {
 		return null;
 	}
+	
+	public static ITypeID binaryThrow(CodePosition position, ITypeID left, ITypeID right) {
+		if (left == right)
+			return left;
+		else if (left == null)
+			return right;
+		else if (right == null)
+			return left;
+		else
+			throw new CompileException(position, CompileExceptionCode.DIFFERENT_EXCEPTIONS, "two different exceptions in same operation: " + left.toString() + " and " + right.toString());
+	}
+	
+	public static ITypeID multiThrow(CodePosition position, Expression[] expressions) {
+		ITypeID result = null;
+		for (Expression expression : expressions)
+			result = binaryThrow(position, result, expression.thrownType);
+		return result;
+	}
 }

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

 	
 	public T visitThis(ThisExpression expression);
 	
+	public T visitTryConvert(TryConvertExpression expression);
+	
+	public T visitTryRethrowAsException(TryRethrowAsExceptionExpression expression);
+	
+	public T visitTryRethrowAsResult(TryRethrowAsResultExpression expression);
+	
+	public T visitVariantValue(VariantValueExpression expression);
+	
 	public T visitWrapOptional(WrapOptionalExpression expression);
 }

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

 			FunctionTypeID type,
 			LambdaClosure closure,
 			Statement body) {
-		super(position, type);
+		super(position, type, body.thrownType);
 		
 		this.header = type.header;
 		this.closure = closure;

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

 	public final CompareType operator;
 	
 	public GenericCompareExpression(CodePosition position, Expression value, CompareType operator) {
-		super(position, BasicTypeID.BOOL);
+		super(position, BasicTypeID.BOOL, value.thrownType);
 		
 		this.value = value;
 		this.operator = operator;

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

 	public final FieldMember field;
 	
 	public GetFieldExpression(CodePosition position, Expression target, FieldMember field) {
-		super(position, field.type);
+		super(position, field.type, target.thrownType);
 		
 		this.target = target;
 		this.field = field;

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

 	public final FunctionParameter parameter;
 	
 	public GetFunctionParameterExpression(CodePosition position, FunctionParameter parameter) {
-		super(position, parameter.type);
+		super(position, parameter.type, null);
 		
 		this.parameter = parameter;
 	}

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

 	public final VarStatement variable;
 	
 	public GetLocalVariableExpression(CodePosition position, VarStatement variable) {
-		super(position, variable.type);
+		super(position, variable.type, null);
 		
 		this.variable = variable;
 	}

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

 	public final FieldMember field;
 	
 	public GetStaticFieldExpression(CodePosition position, FieldMember field) {
-		super(position, field.type);
+		super(position, field.type, null);
 		
 		this.field = field;
 	}

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

 	public final GetterMember getter;
 	
 	public GetterExpression(CodePosition position, Expression target, GetterMember getter) {
-		super(position, getter.type);
+		super(position, getter.type, target.thrownType);
 		
 		this.target = target;
 		this.getter = getter;

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

 	public final Expression resolution;
 	
 	public GlobalCallExpression(CodePosition position, String name, CallArguments arguments, Expression resolution) {
-		super(position, resolution.type);
+		super(position, resolution.type, resolution.thrownType);
 		
 		this.name = name;
 		this.arguments = arguments;

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

 	public final Expression resolution;
 	
 	public GlobalExpression(CodePosition position, String name, Expression resolution) {
-		super(position, resolution.type);
+		super(position, resolution.type, resolution.thrownType);
 		
 		this.name = name;
 		this.resolution = resolution;

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

 	public final Expression value;
 	
 	public InterfaceCastExpression(CodePosition position, Expression value, ITypeID toType) {
-		super(position, toType);
+		super(position, toType, value.thrownType);
 		
 		this.value = value;
 	}

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

 	public final ITypeID isType;
 	
 	public IsExpression(CodePosition position, Expression value, ITypeID type) {
-		super(position, BasicTypeID.BOOL);
+		super(position, BasicTypeID.BOOL, value.thrownType);
 		
 		this.value = value;
 		this.isType = type;

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

 	public final Expression value;
 	
 	public MakeConstExpression(CodePosition position, Expression value, ITypeID constType) {
-		super(position, constType);
+		super(position, constType, value.thrownType);
 		
 		this.value = value;
 	}

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

 			Expression[] keys,
 			Expression[] values,
 			ITypeID type) {
-		super(position, type);
+		super(position, type, binaryThrow(position, multiThrow(position, keys), multiThrow(position, values)));
 		
 		this.keys = keys;
 		this.values = values;

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

 	public final Case[] cases;
 	
 	public MatchExpression(CodePosition position, Expression value, ITypeID type, Case[] cases) {
-		super(position, type);
+		super(position, type, binaryThrow(position, value.thrownType, getThrownType(position, cases)));
 		
 		this.value = value;
 		this.cases = cases;
 			this.value = value;
 		}
 	}
+	
+	private static ITypeID getThrownType(CodePosition position, Case[] cases) {
+		if (cases.length == 0)
+			return null;
+		
+		ITypeID result = cases[0].value.thrownType;
+		for (int i = 1; i < cases.length; i++)
+			result = binaryThrow(position, result, cases[i].value.thrownType);
+		
+		return result;
+	}
 }

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

 	public final CallArguments arguments;
 	
 	public NewExpression(CodePosition position, ITypeID type, ConstructorMember constructor, CallArguments arguments) {
-		super(position, type);
+		super(position, type, binaryThrow(position, constructor.header.thrownType, multiThrow(position, arguments.arguments)));
 		
 		this.constructor = constructor;
 		this.arguments = arguments;

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

  */
 public class NullExpression extends Expression {
 	public NullExpression(CodePosition position) {
-		super(position, BasicTypeID.NULL);
+		super(position, BasicTypeID.NULL, null);
 	}
 	
 	public NullExpression(CodePosition position, ITypeID optionalType) {
-		super(position, optionalType);
+		super(position, optionalType, null);
 	}
 
 	@Override

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

 	public final Expression right;
 	
 	public OrOrExpression(CodePosition position, Expression left, Expression right) {
-		super(position, BasicTypeID.BOOL);
+		super(position, BasicTypeID.BOOL, binaryThrow(position, left.thrownType, right.thrownType));
 		
 		this.left = left;
 		this.right = right;

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

 	public final OperatorMember member;
 	
 	public PostCallExpression(CodePosition position, Expression target, OperatorMember member, FunctionHeader instancedHeader) {
-		super(position, instancedHeader.returnType);
+		super(position, instancedHeader.returnType, binaryThrow(position, member.header.thrownType, target.thrownType));
 		
 		if (member.operator != OperatorType.DECREMENT && member.operator != OperatorType.INCREMENT)
 			throw new IllegalArgumentException("Operator must be increment or decrement");

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

 	public final Expression to;
 	
 	public RangeExpression(CodePosition position, GlobalTypeRegistry registry, Expression from, Expression to) {
-		super(position, registry.getRange(from.getType(), to.getType()));
+		super(position, registry.getRange(from.type, to.type), binaryThrow(position, from.thrownType, to.thrownType));
 	
 		this.from = from;
 		this.to = to;

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

 	public final boolean inverted;
 	
 	public SameObjectExpression(CodePosition position, Expression left, Expression right, boolean inverted) {
-		super(position, BasicTypeID.BOOL);
+		super(position, BasicTypeID.BOOL, binaryThrow(position, left.thrownType, right.thrownType));
 		
 		this.left = left;
 		this.right = right;

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

 	public final Expression value;
 	
 	public SetFieldExpression(CodePosition position, Expression target, FieldMember field, Expression value) {
-		super(position, field.type);
+		super(position, field.type, binaryThrow(position, target.thrownType, value.thrownType));
 		
 		this.target = target;
 		this.field = field;

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

 	public final Expression value;
 	
 	public SetFunctionParameterExpression(CodePosition position, FunctionParameter parameter, Expression value) {
-		super(position, parameter.type);
+		super(position, parameter.type, value.thrownType);
 		
 		this.parameter = parameter;
 		this.value = value;

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

 	public final Expression value;
 	
 	public SetLocalVariableExpression(CodePosition position, VarStatement variable, Expression value) {
-		super(position, variable.type);
+		super(position, variable.type, value.thrownType);
 		
 		this.variable = variable;
 		this.value = value;

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

 	public final Expression value;
 	
 	public SetStaticFieldExpression(CodePosition position, FieldMember field, Expression value) {
-		super(position, field.type);
+		super(position, field.type, value.thrownType);
 		
 		this.field = field;
 		this.value = value;

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

 	public final Expression value;
 	
 	public SetterExpression(CodePosition position, Expression target, SetterMember setter, Expression value) {
-		super(position, setter.type);
+		super(position, setter.type, binaryThrow(position, value.thrownType, setter.header.thrownType));
 		
 		this.target = target;
 		this.setter = setter;

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

 	public final GetterMember getter;
 	
 	public StaticGetterExpression(CodePosition position, GetterMember getter) {
-		super(position, getter.type);
+		super(position, getter.type, getter.header.thrownType);
 		
 		this.getter = getter;
 	}

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

 	public final Expression value;
 	
 	public StaticSetterExpression(CodePosition position, SetterMember setter, Expression value) {
-		super(position, setter.type);
+		super(position, setter.type, binaryThrow(position, setter.header.thrownType, value.thrownType));
 		
 		this.setter = setter;
 		this.value = value;

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

 	public final Expression value;
 	
 	public SupertypeCastExpression(CodePosition position, Expression value, ITypeID type) {
-		super(position, type);
+		super(position, type, value.thrownType);
 		
 		this.value = value;
 	}

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

  */
 public class ThisExpression extends Expression {
 	public ThisExpression(CodePosition position, ITypeID type) {
-		super(position, type);
+		super(position, type, null);
 	}
 	
 	@Override

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.expression;
+
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class TryConvertExpression extends Expression {
+	public final Expression value;
+	
+	public TryConvertExpression(CodePosition position, ITypeID type, Expression value) {
+		super(position, type, null);
+		
+		this.value = value;
+	}
+	
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitTryConvert(this);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.expression;
+
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class TryRethrowAsExceptionExpression extends Expression {
+	public final Expression value;
+	
+	public TryRethrowAsExceptionExpression(CodePosition position, ITypeID type, Expression value, ITypeID thrownType) {
+		super(position, type, thrownType);
+		
+		this.value = value;
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitTryRethrowAsException(this);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.expression;
+
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class TryRethrowAsResultExpression extends Expression {
+	public final Expression value;
+	
+	public TryRethrowAsResultExpression(CodePosition position, ITypeID type, Expression value) {
+		super(position, type, null);
+		
+		this.value = value;
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitTryRethrowAsResult(this);
+	}
+}

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

 package org.openzen.zenscript.codemodel.expression;
 
 import java.util.List;
-import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	}
 	
 	public VariantValueExpression(CodePosition position, ITypeID variantType, VariantDefinition.Option option, Expression[] arguments) {
-		super(position, variantType);
+		super(position, variantType, arguments == null ? null : multiThrow(position, arguments));
 		
 		this.option = option;
 		this.arguments = null;
 	}
 	
+	public int getNumberOfArguments() {
+		return arguments == null ? 0 : arguments.length;
+	}
+	
 	@Override
 	public Expression call(CodePosition position, TypeScope scope, List<ITypeID> hints, CallArguments arguments) {
+		if (arguments != null)
+			return super.call(position, scope, hints, arguments);
+		
 		return new VariantValueExpression(position, type, option, arguments.arguments);
 	}
-
+	
 	@Override
 	public <T> T accept(ExpressionVisitor<T> visitor) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		return visitor.visitVariantValue(this);
 	}
 }

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

 	public final Expression value;
 	
 	public WrapOptionalExpression(CodePosition position, Expression value, ITypeID optionalType) {
-		super(position, optionalType);
+		super(position, optionalType, value.thrownType);
 		
 		if (value.type.isOptional())
 			throw new IllegalArgumentException("Value is already optional");

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

  */
 public class ConstructorMember extends FunctionalMember {
 	public ConstructorMember(CodePosition position, HighLevelDefinition definition, int modifiers, FunctionHeader header) {
-		super(position, definition, modifiers, "this", new FunctionHeader(header.typeParameters, BasicTypeID.VOID, header.parameters));
+		super(position, definition, modifiers, "this", new FunctionHeader(header.typeParameters, BasicTypeID.VOID, header.thrownType, header.parameters));
 	}
 	
 	public boolean isConstructorForwarded() {

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

 package org.openzen.zenscript.codemodel.statement;
 
 import java.util.List;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
 	public final List<Statement> statements;
 	
 	public BlockStatement(CodePosition position, List<Statement> statements) {
-		super(position);
+		super(position, getThrownType(statements));
 		
 		this.statements = statements;
 	}
 	public <T> T accept(StatementVisitor<T> visitor) {
 		return visitor.visitBlock(this);
 	}
+	
+	private static ITypeID getThrownType(List<Statement> statements) {
+		ITypeID result = null;
+		for (Statement statement : statements)
+			result = Expression.binaryThrow(statement.position, result, statement.thrownType);
+		return result;
+	}
 }

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

 	public final LoopStatement target;
 	
 	public BreakStatement(CodePosition position, LoopStatement target) {
-		super(position);
+		super(position, null);
 		
 		this.target = target;
 	}

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

 	public final LoopStatement target;
 	
 	public ContinueStatement(CodePosition position, LoopStatement target) {
-		super(position);
+		super(position, null);
 		
 		this.target = target;
 	}

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

 	public final Expression condition;
 	
 	public DoWhileStatement(CodePosition position, String label, Expression condition) {
-		super(position, label);
+		super(position, label, null); // TODO: thrown type
 		
 		this.condition = condition;
 	}

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

  */
 public class EmptyStatement extends Statement {
 	public EmptyStatement(CodePosition position) {
-		super(position);
+		super(position, null);
 	}
 
 	@Override

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

 	public final Expression expression;
 	
 	public ExpressionStatement(CodePosition position, Expression expression) {
-		super(position);
+		super(position, expression.thrownType);
 		
 		this.expression = expression;
 	}

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

 	public Statement content;
 	
 	public ForeachStatement(CodePosition position, VarStatement[] loopVariables, IIteratorMember iterator, Expression list) {
-		super(position, loopVariables[0].name);
+		super(position, loopVariables[0].name, null); // TODO: thrown type
 		
 		this.loopVariables = loopVariables;
 		this.list = list;

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

 package org.openzen.zenscript.codemodel.statement;
 
 import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
 	public final Statement onElse;
 	
 	public IfStatement(CodePosition position, Expression condition, Statement onThen, Statement onElse) {
-		super(position);
+		super(position, getThrownType(condition, onThen, onElse));
 		
 		this.condition = condition;
 		this.onThen = onThen;
 	public <T> T accept(StatementVisitor<T> visitor) {
 		return visitor.visitIf(this);
 	}
+	
+	private static ITypeID getThrownType(Expression condition, Statement onThen, Statement onElse) {
+		ITypeID result = Expression.binaryThrow(onThen.position, condition.thrownType, onThen.thrownType);
+		if (onElse != null)
+			result = Expression.binaryThrow(onElse.position, result, onElse.thrownType);
+		return result;
+	}
 }

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

 	public final Statement content;
 	
 	public LockStatement(CodePosition position, Expression object, Statement content) {
-		super(position);
+		super(position, Expression.binaryThrow(position, object.thrownType, content.thrownType));
 		
 		this.object = object;
 		this.content = content;

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

  */
 package org.openzen.zenscript.codemodel.statement;
 
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
 public abstract class LoopStatement extends Statement {
 	public String label;
 	
-	public LoopStatement(CodePosition position, String label) {
-		super(position);
+	public LoopStatement(CodePosition position, String label, ITypeID thrownType) {
+		super(position, thrownType);
 		
 		this.label = label;
 	}

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

 	public final Expression value;
 	
 	public ReturnStatement(CodePosition position, Expression value) {
-		super(position);
+		super(position, value == null ? null : value.thrownType);
 		
 		this.value = value;
 	}

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

  */
 public abstract class Statement extends Taggable {
 	public final CodePosition position;
+	public final ITypeID thrownType;
 	
-	public Statement(CodePosition position) {
+	public Statement(CodePosition position, ITypeID thrownType) {
 		this.position = position;
+		this.thrownType = thrownType;
 	}
 	
 	public ITypeID getReturnType() {

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

 	public final List<SwitchCase> cases = new ArrayList<>();
 	
 	public SwitchStatement(CodePosition position, String label, Expression value) {
-		super(position, label);
+		super(position, label, null); // TODO: thrown type
 		
 		this.value = value;
 	}

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

 	public final Expression value;
 	
 	public ThrowStatement(CodePosition position, Expression value) {
-		super(position);
+		super(position, value.type);
 		
 		this.value = value;
 	}

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

 			Statement content,
 			List<CatchClause> catchClauses,
 			Statement finallyClause) {
-		super(position);
+		super(position, null); // TODO: thrown type
 		
 		this.resource = resource;
 		this.content = content;

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

 	public final boolean isFinal;
 	
 	public VarStatement(CodePosition position, String name, ITypeID type, Expression initializer, boolean isFinal) {
-		super(position);
+		super(position, initializer == null ? null : initializer.thrownType);
 		
 		this.name = name;
 		this.type = type;

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

 	public Statement content;
 	
 	public WhileStatement(CodePosition position, String label, Expression condition) {
-		super(position, label);
+		super(position, label, null); // TODO: thrown type
 		
 		this.condition = condition;
 	}

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

 
 import java.util.Map;
 import java.util.Objects;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 		return true;
 	}
 	
+	@Override
+	public boolean isDefinition(HighLevelDefinition definition) {
+		return baseType.isDefinition(definition);
+	}
+	
 	@Override
 	public ITypeID unwrap() {
 		return baseType;

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

 		return definition instanceof VariantDefinition;
 	}
 	
+	@Override
+	public boolean isDefinition(HighLevelDefinition definition) {
+		return definition == this.definition;
+	}
+	
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
 		if (typeParameters != null) {

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

 import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import static org.openzen.zenscript.codemodel.type.member.TypeMembers.MODIFIER_CONST;
 import static org.openzen.zenscript.codemodel.type.member.TypeMembers.MODIFIER_OPTIONAL;
 	private final Map<ITypeID, ConstTypeID> constTypes = new HashMap<>();
 	private final Map<ITypeID, OptionalTypeID> optionalTypes = new HashMap<>();
 	
-	public GlobalTypeRegistry() {
+	public final ZSPackage stdlib;
+	
+	public GlobalTypeRegistry(ZSPackage stdlib) {
+		this.stdlib = stdlib;
+		
 		arrayTypes.put(ArrayTypeID.INT, ArrayTypeID.INT);
 		arrayTypes.put(ArrayTypeID.CHAR, ArrayTypeID.CHAR);
 		
 		}
 	}
 	
-	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, ITypeID[] genericArguments) {
+	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, ITypeID... genericArguments) {
 		return this.getForDefinition(definition, genericArguments, Collections.emptyMap());
 	}
 	

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

 package org.openzen.zenscript.codemodel.type;
 
 import java.util.Map;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 
 		return false;
 	}
 	
+	public default boolean isDefinition(HighLevelDefinition definition) {
+		return false;
+	}
+	
 	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments);
 	
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters);

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

 
 import java.util.Map;
 import java.util.Objects;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 		return baseType.isObjectType();
 	}
 	
+	@Override
+	public boolean isDefinition(HighLevelDefinition definition) {
+		return baseType.isDefinition(definition);
+	}
+	
 	@Override
 	public ITypeID unwrap() {
 		return baseType;

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

 			}
 			
 			for (int i = 0; i < header.parameters.length; i++) {
-				if (arguments.arguments[i].getType() != header.parameters[i].type)
+				if (arguments.arguments[i].type != header.parameters[i].type)
 					continue outer;
 			}
 			
 			}
 			
 			for (int i = 0; i < header.parameters.length; i++) {
-				if (!scope.getTypeMembers(arguments.arguments[i].getType()).canCastImplicit(header.parameters[i].type))
+				if (!scope.getTypeMembers(arguments.arguments[i].type).canCastImplicit(header.parameters[i].type))
 					continue outer;
 			}
 			

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

 	private final GlobalTypeRegistry registry;
 	private final TypeMembers members;
 	private final LocalMemberCache cache;
-
+	
 	public TypeMemberBuilder(GlobalTypeRegistry registry, TypeMembers members, LocalMemberCache cache) {
 		this.registry = registry;
 		this.members = members;
 		
 		ClassDefinition definition = new ClassDefinition(BUILTIN, null, "", Modifiers.EXPORT);
 		members.addConstructor(new ConstructorMember(BUILTIN, definition, 0, new FunctionHeader(VOID)));
-		members.addMethod(new MethodMember(BUILTIN, definition, 0, "getOptional", new FunctionHeader(map.keys, registry.getOptional(valueType), new FunctionParameter[0])));
-		members.addMethod(new MethodMember(BUILTIN, definition, 0, "put", new FunctionHeader(map.keys, BasicTypeID.VOID, new FunctionParameter(valueType))));
-		members.addMethod(new MethodMember(BUILTIN, definition, 0, "contains", new FunctionHeader(map.keys, BasicTypeID.BOOL, new FunctionParameter[0])));
+		members.addMethod(new MethodMember(BUILTIN, definition, 0, "getOptional", new FunctionHeader(map.keys, registry.getOptional(valueType), null, new FunctionParameter[0])));
+		members.addMethod(new MethodMember(BUILTIN, definition, 0, "put", new FunctionHeader(map.keys, BasicTypeID.VOID, null, new FunctionParameter(valueType))));
+		members.addMethod(new MethodMember(BUILTIN, definition, 0, "contains", new FunctionHeader(map.keys, BasicTypeID.BOOL, null, new FunctionParameter[0])));
 		members.addGetter(new GetterMember(BUILTIN, definition, Modifiers.PUBLIC | Modifiers.EXTERN, "objectHashCode", BasicTypeID.INT));
 		return null;
 	}

Constructor/libraries/collections/src/LinkedList.zs

 		var node = first;
 		while index > 0 {
 			if node == null
-				throw new NoSuchElementException("index out of bounds");
+				return panic<T>("index out of bounds");
 			
 			node = node.next;
 		}
 		
 		if node == null
-			throw new NoSuchElementException("index out of bounds");
+			return panic<T>("index out of bounds");
 		
 		return node.value;
 	}
 	public implements Queue<T> {
 		poll() as T {
 			if first == null
-				throw new NoSuchElementException("Cannot poll an empty queue");
+				return panic<T>("Cannot poll an empty queue");
 			
 			val result = first.value;
 			first = first.next;

Constructor/libraries/io/src/IOException.zs

+public class IOException : Exception {
+	public this(message as string) {
+		super(message);
+	}
+	
+	/*public this(message as string, cause as Exception) {
+		super(message, cause);
+	}*/
+}

Constructor/libraries/io/src/Reader.zs

 export interface Reader {
 	~this;
 	
-	read() as int;
+	read() as int throws IOException;
 	
-	read(buffer as char[]) as int
+	read(buffer as char[]) as int throws IOException
 		=> read(buffer, 0, buffer.length);
 	
-	read(buffer as char[], offset as int, length as int) as int;
+	read(buffer as char[], offset as int, length as int) as int throws IOException;
 }

Constructor/libraries/stdlib/src/Result.zs

 export variant Result<T, E> {
-	Success(T),
-	Failure(E);
+	Ok(T),
+	Error(E);
 	
 	public then<R>(fn as function(result as T) as R) as Result<R, E> {
 		return match this {
-			Success(result) => Success(fn(result)),
-			Failure(error) => Failure(error)
+			Ok(result) => Ok(fn(result)),
+			Error(error) => Error(error)
 		};
 	}
 	
 	public handle<X>(handler as function(error as E) as Result<T, X>) as Result<T, X> {
 		return match this {
-			Success(result) => Success(result),
-			Failure(error) => handler(error)
+			Ok(result) => Ok(result),
+			Error(error) => handler(error)
 		};
 	}
 	
 	public expect() as T {
 		return match this {
-			Success(result) => result,
-			Failure(error) => panic<T>("demand with error value")
+			Ok(result) => result,
+			Error(error) => panic<T>("demand with error value")
+		};
+	}
+	
+	public orElse(other as T) as T {
+		return match this {
+			Ok(result) => result,
+			Error(error) => other
+		};
+	}
+	
+	public orElse(other as function(error as E) as T) as T {
+		return match this {
+			Ok(result) => result,
+			Error(error) => other(error)
 		};
 	}
 }
 export expand <T, E : Exception> Result<T, E> {
 	public unwrap() as T {
 		return match this {
-			Success(result) => result,
-			Failure(error) => { throw error; }
+			Ok(result) => result,
+			Error(error) => { throw error; }
 		};
 	}
 }

Constructor/src/main/java/org/openzen/zenscript/constructor/module/ModuleSpace.java

  * @author Hoofdgebruiker
  */
 public class ModuleSpace {
-	public final GlobalTypeRegistry typeRegistry = new GlobalTypeRegistry();
-	public final ZSPackage globalsPackage = new ZSPackage("");
 	private final ZSPackage rootPackage = new ZSPackage("");
+	private final ZSPackage stdlib = new ZSPackage("");
+	public final GlobalTypeRegistry typeRegistry = new GlobalTypeRegistry(stdlib);
+	public final ZSPackage globalsPackage = new ZSPackage("");
 	private final List<ExpansionDefinition> expansions = new ArrayList<>();
 	private final Map<String, ISymbol> globals = new HashMap<>();
 	

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

         return null;
     }
 
+	@Override
+	public Void visitTryConvert(TryConvertExpression expression) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Void visitTryRethrowAsException(TryRethrowAsExceptionExpression expression) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Void visitTryRethrowAsResult(TryRethrowAsResultExpression expression) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+	
+	@Override
+	public Void visitVariantValue(VariantValueExpression expression) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
     @Override
     public Void visitWrapOptional(WrapOptionalExpression expression) {
-        //TODO What am I supposed to do here?
+		// TODO: convert basic types (char, int, float, ...) to their boxed (Character, Integer, Float, ...) counterparts
+		// -- any object type values can just be passed as-is
         expression.value.accept(this);
         return null;
     }