Initial commit.

.gitignore

@@ -0,0 +1 @@
+outputJava/

codemodel/module.json

@@ -0,0 +1,8 @@
+{
+	"package": "org.openzen.zencode.codemodel",
+	"host": "universal",
+	"dependencies": [
+		"collections",
+		"shared"
+	]
+}

codemodel/src/AccessScope.zs

@@ -0,0 +1 @@
+export class AccessScope {}

codemodel/src/CompareType.zs

@@ -0,0 +1,18 @@
+export enum CompareType {
+	LT("<"),
+	GT(">"),
+	EQ("=="),
+	NE("!="),
+	LE("<="),
+	GE(">="),
+	SAME("==="),
+	NOTSAME("!==");
+	
+	val str as string;
+	
+	this(str as string) {
+		this.str = str;
+	}
+
+	public as string => str;
+}

codemodel/src/FunctionHeader.zs

@@ -0,0 +1,223 @@
+import .expression.CallArguments;
+import .expression.Expression;
+import .generic.TypeParameter;
+import .scope.TypeScope;
+import .type.BasicTypeID;
+import .type.GlobalTypeRegistry;
+import .type.ITypeID;
+import .type.member.LocalMemberCache;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class FunctionHeader {
+	static val NO_PARAMETERS as FunctionParameter[] = new FunctionParameter[](0);
+	static val NO_TYPE_PARAMETERS as TypeParameter[] = new TypeParameter[](0);
+	
+	val typeParameters as TypeParameter[] : get;
+	val returnType as ITypeID : get;
+	val parameters as FunctionParameter[] : get;
+	val thrownType as ITypeID : get;
+	
+	public this(returnType as ITypeID) {
+		this.typeParameters = NO_TYPE_PARAMETERS;
+		this.returnType = returnType;
+		this.parameters = NO_PARAMETERS;
+		this.thrownType = BasicTypeID.VOID;
+	}
+	
+	public this(returnType as ITypeID, parameters... as ITypeID) {
+		this.typeParameters = NO_TYPE_PARAMETERS;
+		this.returnType = returnType;
+		this.parameters = parameters.map(parameter => new FunctionParameter(parameter, null));
+		this.thrownType = BasicTypeID.VOID;
+	}
+	
+	public this(returnType as ITypeID, parameters... as FunctionParameter) {
+		this.typeParameters = NO_TYPE_PARAMETERS;
+		this.returnType = returnType;
+		this.parameters = parameters;
+		this.thrownType = BasicTypeID.VOID;
+	}
+	
+	public this(typeParameters as TypeParameter[], returnType as ITypeID, thrownType as ITypeID, parameters... as FunctionParameter) {
+		this.typeParameters = typeParameters;
+		this.returnType = returnType;
+		this.parameters = parameters;
+		this.thrownType = thrownType;
+	}
+
+	public get numberOfTypeParameters as int
+		=> typeParameters.length;
+	
+	public get doesThrow as bool
+		=> thrownType != BasicTypeID.VOID;
+	
+	public instance(registry as GlobalTypeRegistry, mapping as ITypeID[TypeParameter]) as FunctionHeader {
+		val genericParameters = this.typeParameters.map(parameter => parameter.withGenericArguments(registry, mapping));
+		val returnType = this.returnType.withGenericArguments(registry, mapping);
+		val parameters = this.parameters.map(parameter => parameter.withGenericArguments(registry, mapping));
+		val thrownType = this.thrownType.withGenericArguments(registry, mapping);
+		return new FunctionHeader(genericParameters, returnType, thrownType, parameters);
+	}
+	
+	public inferTypes(cache as LocalMemberCache, arguments as CallArguments, resultHint as ITypeID[]) as ITypeID[]? {
+		if arguments.arguments.length != this.parameters.length
+			return null;
+		
+		val mapping = new ITypeID[TypeParameter];
+		if !resultHint.empty {
+			val temp = new ITypeID[TypeParameter];
+			for hint in resultHint {
+				if returnType.inferTypeParameters(cache, hint, temp) {
+					mapping = temp;
+					break;
+				}
+			}
+		}
+		
+		// TODO: lambda header inference
+		for i, parameter in parameters
+			if !parameter.type.inferTypeParameters(cache, argument.arguments[i].type, mapping)
+				return null;
+		
+		if mapping.size > typeParameters.length
+			return null;
+		
+		val result = new ITypeID[](typeParameters.length);
+		for i, typeParameter in typeParameters {
+			if typeParameter !in mapping
+				return null;
+			
+			result[i] = mapping[typeParameter];
+		}
+		
+		return result;
+	}
+	
+	public hasInferenceBlockingTypeParameters(parameters as TypeParameter[]) as bool
+		=> this.parameters
+			.contains((i, parameter) => parameter.type.hasInferenceBlockingTypeParameters(parameters));
+	
+	public canCastTo(scope as TypeScope, header as FunctionHeader) as bool {
+		if parameters.length != header.parameters.length
+			return false; // TODO: check type argument compatibility
+		
+		if !scope.getTypeMembers(returnType).canCastImplicit(header.returnType)
+			return false;
+		
+		return !parameters.contains((i, parameter)
+			=> !scope.getTypeMembers(header.parameters[i].type).canCastImplicit(parameter.type));
+	}
+	
+	public accepts(scope as TypeScope, arguments... as Expression) as bool {
+		if parameters.length != arguments.length
+			return false;
+		
+		return !arguments.contains((i, argument) => !scope
+			.getTypeMembers(argument.type)
+			.canCastImplicit(parameters[i].type));
+	}
+	
+	/**
+	 * Checks if two function headers are equivalent. Functions headers are
+	 * equivalent if their types are the same.
+	 * 
+	 * @param other
+	 * @return 
+	 */
+	public isEquivalentTo(other as FunctionHeader) as bool {
+		if parameters.length != other.parameters.length
+			return false;
+		
+		return !parameters.contains((i, parameter) => parameter.type !== other.parameters[i].type);
+	}
+	
+	/**
+	 * Checks if two function headers are similar. "similar" means that there
+	 * exists a set of parameters for which there is no way to determine which
+	 * one to call.
+	 * 
+	 * Note that this does not mean that there is never confusion about which
+	 * method to call. There can be confusion due to implicit conversions. This
+	 * can be resolved by performing the conversions explicitly.
+	 * 
+	 * It is illegal to have two similar methods with the same name.
+	 * 
+	 * @param other
+	 * @return 
+	 */
+	public isSimilarTo(other as FunctionHeader) as bool {
+		val common = int.min(parameters.length, other.parameters.length);
+		for i in 0 .. common
+			if parameters[i].type !== other.parameters[i].type
+				return false;
+		
+		for i in common .. parameters.length
+			if parameters[i].defaultValue == null
+				return false;
+		
+		for i in common .. other.parameters.length
+			if other.parameters[i].defaultValue == null
+				return false;
+		
+		return true;
+	}
+	
+	public withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as FunctionHeader {
+		val returnType = this.returnType.withGenericArguments(registry, arguments);
+		val parameters = this.parameters.map(parameter => {
+			val modified = parameter.type.withGenericArguments(registry, arguments);
+			return modified == parameter.type ? parameter : new FunctionParameter(modified, parameter.name);
+		});
+		return new FunctionHeader(
+			typeParameters,
+			returnType,
+			thrownType.withGenericArguments(registry, arguments),
+			parameters);
+	}
+	
+	public withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[]) as FunctionHeader {
+		val typeArguments = new ITypeID[TypeParameter];
+		for i, typeParameter in typeParameters
+			typeArguments[typeParameter] = arguments[i];
+		
+		return withGenericArguments(registry, typeArguments);
+	}
+	
+	public forTypeParameterInference() as FunctionHeader {
+		return new FunctionHeader(BasicTypeID.UNDETERMINED, parameters);
+	}
+	
+	public forLambda(lambdaHeader as FunctionHeader) as FunctionHeader {
+		val parameters = lambdaHeader.parameters
+			.map((i, parameter) => new FunctionParameter(this.parameters[i].type, parameter.name));
+		return new FunctionHeader(typeParameters, returnType, thrownType, parameters);
+	}
+	
+	public getVariadicParameter() as FunctionParameter?
+		=> !parameters.empty && parameters.last.variadic ? parameters.last : null;
+	
+	public explainWhyIncompatible(scope as TypeScope, arguments as CallArguments) as string {
+		if this.parameters.length != arguments.arguments.length
+			return parameters.length + " parameters expected but " + arguments.arguments.length + " given.";
+		
+		if numberOfTypeParameters != arguments.numberOfTypeArguments
+			return numberOfTypeParameters + " type parameters expected but " + arguments.numberOfTypeArguments + " given.";
+		
+		for i, parameter in parameters
+			if !scope.getTypeMembers(arguments.arguments[i].type).canCastImplicit(parameter.type)
+				return "Parameter " + i + ": cannot cast " + arguments.arguments[i].type + " to " + parameter.type;
+		
+		return "Method should be compatible";
+	}
+	
+	public as string {
+		val result = new StringBuilder();
+		if typeParameters.length > 0
+			result << '<' << typeParameters.map(param => param as string).join(', ') << '>';
+		result << '(' << parameters.map(parameter => parameter as string).join(', ') < ')';
+		return result as string;
+	}
+}

codemodel/src/FunctionParameter.zs

@@ -0,0 +1,57 @@
+import .expression.Expression;
+import .generic.TypeParameter;
+import .type.GlobalTypeRegistry;
+import .type.ITypeID;
+import shared.Taggable;
+
+export class FunctionParameter : Taggable {
+	static val NONE as FunctionParameter[] : get = [];
+	
+	val type as ITypeID : get;
+	val name as string : get;
+	val defaultValue as Expression : get;
+	val variadic as bool : get;
+	
+	public this(type as ITypeID) {
+		this.type = type;
+		this.name = "";
+		this.defaultValue = null;
+		this.variadic = false;
+	}
+	
+	public this(type as ITypeID, name as string) {
+		this.type = type;
+		this.name = name;
+		this.defaultValue = null;
+		this.variadic = false;
+	}
+	
+	public this(type as ITypeID, name as string, defaultValue as Expression, variadic as bool) {
+		this.type = type;
+		this.name = name;
+		this.defaultValue = defaultValue;
+		this.variadic = variadic;
+	}
+	
+	public withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as FunctionParameter
+		=> new FunctionParameter(type.withGenericArguments(registry, arguments), name, defaultValue, variadic);
+	
+	public as string
+		=> name + " as " + type as string;
+
+	public implements Hashable<FunctionParameter> {
+		hashCode() as int {
+			var hash = 5;
+			hash = 17 * hash + this.type.hashCode();
+			hash = 17 * hash + (this.variadic ? 1 : 0);
+			return hash;
+		}
+
+		equals(other as FunctionParameter) {
+			if this === other
+				return true;
+			
+			return this.type == other.type && this.variadic == other.variadic;
+		}
+	}
+}

codemodel/src/GenericName.zs

@@ -0,0 +1,31 @@
+import .type.ITypeID;
+
+export struct GenericName {
+	val name as string : get;
+	val arguments as ITypeID[] : get;
+	
+	public this(name as string) {
+		this(name, []);
+	}
+	
+	public this(name as string, arguments as ITypeID[]) {
+		this(name, arguments);
+	}
+	
+	public get numberOfArguments as int
+		=> arguments.length;
+	
+	public get hasArguments as bool
+		=> !arguments.empty;
+	
+	public get hasNoArguments as bool
+		=> arguments.empty;
+		
+	public as string {
+		val result = new StringBuilder();
+		result << name;
+		if hasArguments
+			result << '<' << arguments.map(argument => argument as string).join(', ') << '>';
+		return result as string;
+	}
+}

codemodel/src/HighLevelDefinition.zs

@@ -0,0 +1,65 @@
+import .definition.DefinitionVisitor;
+import .generic.TypeParameter;
+import .member.ConstructorMember;
+import .member.EnumConstantMember;
+import .member.FieldMember;
+import .member.IDefinitionMember;
+import .type.ITypeID;
+import shared.CodePosition;
+import shared.Taggable;
+
+public abstract class HighLevelDefinition : Taggable {
+	val position as CodePosition : get;
+	val package as ZSPackage : get;
+	val name as string : get;
+	val modifiers as int : get;
+	val members as IDefinitionMember[] : get;
+	val typeParameters as TypeParameter[] : get = [];
+	
+	val outerDefinition as HighLevelDefinition? : get;
+	val superType as ITypeID? : get, set;
+	
+	public this(
+			position as CodePosition,
+			package as ZSPackage,
+			name as string,
+			modifiers as int,
+			outerDefinition as HighLevelDefinition?)
+	{
+		this.position = position;
+		this.pkg = pkg;
+		this.name = name;
+		this.modifiers = modifiers;
+		this.outerDefinition = outerDefinition;
+		
+		package.register(this);
+	}
+	
+	public get numerOfTypeParameters as int
+		=> genericParameters.length;
+	
+	public set outerDefinition as HighLevelDefinition
+		=> outerDefinition = $;
+	
+	public get isInnerDefinition
+		=> outerDefinition != null;
+	
+	public addMember(member as IDefinitionMember) as void {
+		if member !in members
+			members.add(member);
+	}
+	
+	public set typeParameters as TypeParameter[]
+		=> typeParameters = $;
+	
+	public get fields as FieldMember[]
+		=> members.filter(member => member is FieldMember).map(member as FieldMember);
+	
+	public get hasEmptyConstructor as bool 
+		=> members.contains(member
+			=> (member is ConstructorMember) && (member as ConstructorMember).header.parameters.empty);
+	
+	public get isStatic => (modifiers & Modifiers.STATIC) > 0;
+	
+	public abstract accept<T>(visitor as DefinitionVisitor<T>) as T;
+}

codemodel/src/WhitespaceInfo.zs

@@ -0,0 +1,16 @@
+export struct WhitespaceInfo {
+	public static from(whitespaceBefore as string, lineAfter as string, skipLineBefore as bool) as WhitespaceInfo {
+		val numNewLines = whitespaceBefore.characters.count(c => c == '\n');
+		val commentsBefore = whitespaceBefore
+			.split('\n')
+			.map(value => value.trim())
+			.filter(value => !value.empty);
+		
+		val emptyLine = !skipLineBefore && numNewLines - commentsBefore.length > 0;
+		return { emptyLine, commentsBefore, lineAfter.trim() };
+	}
+	
+	val emptyLine as bool : get;
+	val commentsBefore as string[] : get;
+	val commentsAfter as string : get;
+}

codemodel/src/ZSPackage.zs

@@ -0,0 +1,107 @@
+import shared.CompileException;
+import shared.CompileExceptionCode;
+import .HighLevelDefinition;
+import .partial.IPartialExpression;
+import .partial.PartialPackageExpression;
+import .partial.PartialTypeExpression;
+import .scope.TypeScope;
+import .type.GenericName;
+import .type.GlobalTypeRegistry;
+import .type.ITypeID;
+import shared.CodePosition;
+
+export class ZSPackage {
+	val fullName as string : get;
+	val subPackages as ZSPackage[string] = {};
+	val types as HighLevelDefinition[string] = {};
+	
+	public this(fullName as string) {
+		this.fullName = fullName;
+	}
+	
+	public add(name as string, package as ZSPackage) as void {
+		if name in subPackages
+			panic("Such package already exists: " + name);
+		
+		subPackages[name] = package;
+	}
+	
+	public getMember(position as CodePosition, registry as GlobalTypeRegistry, name as GenericName) as IPartialExpression {
+		if name.name in subPackages && name.hasNoArguments
+			return new PartialPackageExpression(position, subPackages[name.name]);
+		
+		if name.name in types {
+			if types[name.name].genericParameters.length != name.numberOfArguments
+				throw new CompileException(position, TYPE_ARGUMENTS_INVALID_NUMBER, "Invalid number of type arguments");
+			
+			return new PartialTypeExpression(position, registry.getForDefinition(types[name.name], name.arguments), name.arguments);
+		}
+		
+		return null;
+	}
+	
+	public in(name as string) as bool
+		=> name in types || name in subPackages;
+	
+	public getDefinition(name as string) as HighLevelDefinition?
+		=> types.getOrDefault(name);
+	
+	public getImport(name as string[], depth as int) as HighLevelDefinition? {
+		if depth >= name.length
+			return null;
+		
+		if name[depth] in subPackages
+			return subPackages[name[depth]].getImport(name, depth + 1);
+		
+		if depth == name.length - 1 && name[depth] in types
+			return types[name[depth]];
+		
+		return null;
+	}
+	
+	public getType(position as CodePosition, scope as TypeScope, nameParts as GenericName[]) as ITypeID?
+		=> getType(position, scope, nameParts, 0);
+	
+	public getType(position as CodePosition, scope as TypeScope, name as GenericName) as ITypeID? {
+		if name.name in types
+			return scope.getTypeRegistry().getForDefinition(types[name.name], name.arguments);
+		
+		return null;
+	}
+	
+	private getType(position as CodePosition, scope as TypeScope, nameParts as GenericName[], depth as int) as ITypeID? {
+		if depth >= nameParts.length
+			return null;
+		
+		val name = nameParts[depth];
+		if name.name in subPackages && name.hasNoArguments
+			return subPackages[name.name].getType(position, scope, nameParts, depth + 1);
+		
+		if name.name in types {
+			var type = scope.getTypeRegistry().getForDefinition(types[name.name], name.arguments);
+			depth++;
+			while depth < nameParts.length {
+				val innerName = nameParts[depth++];
+				type = scope.getTypeMembers(type).getInnerType(position, innerName);
+				if type == null
+					return null;
+			}
+			
+			return type;
+		}
+		
+		return null;
+	}
+	
+	public getOrCreatePackage(name as string) as ZSPackage {
+		if name in subPackages
+			return subPackages[name];
+		
+		val result = new ZSPackage(fullName.empty ? name : fullName + '.' + name);
+		subPackages[name] = result;
+		return result;
+	}
+	
+	public register(definition as HighLevelDefinition) as void
+		=> types[definition.name] = definition;
+}

codemodel/src/definition/AliasDefinition.zs

@@ -0,0 +1,20 @@
+import .HighLevelDefinition;
+import .type.ITypeID;
+import shared.CodePosition;
+
+export class AliasDefinition : HighLevelDefinition {
+	var type as ITypeID : get, set;
+	
+	public this(
+		position as CodePosition,
+		packages as ZSPackage,
+		name as string,
+		modifiers as int,
+		outerDefinition as HighLevelDefinition)
+	{
+		super(position, pkg, name, modifiers, outerDefinition);
+	}
+	
+	override accept<T>(visitor as DefinitionVisitor<T>) as T
+		=> visitor.visitAlias(this);
+}

codemodel/src/definition/ClassDefinition.zs

@@ -0,0 +1,16 @@
+import .HighLevelDefinition;
+import .type.ITypeID;
+import shared.CodePosition;
+
+export class ClassDefinition : HighLevelDefinition {
+	public this(position as CodePosition, package as ZSPackage, name as string, modifiers as int) {
+		this(position, pkg, name, modifiers, null);
+	}
+	
+	public this(position as CodePosition, package as ZSPackage, name as string, modifiers as int, outerDefinition as HighLevelDefinition) {
+		super(position, pkg, name, modifiers, outerDefinition);
+	}
+
+	override accept<T>(visitor as DefinitionVisitor<T>) as T
+		=> visitor.visitClass(this);
+}

codemodel/src/definition/DefinitionVisitor.zs

@@ -0,0 +1,17 @@
+export interface DefinitionVisitor<T> {
+	visitClass(definition as ClassDefinition) as T;
+	
+	visitInterface(definition as InterfaceDefinition) as T;
+	
+	visitEnum(definition as EnumDefinition) as T;
+	
+	visitStruct(definition as StructDefinition) as T;
+	
+	visitFunction(definition as FunctionDefinition) as T;
+	
+	visitExpansion(definition as ExpansionDefinition) as T;
+	
+	visitAlias(definition as AliasDefinition) as T;
+	
+	visitVariant(definition as VariantDefinition) as T;
+}

codemodel/src/definition/EnumDefinition.zs

@@ -0,0 +1,23 @@
+import .HighLevelDefinition;
+import .member.EnumConstantMember;
+import shared.CodePosition;
+
+export class EnumDefinition : HighLevelDefinition {
+	val enumConstants as EnumConstantMember[] : get = [];
+	
+	public this(
+		position as CodePosition,
+		package as ZSPackage,
+		name as string,
+		modifiers as int,
+		outerDefinition as HighLevelDefinition)
+	{
+		super(position, pkg, name, modifiers, outerDefinition);
+	}
+
+	override accept<T>(visitor as DefinitionVisitor<T>) as T
+		=> visitor.visitEnum(this);
+	
+	public addEnumConstant(constant as EnumConstantMember) as void
+		=> enumConstants.add(constant);
+}

codemodel/src/definition/ExpansionDefinition.zs

@@ -0,0 +1,19 @@
+import .HighLevelDefinition;
+import .type.ITypeID;
+import shared.CodePosition;
+
+export class ExpansionDefinition : HighLevelDefinition {
+	val target as ITypeID : get;
+	
+	public this(
+		position as CodePosition,
+		package as ZSPackage,
+		modifiers as int,
+		outerDefinition as HighLevelDefinition)
+	{
+		super(position, pkg, null, modifiers, outerDefinition);
+	}
+	
+	override accept<T>(visitor as DefinitionVisitor<T>) as T
+		=> visitor.visitExpansion(this);
+}

codemodel/src/definition/FunctionDefinition.zs

@@ -0,0 +1,52 @@
+import .FunctionHeader;
+import .HighLevelDefinition;
+import .Modifiers;
+import .member.CallerMember;
+import .statement.Statement;
+import .type.member.DefinitionMemberGroup;
+import .type.member.TypeMemberPriority;
+import shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class FunctionDefinition : HighLevelDefinition {
+	val _header as FunctionHeader;
+	val statement as Statement : get;
+	val caller as CallerMember : get;
+	val callerGroup as DefinitionMemberGroup : get;
+	
+	public this(
+		position as CodePosition,
+		package as ZSPackage,
+		name as string,
+		modifiers as int,
+		outerDefinition as HighLevelDefinition?)
+	{
+		super(position, pkg, name, modifiers, outerDefinition);
+		callerGroup = new DefinitionMemberGroup(true, name);
+	}
+	
+	public this(position as CodePosition, package as ZSPackage, name as string, modifiers as int, header as FunctionHeader) {
+		this(position, pkg, name, modifiers, null as HighLevelDefinition?);
+		setHeader(header);
+	}
+	
+	public get header as FunctionDefinition
+		=> _header;
+	
+	public set header as FunctionDefinition {
+		_header = $;
+		addMember(caller = new CallerMember(position, this, modifiers | Modifiers.STATIC, $));
+		callerGroup.addMethod(caller, SPECIFIED);
+	}
+	
+	public set code as Statement {
+		this.statement = $;
+		caller.setBody($);
+	}
+
+	override accept<T>(visitor) as T
+		=> visitor.visitFunction(this);
+}

codemodel/src/expression/CallArguments.zs

@@ -0,0 +1,35 @@
+import .type.ITypeID;
+
+export class CallArguments {
+	static val NO_TYPE_ARGUMENTS as ITypeID[] : get = new ITypeID[](0);
+	static val EMPTY as CallArguments : get = new CallArguments(new Expression[](0));
+	
+	val typeArguments as ITypeID[] : get;
+	val arguments as Expression[] : get;
+	
+	public this(arguments... as Expression) {
+		this.typeArguments = NO_TYPE_ARGUMENTS;
+		this.arguments = arguments;
+	}
+	
+	public this(typeArguments as ITypeID[], arguments as Expression[]) {
+		this.typeArguments = typeArguments;
+		this.arguments = arguments;
+	}
+	
+	public get numberOfTypeArguments as int
+		=> typeArguments.length;
+	
+	public normalize(position as CodePosition, scope as TypeScope, header as FunctionHeader) as CallArguments {
+		var newArguments = arguments.map((i, argument) => argument.castImplicit(position, scope, header.parameters[i].type));
+		if (arguments.length < header.parameters.length) {
+			newArguments = newArguments.resize(arguments, i => {
+				if header.parameters[i].defaultValue == null
+					throw new CompileException(position, CompileExceptionCode.MISSING_PARAMETER, "Parameter missing and no default value specified");
+				
+				return header.parameters[i].defaultValue;
+			});
+		}
+		return new CallArguments(typeArguments, newArguments);
+	}
+}

codemodel/src/expression/Expression.zs

@@ -0,0 +1,67 @@
+public abstract class Expression {
+	val position as CodePosition : get;
+	val type as ITypeID : get;
+	val thrownType as ITypeID : get;
+	
+	public this(position as CodePosition, type as ITypeID, thrownType as ITypeID) {
+		this.position = position;
+		this.type = type;
+		this.thrownType = thrownType;
+	}
+	
+	public abstract accept<T>(visitor as ExpressionVisitor<T>) as T;
+	
+	public castExplicit(position as CodePosition, scope as TypeScope, asType as ITypeID, optional as bool) as Expression
+		=> scope.getTypeMembers(type).castExplicit(position, this, asType, optional);
+	
+	public castImplicit(position as CodePosition, scope as TypeScope, asType as ITypeID) as Expression
+		=> scope.getTypeMembers(type).castImplicit(position, this, asType, true);
+	
+	public implements IPartialExpression {
+		get assignHints as ITypeID[]
+			=> [type];
+		
+		eval() as Expression
+			=> this;
+	
+		predictCallTypes(scope as TypeScope, hints as ITypeID[], arguments as int) as ITypeID[][]
+			=> scope.getTypeMembers(type).getOrCreateGroup(CALL).predictCallTypes(scope, hints, arguments);
+		
+		getPossibleFunctionHeaders(scope as TypeScope, hints as ITypeID[], arguments as int) as FunctionHeader[]
+			=> scope.getTypeMembers(type)
+					.getOrCreateGroup(CALL)
+					.methodMembers
+					.filter(method => method.member.header.parameters.length == arguments && !method.member.isStatic)
+					.map(method => method.member.header);
+		
+		call(position as CodePosition, scope as TypeScope, hints as ITypeID[], arguments as CallArguments) as Expression
+			=> scope.getTypeMembers(type).getOrCreateGroup(CALL).call(position, scope, this, arguments, false);
+		
+		getMember(position as CodePosition, scope as TypeScope, hints as ITypeID[], name as GenericName) as IPartialExpression
+			=> scope.getTypeMembers(type).getMemberExpression(position, this, name, false);
+		
+		getGenericCallTypes() as ITypeID[]?
+			=> null;
+	}
+	
+	public static binaryThrow(position as CodePosition, left as ITypeID?, right as ITypeID?) as ITypeID? {
+		if left == right
+			return left;
+		else if left == null
+			return right;
+		else if right == null
+			return left;
+		
+		throw new CompileException(
+			position,
+			DIFFERENT_EXCEPTIONS,
+			"two different exceptions in same operation: " + left as string + " and " + right as string);
+	}
+	
+	public static multiThrow(position as CodePosition, expressions as Expression[]) as ITypeID? {
+		val result as ITypeID? = null;
+		for expression in expressions
+			result = binaryThrow(position, result, expression.thrownType);
+		return result;
+	}
+}

codemodel/src/generic/GenericParameterBound.zs

@@ -0,0 +1,11 @@
+public interface GenericParameterBound {
+	get isObjectType as bool;
+	
+	registerMembers(cache as LocalMemberCache, type as TypeMembers) as void;
+	
+	matches(cache as LocalMemberCache, type as ITypeID) as bool;
+	
+	withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as GenericParameterBound;
+	
+	accept<T>(visitor as GenericParameterBoundVisitor<T>) as T;
+}

codemodel/src/generic/ParameterSuperBound.zs

@@ -0,0 +1,29 @@
+import .type.ITypeID;
+
+public class ParameterSuperBound {
+	val type as ITypeID : get;
+	
+	public this(type as ITypeID) {
+		this.type = type;
+	}
+	
+	public implements GenericParameterBound {
+		get isObjectType as bool
+			=> true;
+		
+		registerMembers(cache as LocalMemberCache, members as TypeMembers) {
+			// No members to register
+		}
+		
+		matches(cache as LocalMemberCache, type as ITypeID) as bool
+			=> cache[this.type].extendsOrImplements(type);
+
+		withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as GenericParameterBound {
+			val translated = type.withGenericArguments(registry, arguments);
+			return translated === type ? this : new ParameterSuperBound(translated);
+		}
+
+		accept<T>(visitor as GenericParameterBoundVisitor<T>) as T
+			=> visitor.visitSuper(this);
+	}
+}

codemodel/src/generic/ParameterTypeBound.zs

@@ -0,0 +1,29 @@
+import shared.CodePosition;
+import .type.ITypeID;
+
+public class ParameterTypeBound {
+	val position as CodePosition : get;
+	val type as ITypeID : get;
+	
+	public ParameterTypeBound(position as CodePosition, type as ITypeID) {
+		this.position = position;
+		this.type = type;
+	}
+	
+	public implements GenericParameterBound {
+		get isObjectType as bool
+			=> true;
+		
+		registerMembers(cache as LocalMemberCache, type as TypeMembers) as void
+			=> cache[this.type].copyMembersTo(position, type, FROM_TYPE_BOUNDS);
+
+		matches(cache as LocalMemberCache, type as ITypeID) as bool
+			=> cache[type].extendsOrImplements(this.type);
+
+		withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as GenericParameterBound
+			=> new ParameterTypeBound(position, type.withGenericArguments(registry, arguments));
+
+		accept<T>(visitor as GenericParameterBoundVisitor<T>) as T
+			=> visitor.visitType(this);
+	}
+}

codemodel/src/generic/TypeParameter.zs

@@ -0,0 +1,37 @@
+import shared.CodePosition;
+import .type.ITypeID;
+
+export class TypeParameter {
+	val position as CodePosition : get;
+	val name as string : get;
+	var bounds as GenericParameterBound[] : get, set;
+	
+	public this(position as CodePosition, name as string) {
+		this.position = position;
+		this.name = name;
+	}
+	
+	private this(position as CodePosition, name as string, bounds as GenericParameterBound[]) {
+		this.position = position;
+		this.name = name;
+		this.bounds = bounds;
+	}
+	
+	public get isObjectType as bool
+		=> bounds.contains(bound => bound.isObjectType);
+	
+	public matches(cache as LocalMemberCache, type as ITypeID) as bool
+		=> bounds.all(bound => bound.matches(cache, type));
+	
+	public withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as TypeParameter {
+		// TODO: think about this...
+		//List<GenericParameterBound> bounds = new ArrayList<>();
+		//for (GenericParameterBound bound : this.bounds)
+		//	bounds.add(bound.withGenericArguments(registry, arguments));
+		//return new TypeParameter(name, bounds);
+		return this;
+	}
+	
+	public as string
+		=> name + "@" + position.toShortString();
+}

codemodel/src/generic/TypeParameterBoundVisitor.zs

@@ -0,0 +1,5 @@
+public interface GenericParameterBoundVisitor<T> {
+	public visitSuper(bound as ParameterSuperBound) as T;
+	
+	public visitType(bound as ParameterTypeBound) as T;
+}

codemodel/src/scope/TypeScope.zs

@@ -0,0 +1,7 @@
+export interface TypeScope {
+	get typeRegistry as GlobalTypeRegistry;
+	get memberCache as LocalMemberCache;
+	
+	getTypeMembers(type as ITypeID) as TypeMembers
+		=> memberCache[type];
+}

codemodel/src/type/ArrayTypeID.zs

@@ -0,0 +1,52 @@
+import .generic.TypeParameter;
+
+export class ArrayTypeID {
+	static val INT as ArrayTypeID : get = { BasicTypeID.INT, 1 };
+	static val CHAR as ArrayTypeID : get = { BasicTypeID.CHAR, 1 };
+	
+	val elementType as ITypeID : get;
+	val dimension as int : get;
+	
+	public this(elementType as ITypeID, dimension as ITypeID) {
+		this.elementType = elementType;
+		this.dimension = dimension;
+	}
+	
+	public implements ITypeID {
+		get unmodified as ArrayTypeID => this;
+		get isObjectType as bool => true;
+		get hasDefaultValue as bool => true;
+		
+		accept<T>(visitor as ITypeVisitor<T>) as T
+			=> visitor.visitArray(this);
+		
+		withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as ArrayTypeID
+			=> registry.getArray(elementType.withGenericArguments(registry, arguments), dimension);
+
+		hasInferenceBlockingTypeParameters(parameters as TypeParameter[]) as bool
+			=> elementType.hasInferenceBlockingTypeParameters(parameters);
+		
+		hashCode() as int {
+			var hash = 7;
+			hash = 79 * hash + elementType.hashCode();
+			hash = 79 * hash + dimension;
+			return hash;
+		}
+
+		==(other as ITypeID) as bool {
+			if this == other
+				return true;
+			if other !is ArrayTypeID
+				return false;
+			
+			val otherArray = other as ArrayTypeID;
+			return this.dimension == other.dimension && this.elementType === other.elementType;
+		}
+		
+		as string {
+			val result = new StringBuilder();
+			result << elementType as string << '[' << ','.times(dimension - 1) << ']';
+			return result as string;
+		}
+	}
+}

codemodel/src/type/AssocTypeID.zs

@@ -0,0 +1,52 @@
+import .generic.TypeParameter;
+
+export class AssocTypeID {
+	val keyType as ITypeID : get;
+	val valueType as ITypeID : get;
+	
+	public this(keyType as ITypeID, valueType as ITypeID) {
+		this.keyType = keyType;
+		this.valueType = valueType;
+	}
+	
+	public implements ITypeID {
+		get unmodified as AssocTypeID => this;
+		get isObjectType as bool => true;
+		get hasDefaultValue as bool => true;
+		
+		accept<T>(visitor as ITypeVisitor<T>)
+			=> visitor.visitAssoc(this);
+		
+		withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as AssocTypeID
+			=> registry.getAssociative(
+					keyType.withGenericArguments(registry, arguments),
+					valueType.withGenericArguments(registry, arguments));
+		
+		hasInferenceBlockingTypeParameters(parameters as TypeParameter[]) as bool
+			=> keyType.hasInferenceBlockingTypeParameters(parameters)
+				|| valueType.hasInferenceBlockingTypeParameters(parameters);
+
+		hashCode() as int {
+			val hash = 7;
+			hash = 29 * hash + keyType.hashCode();
+			hash = 29 * hash + valueType.hashCode();
+			return hash;
+		}
+		
+		==(other as ITypeID) {
+			if this == other
+				return true;
+			if other !is AssocTypeID
+				return false;
+			
+			val otherAssoc = other as AssocTypeID;
+			return this.keyType === other.keyType && this.valueType === other.valueType;
+		}
+		
+		as string {
+			val result = new StringBuilder();
+			result << valueType as string << '[' << keyType as string << ']';
+			return result as string;
+		}
+	}
+}

codemodel/src/type/BasicTypeID.zs

@@ -0,0 +1,47 @@
+import .generic.TypeParameter;
+
+export enum BasicTypeID {
+	VOID("void"),
+	NULL("null"),
+	ANY("any"),
+	BOOL("bool"),
+	BYTE("byte"),
+	SBYTE("sbyte"),
+	SHORT("short"),
+	USHORT("ushort"),
+	INT("int"),
+	UINT("uint"),
+	LONG("long"),
+	ULONG("ulong"),
+	FLOAT("float"),
+	DOUBLE("double"),
+	CHAR("char"),
+	STRING("string"),
+	
+	UNDETERMINED("undetermined");
+	
+	static val HINT_BOOL as ITypeID[] : get = [BOOL];
+	
+	public val name as string : get;
+	
+	this(name as string) {
+		this.name = name;
+	}
+	
+	public implements ITypeID {
+		get unmodified as ITypeID => this;
+		get isObjectType as bool => this in [ANY, STRING];
+		get hasDefaultValue as bool => true;
+		
+		accept<T>(visitor as ITypeVisitor<T>) as T
+			=> visitor.visitBasic(this);
+		
+		withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as BasicTypeID
+			=> this;
+
+		hasInferenceBlockingTypeParameters(parameters as TypeParameter[])
+			=> false;
+		
+		as string => name;
+	}
+}

codemodel/src/type/ConstTypeID.zs

@@ -0,0 +1,48 @@
+public class ConstTypeID {
+	val baseType as ITypeID : get;
+	
+	public this(baseType as ITypeID) {
+		this.baseType = baseType;
+	}
+	
+	public implements ITypeID {
+		get unmodified as ITypeID => baseType.unmodified;
+		get isConst as bool => true;
+		get isOptional as bool => baseType.isOptional;
+		get isObjectType as bool => baseType.isObjectType;
+		get hasDefaultValue as bool => baseType.hasDefaultValue;
+		
+		accept<T>(visitor as ITypeVisitor<T>)
+			=> visitor.visitConst(this);
+		
+		withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as ITypeID
+			=> registry.getModified(TypeMembers.MODIFIER_CONST, baseType.withGenericArguments(registry, arguments));
+		
+		isDefinition(definition as HighLevelDefinition) as bool
+			=> baseType.isDefinition(definition);
+		
+		unwrap() as ITypeID
+			=> baseType;
+
+		hasInferenceBlockingTypeParameters(parameters as TypeParameter[]) as bool
+			=> baseType.hasInferenceBlockingTypeParameters(parameters);
+
+		hashCode() as int {
+			var hash = 3;
+			hash = 79 * hash + baseType.hashCode();
+			return hash;
+		}
+
+		==(other as ITypeID) {
+			if this == other
+				return true;
+			if other !is ConstTypeID
+				return false;
+			
+			val otherConst = other as ConstTypeID;
+			return this.baseType == other.baseType;
+		}
+		
+		as string => "const " + baseType as string;
+	}
+}

codemodel/src/type/DefinitionTypeID.zs

@@ -0,0 +1,146 @@
+import .HighLevelDefinition;
+import .definition.EnumDefinition;
+import .definition.VariantDefinition;
+import .generic.TypeParameter;
+
+export class DefinitionTypeID {
+	public static forType(definition as HighLevelDefinition) as DefinitionTypeID {
+		if definition.genericParameters.length > 0
+			return panic("Definition has type arguments!");
+		
+		return { definition, [] };
+	}
+	
+	static val NO_OUTER_ENTRIES as OuterTypeEntry[] = new OuterTypeEntry[](0);
+	
+	val definition as HighLevelDefinition : get;
+	val typeParameters as ITypeID[] : get;
+	val outerTypeEntries as OuterTypeEntry[] : get;
+	var superType as ITypeID? : get, set;
+	// for nonstatic inner classes of generic types, contains the type parameters for the outer class(es)
+	val outerTypeParameters as ITypeID[TypeParameter];
+	
+	public this(definition as HighLevelDefinition) {
+		this.definition = definition;
+		this.typeParameters = [];
+		this.superType = definition.superType;
+		this.outerTypeParameters = {};
+		this.outerTypeEntries = NO_OUTER_ENTRIES;
+	}
+	
+	public this(definition as HighLevelDefinition, typeParameters as ITypeID[]) {
+		this(definition, typeParameters, {});
+	}
+	
+	// For inner classes of generic outer classes
+	public this(
+			definition as HighLevelDefinition,
+			typeParameters as ITypeID[],
+			outerTypeParameters as ITypeID[TypeParameter]) {
+		this.definition = definition;
+		this.typeParameters = typeParameters;
+		this.outerTypeParameters = outerTypeParameters;
+		
+		if outerTypeParameters.empty {
+			this.outerTypeEntries = NO_OUTER_ENTRIES;
+		} else {
+			this.outerTypeEntries = new OuterTypeEntry[](outerTypeParameters.size);
+			val index = 0;
+			for parameter, type in outerTypeParameters
+				outerTypeEntries[index++] = new OuterTypeEntry(parameter, type);
+			this.outerTypeEntries.sort(outerTypeEntries, (a, b) => a.parameter.name.compareTo(b.parameter.name));
+		}
+	}
+	
+	public get hasTypeParameters as bool
+		=> typeParameters.length > 0;
+	
+	public init(registry as GlobalTypeRegistry) as void {
+		val superType = definition.superType;
+		if superType != null && hasTypeParameters() {
+			val genericSuperArguments = new ITypeID[TypeParameter];
+			for i, typeParameter in typeParameters
+				genericSuperArguments[definition.genericParameters[i]] = typeParameter;
+			superType = definition.superType.withGenericArguments(registry, genericSuperArguments);
+		}
+		this.superType = superType;
+	}
+	
+	public implements ITypeID {
+		get unmodified as ITypeID => this;
+		get isObjectType as bool => true;
+		get isEnum as bool => definition is EnumDefinition;
+		get isVariant as bool => definition is VariantDefinition;
+		get hasDefaultValue => definition.hasEmptyConstructor();
+		
+		accept<T>(visitor as ITypeVisitor<T>) as T
+			=> visitor.visitDefinition(this);
+		
+		withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as ITypeID {
+			if !hasTypeParameters && outerTypeParameters.empty
+				return this;
+			
+			val instancedArguments = typeParameters.map(parameter => parameter.withGenericArguments(registry, arguments));
+			val instancedOuter = outerTypeParameters.mapValues(value => value.withGenericArguments(registry, arguments));
+			return registry.getForDefinition(definition, instancedArguments, instancedOuter);
+		}
+		
+		accept<T>(visitor as ITypeVisitor<T>) as T
+			=> visitor.visitDefinition(this);
+		
+		isDefinition(definition as HighLevelDefinition) as bool
+			=> definition === this.definition;
+		
+		hasInferenceBlockingTypeParameters(parameters as TypeParameter[]) as bool
+			=> typeParameters.contains(parameter => parameter.hasInferenceBlockingTypeParameters(parameters))
+				|| (superType != null && superType.hasInferenceBlockingTypeParameters(parameters));
+
+		hashCode() as int {
+			val hash = 7;
+			hash = 97 * hash + definition.hashCode();
+			hash = 97 * hash + typeParameters.hashCode();
+			hash = 97 * hash + outerTypeEntries.hashCode();
+			return hash;
+		}
+
+		==(other as ITypeID) {
+			if this === other
+				return true;
+			
+			if other !is DefinitionTypeID
+				return false;
+			
+			val otherDefinition = other as DefinitionTypeID;
+			return this.definition == otherDefinition.definition
+					&& this.typeParameters.deepEquals(otherDefinition.typeParameters)
+					&& this.outerTypeEntries.deepEquals(otherDefinition.outerTypeEntries);
+		}
+		
+		as string {
+			if typeParameters.empty
+				return definition.name;
+			
+			val result = new StringBuilder();
+			result << definition.name;
+			result << '<' << typeParameters.map(parameter => parameter as string).join(', ') << '>';
+			return result as string;
+		}
+	}
+	
+	private struct OuterTypeEntry {
+		val parameter as TypeParameter;
+		val type as ITypeID;
+		
+		public implements Hashable<OuterTypeEntry> {
+			hashCode() as int {
+				var hash = 3;
+				hash = 11 * hash + Objects.hashCode(this.parameter);
+				hash = 11 * hash + Objects.hashCode(this.type);
+				return hash;
+			}
+			
+			==(other as OuterTypeEntry)
+				=> this === obj || (this.parameter === other.parameter && this.type === other.type);
+		}
+	}
+}

codemodel/src/type/FunctionTypeID.zs

@@ -0,0 +1,53 @@
+import .FunctionHeader;
+import .FunctionParameter;
+import .generic.TypeParameter;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class FunctionTypeID {
+	val header as FunctionHeader : get;
+	
+	public this(header as FunctionHeader) {
+		this.header = header;
+	}
+	
+	public implements ITypeID {
+		get unmodified as FunctionTypeID => this;
+		get isObjectType as bool => true;
+		get hasDefaultValue as bool => false;
+		
+		withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as ITypeID
+			=> registry.getFunction(header.withGenericArguments(registry, arguments));
+		
+		accept<T>(visitor as ITypeVisitor<T>) as T
+			=> visitor.visitFunction(this);
+
+		hasInferenceBlockingTypeParameters(parameters as TypeParameter[])
+			=> header.hasInferenceBlockingTypeParameters(parameters);
+
+		hashCode() as int {
+			var hash = 5;
+			hash = 71 * hash + header.returnType.hashCode();
+			hash = 71 * hash + header.parameters.hashCode();
+			hash = 71 * hash + header.typeParameters.hashCode();
+			return hash;
+		}
+
+		==(other as ITypeID) {
+			if this === other
+				return true;
+			if other !is FunctionTypeID
+				return false;
+			
+			val otherFunction = other as FunctionTypeID;
+			return this.header.returnType == otherFunction.header.returnType
+					&& this.header.parameters == otherFunction.header.parameters
+					&& this.header.typeParameters == otherFunction.header.typeParameters;
+		}
+		
+		as string
+			=> header as string;
+	}
+}

codemodel/src/type/GenericMapTypeID.zs

@@ -0,0 +1,50 @@
+import .generic.TypeParameter;
+
+public class GenericMapTypeID {
+	val value as ITypeID : get;
+	val keys as TypeParameter[] : get;
+	
+	public this(value as ITypeID, keys as TypeParameter[]) {
+		this.value = value;
+		this.keys = keys;
+	}
+	
+	public implements ITypeID {
+		get unmodified as ITypeID => this;
+		get hasDefaultValue as bool => true;
+		get isObjectType as bool => true;
+
+		accept<T>(visitor as ITypeVisitor<T>) as T
+			=> visitor.visitGenericMap(this);
+
+		withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as ITypeID
+			=> registry.getGenericMap(value.withGenericArguments(registry, arguments), keys);
+
+		hasInferenceBlockingTypeParameters(parameters as TypeParameter[]) as bool
+			=> value.hasInferenceBlockingTypeParameters(parameters);
+		
+		as string {
+			val result = new StringBuilder();
+			result << value as string;
+			result << '[<' << keys.map(key => key as string).join(', ') << '>]';
+			return result as string;
+		}
+
+		hashCode() as int {
+			var hash = 5;
+			hash = 97 * hash + this.value.hashCode();
+			hash = 97 * hash + this.keys.hashCode();
+			return hash;
+		}
+		
+		==(other as ITypeID) as bool {
+			if this === other
+				return true;
+			if other !is GenericMapTypeID
+				return false;
+			
+			val otherMap = other as GenericMapTypeID;
+			return this.value == other.value && this.keys == other.keys;
+		}
+	}
+}

codemodel/src/type/GenericTypeID.zs

@@ -0,0 +1,46 @@
+import .generic.TypeParameter;
+import .type.member.LocalMemberCache;
+
+public class GenericTypeID {
+	val parameter as TypeParameter : get;
+
+	public this(parameter as TypeParameter) {
+		this.parameter = parameter;
+	}
+	
+	public matches(cache as LocalMemberCache, type as ITypeID) as bool
+		=> parameter.matches(cache, type);
+	
+	public implements ITypeID {
+		get unmodified as ITypeID => this;
+		get hasDefaultValue as bool => false;
+		get isObjectType as bool => parameter.isObjectType;
+		
+		withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as ITypeID
+			=> arguments.getOrDefault(parameter, this);
+
+		accept<T>(visitor as ITypeVisitor<T>)
+			=> visitor.visitGeneric(this);
+		
+		hasInferenceBlockingTypeParameters(parameters as TypeParameter[]) as bool
+			=> parameter in parameters;
+		
+		hashCode() as int {
+			var hash = 7;
+			hash = 47 * hash + parameter.hashCode();
+			return hash;
+		}
+		
+		==(other as ITypeID) as bool {
+			if this === other
+				return true;
+			if this !is GenericTypeID
+				return false;
+			
+			val otherGeneric = other as GenericTypeID;
+			return this.parameter === otherGeneric.parameter;
+		}
+		
+		as string => parameter as string;
+	}
+}

codemodel/src/type/GlobalTypeRegistry.zs

@@ -0,0 +1,144 @@
+import .FunctionHeader;
+import .HighLevelDefinition;
+import .definition.FunctionDefinition;
+import .definition.ZSPackage;
+import .generic.TypeParameter;
+import .type.members.TypeMembers;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class GlobalTypeRegistry {
+	val arrayTypes as ArrayTypeID[ArrayTypeID] = new ArrayTypeID[ArrayTypeID];
+	val assocTypes as AssocTypeID[AssocTypeID] = new AssocTypeID[AssocTypeID];
+	val genericMapTypes as GenericMapTypeID[GenericMapTypeID] = new GenericMapTypeID[GenericMapTypeID];
+	val iteratorTypes as IteratorTypeID[IteratorTypeID] = new IteratorTypeID[IteratorTypeID];
+	val functionTypes as FunctionTypeID[FunctionTypeID] = new FunctionTypeID[FunctionTypeID];
+	val rangeTypes as RangeTypeID[RangeTypeID] = new RangeTypeID[RangeTypeID];
+	val definitionTypes as DefinitionTypeID[DefinitionTypeID] = new DefinitionTypeID[DefinitionTypeID];
+	val genericTypes as GenericTypeID[GenericTypeID] = new GenericTypeID[GenericTypeID];
+	
+	val constTypes as ConstTypeID[ITypeID] = new ConstTypeID[ITypeID];
+	val optionalTypes as OptionalTypeID[ITypeID] = new OptionalTypeID[ITypeID];
+	
+	val stdlib as ZSPackage : get;
+	
+	public this(stdlib as ZSPackage) {
+		this.stdlib = stdlib;
+		
+		arrayTypes[ArrayTypeID.INT] = ArrayTypeID.INT;
+		arrayTypes[ArrayTypeID.CHAR] = ArrayTypeID.CHAR;
+		
+		rangeTypes[RangeTypeID.INT] = RangeTypeID.INT;
+	}
+	
+	public getArray(baseType as ITypeID, dimension as int) as ArrayTypeID {
+		val type = new ArrayTypeID(baseType, dimension);
+		if type in arrayTypes
+			return arrayTypes[type];
+		
+		arrayTypes[type] = type;
+		return type;
+	}
+	
+	public getAssociative(keyType as ITypeID, valueType as ITypeID) as AssocTypeID {
+		val type = new AssocTypeID(keyType, valueType);
+		if type in assocTypes
+			return assocTypes[type];
+		
+		assocTypes[type] = type;
+		return type;
+	}
+	
+	public getGenericMap(valueType as ITypeID, keys as TypeParameter[]) as GenericMapTypeID {
+		val type = new GenericMapTypeID(valueType, keys);
+		if type in genericMapTypes
+			return genericMapTypes[type];
+			
+		genericMapTypes[type] = type;
+		return type;
+	}
+	
+	public getIterator(loopTypes as ITypeID[]) as IteratorTypeID {
+		val type = new IteratorTypeID(loopTypes);
+		if type in iteratorTypes
+			return iteratorTypes[type];
+		
+		iteratorTypes[type] = type;
+		return type;
+	}
+	
+	public getFunction(header as FunctionHeader) as FunctionTypeID {
+		val type = new FunctionTypeID(header);
+		if type in functionTypes
+			return functionTypes[type];
+		
+		functionTypes[type] = type;
+		return type;
+	}
+	
+	public getRange(from as ITypeID, to as ITypeID) as RangeTypeID {
+		val type = new RangeTypeID(from, to);
+		if type in rangeTypes
+			return rangeTypes[type];
+		
+		rangeTypes[type] = type;
+		return type;
+	}
+	
+	public getGeneric(parameter as TypeParameter) as GenericTypeID {
+		val type = new GenericTypeID(parameter);
+		if type in genericTypes
+			return genericTypes[type];
+		
+		genericTypes[type] = type;
+		return type;
+	}
+	
+	public getForDefinition(definition as HighLevelDefinition, genericArguments... as ITypeID) as DefinitionTypeID
+		=> getForDefinition(definition, genericArguments, {});
+	
+	public getForDefinition(definition as HighLevelDefinition, typeParameters as ITypeID[], outerInstance as ITypeID[TypeParameter]) as DefinitionTypeID {
+		val type = (definition is FunctionDefinition)
+			? new DefinitionTypeID(definition)
+			: new DefinitionTypeID(definition, typeParameters, outerInstance);
+		
+		if type in definitionTypes
+			return definitionTypes[type];
+		
+		definitionTypes[type] = type;
+		type.init(this);
+		return type;
+	}
+	
+	private getConst(original as ITypeID) as ConstTypeID {
+		if original in constTypes
+			return constTypes[original];
+		
+		val type = new ConstTypeID(original);
+		constTypes[original] = type;
+		return type;
+	}
+	
+	public getOptional(original as ITypeID) as OptionalTypeID {
+		if original in optionalTypes
+			return optionalTypes[original];
+		
+		val type = new OptionalTypeID(original);
+		optionalTypes[original] = type;
+		return type;
+	}
+	
+	public getModified(modifiers as int, type as ITypeID) as ITypeID {
+		if modifiers == 0
+			return type;
+		
+		if (modifiers & TypeMembers.MODIFIER_OPTIONAL) > 0
+			return getModified(modifiers & ~TypeMembers.MODIFIER_OPTIONAL, getOptional(type));
+		if (modifiers & MODIFIER_CONST) > 0
+			return getModified(modifiers & ~TypeMembers.MODIFIER_CONST, getConst(type));
+		
+		return panic("Invalid modifier: " + modifiers);
+	}
+}

codemodel/src/type/ITypeID.zs

@@ -0,0 +1,152 @@
+public interface ITypeID : Hashable<ITypeID> {
+	public get unmodified as ITypeID => this;
+	public get superType as ITypeID? => null;
+	public get isOptional as bool => false;
+	public get optionalBase => this;
+	public get isConst as bool => false;
+	public get unwrap as ITypeID => this;
+	public get hasDefaultValue as bool;
+	public get isObjectType as bool;
+	public get isEnum as bool => false;
+	public get isVariant as bool => false;
+	
+	public isDefinition(definition as HighLevelDefinition) as bool
+		=> false;
+	
+	public accept<T>(visitor as ITypeVisitor<T>) as T;
+	
+	public withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as ITypeID;
+	
+	public hasInferenceBlockingTypeParameters(parameters as TypeParameter[]) as bool;
+	
+	public as string;
+	
+	// Infers type parameters for this type so it matches with targetType
+	// returns false if that isn't possible
+	public final inferTypeParameters(
+			cache as LocalMemberCache,
+			targetType as ITypeID,
+			mapping as ITypeID[TypeParameter]) as bool
+		=> accept(new MatchingTypeVisitor(cache, targetType, mapping));
+	
+	public static class MatchingTypeVisitor {
+		val type as ITypeID;
+		val mapping as ITypeID[TypeParameter];
+		val cache as LocalMemberCache;
+		
+		public this(cache as LocalMemberCache, type as ITypeID, mapping as ITypeID[TypeParameter]) {
+			this.type = type;
+			this.mapping = mapping;
+			this.cache = cache;
+		}
+	
+		public implements ITypeVisitor<bool> {
+			visitBasic(basic as BasicTypeID) as bool
+				=> basic == type;
+
+			visitArray(aray as ArrayTypeID) as bool {
+				if type !is ArrayTypeID
+					return false;
+				
+				val arrayType = type as ArrayTypeID;
+				if arrayType.dimension != array.dimension
+					return false;
+				
+				return matches(arrayType.elementType, array.elementType);
+			}
+
+			visitAssoc(assoc as AssocTypeID) as bool {
+				if type !is AssocTypeID
+					return false;
+					
+				val assocType = type as AssocTypeID;
+				return matches(assoc.keyType, assocType.keyType)
+						&& matches(assoc.valueType, assocType.valueType);
+			}
+			
+			visitIterator(iterator as IteratorTypeID) as bool {
+				if type !is IteratorTypeID
+					return false;
+					
+				val iteratorType = type as IteratorTypeID;
+				if iteratorType.iteratorTypes.length != iterator.iteratorTypes.length
+					return false;
+				
+				return iteratorType.iteratorTypes
+					.all((i, type) => matches(type, iterator.iteratorTypes[i]));
+			}
+
+			visitFunction(func as FunctionTypeID) {
+				if type !is FunctionTypeID
+					return false;
+				
+				val functionType = type as FunctionTypeID;
+				if functionType.header.parameters.length != func.header.parameters.length
+					return false;
+				
+				return matches(functionType.header.returnType, func.header.returnType)
+					&& functionType.header.parameters.all(
+						(i, parameter) => matches(parameter.type, func.header.parameters[i].type));
+			}
+
+			visitDefinition(definition as DefinitionTypeID) as bool {
+				if type !is DefinitionTypeID
+					return false;
+				
+				val definitionType = type as DefinitionTypeID;
+				if definitionType.definition != definition.definition
+					return false;
+				
+				return definition.typeParameters == null
+					|| definitionType.typeParameters.all(
+						(i, typeParameter) => matches(typeParameter, definition.typeParameters[i]));
+			}
+
+			visitGeneric(generic as GenericTypeID) as void {
+				if generic.parameter in mapping {
+					return mapping[generic.parameter] == type;
+				} else if generic.matches(cache, type) {
+					mapping[generic.parameter] = type;
+					return true;
+				} else {
+					return false;
+				}
+			}
+
+			visitRange(range as RangeTypeID) as bool {
+				if type !is RangeTypeID
+					return false;
+				
+				val rangeType = type as RangeTypeID;
+				return matches(rangeType.from, range.from) && matches(rangeType.to, range.to);
+			}
+
+			visitConst(type as ConstTypeID) as bool {
+				if this.type !is ConstTypeID
+					return false;
+					
+				val constType = this.type as ConstTypeID;
+				return matches(constType.baseType, type.baseType);
+			}
+
+			visitOptional(optional as OptionalTypeID) as bool {
+				if this.type !is ConstTypeID
+					return false;
+				
+				val optionalType = this.type as OptionalTypeID;
+				return matches(optionalType.baseType, optional.baseType);
+			}
+
+			visitGenericMap(map as GenericMapTypeID) as bool {
+				return map == type; // TODO: improve this
+			}
+			
+			private matches(type as ITypeID, pattern as ITypeID) as bool {
+				if type == pattern
+					return true;
+				
+				return pattern.accept(new MatchingTypeVisitor(cache, type, mapping));
+			}
+		}
+	}
+}

codemodel/src/type/ITypeVisitor.zs

@@ -0,0 +1,36 @@
+export interface ITypeVisitor<T> {
+	visitBasic(basic as BasicTypeID) as T
+		=> visitOther(basic);
+	
+	visitArray(array as ArrayTypeID) as T
+		=> visitOther(array);
+	
+	visitAssoc(assoc as AssocTypeID) as T
+		=> visitOther(assoc);
+	
+	visitGenericMap(map as GenericMapTypeID) as T
+		=> visitOther(map);
+	
+	visitIterator(iterator as IteratorTypeID) as T
+		=> visitOther(iterator);
+	
+	visitFunction(func as FunctionTypeID) as T
+		=> visitOther(func);
+	
+	visitDefinition(definition as DefinitionTypeID) as T
+		=> visitOther(definition);
+	
+	visitGeneric(generic as GenericTypeID) as T
+		=> visitOther(generic);
+	
+	visitRange(range as RangeTypeID) as T
+		=> visitOther(generic);
+	
+	visitConst(type as ConstTypeID) as T
+		=> visitOther(type);
+	
+	visitOptional(optional as OptionalTypeID) as T
+		=> visitOther(optional);
+	
+	visitOther(type as ITypeID) as T;
+}

codemodel/src/type/IteratorTypeID.zs

@@ -0,0 +1,40 @@
+import .generic.TypeParameter;
+
+public class IteratorTypeID {
+	val iteratorTypes as ITypeID[] : get;
+	
+	public this(iteratorTypes as ITypeID[]) {
+		this.iteratorTypes = iteratorTypes;
+	}
+	
+	public implements ITypeID {
+		get unmodified as ITypeID => this;
+		get isObjectType as bool => true;
+		get hasDefaultValue as bool => false;
+		
+		accept<T>(visitor as ITypeVisitor<T>) as T
+			=> visitor.visitIterator(visitor);
+		
+		withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as ITypeID
+			=> registry.getIterator(iteratorTypes.map(type => type.withGenericArguments(registry, arguments)));
+
+		hasInferenceBlockingTypeParameters(parameters as TypeParameter[]) as bool
+			=> iteratorTypes.contains(type => type.hasInferenceBlockingTypeParameters(parameters));
+
+		hashCode() as int {
+			var hash = 5;
+			hash = 13 * hash + iteratorTypes.hashCode();
+			return hash;
+		}
+
+		==(other as ITypeID) as bool {
+			if this === other
+				return true;
+			if other !is IteratorTypeID
+				return false;
+			
+			val otherIterator = other as IteratorTypeID;
+			return iteratorTypes == other.iteratorTypes;
+		}
+	}
+}

codemodel/src/type/OptionalTypeID.zs

@@ -0,0 +1,52 @@
+import .HighLevelDefinition;
+import .type.member.TypeMembers;
+import .generic.TypeParameter;
+
+export class OptionalTypeID {
+	val baseType as ITypeID : get;
+	
+	public this(baseType as ITypeID) {
+		this.baseType = baseType;
+	}
+	
+	public implements ITypeID {
+		get unmodified as ITypeID => baseType.unmodified;
+		get isOptional as bool => true;
+		get optionalBase as ITypeID => baseType;
+		get isObjectType as bool => baseType.isObjectType;
+		get hasDefaultValue as bool => true;
+		
+		withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as ITypeID
+			=> registry.getModified(TypeMembers.MODIFIER_OPTIONAL, baseType.withGenericArguments(registry, arguments));
+
+		accept<T>(visitor as ITypeVisitor<T>)
+			=> visitor.visitOptional(this);
+		
+		isDefinition(definition as HighLevelDefinition) as bool
+			=> baseType.isDefinition(definition);
+		
+		unwrap() as ITypeID
+			=> baseType;
+		
+		hasInferenceBlockingTypeParameters(parameters as TypeParameter[]) as bool
+			=> baseType.hasInferenceBlockingTypeParameters(parameters);
+
+		hashCode() as int {
+			val hash = 7;
+			hash = 29 * hash + baseType.hashCode();
+			return hash;
+		}
+
+		==(other as ITypeID) as bool {
+			if this === other
+				return true;
+			if this !is OptionalTypeID
+				return false;
+			
+			val otherOptional = other as OptionalTypeID;
+			return this.baseType == otherOptional.baseType;
+		}
+		
+		as string => baseType as string + '?';
+	}
+}

codemodel/src/type/RangeTypeID.zs

@@ -0,0 +1,50 @@
+import .generic.TypeParameter;
+
+public class RangeTypeID {
+	static val INT as RangeTypeID : get = new RangeTypeID(BasicTypeID.INT, BasicTypeID.INT);
+	
+	val from as ITypeID : get;
+	val to as ITypeID : get;
+	
+	public this(from as ITypeID, to as ITypeID) {
+		this.from = from;
+		this.to = to;
+	}
+	
+	public implements ITypeID {
+		get unmodified as RangeTypeID => this;
+		get isObjectType as bool => false;
+		get hasDefaultValue as bool => false;
+		
+		withGenericArguments(registry as GlobalTypeRegistry, arguments as ITypeID[TypeParameter]) as ITypeID
+			=> registry.getRange(
+					from.withGenericArguments(registry, arguments),
+					to.withGenericArguments(registry, arguments));
+
+		accept<T>(visitor as ITypeVisitor<T>) as TypeParamete
+			=> visitor.visitRange(this);
+		
+		hasInferenceBlockingTypeParameters(parameters as TypeParameter[]) as bool
+			=> from.hasInferenceBlockingTypeParameters(parameters)
+				|| to.hasInferenceBlockingTypeParameters(parameters);
+		
+		hashCode() as int {
+			var hash = 5;
+			hash = 89 * hash + from.hashCode();
+			hash = 89 * hash + to.hashCode();
+			return hash;
+		}
+		
+		==(other as ITypeID) as bool {
+			if this === other
+				return true;
+			if this !is RangeTypeID
+				return false;
+				
+			val otherRange = other as RangeTypeID;
+			return from === other.from && to === other.to;
+		}
+		
+		as string => from as string + ' .. ' + to as string;
+	}
+}

codemodel/src/type/member/LocalMemberCache.zs

@@ -0,0 +1,30 @@
+import .AccessScope;
+import .definition.ExpansionDefinition;
+import .type.GlobalTypeRegistry;
+import .type.ITypeID;
+
+export class LocalMemberCache {
+	val access as AccessScope : get;
+	val registry as GlobalTypeRegistry : get;
+	val types as TypeMembers[ITypeID];
+	val expansions as ExpansionDefinition[] : get;
+	
+	public this(
+			scope as AccessScope,
+			registry as GlobalTypeRegistry,
+			expansions as ExpansionDefinition[]) {
+		this.access = access;
+		this.registry = registry;
+		this.expansions = expansions;
+	}
+	
+	public [](type as ITypeID) as TypeMembers {
+		if type in types
+			return types[type];
+		
+		var members = new TypeMembers(this, type);
+		members.type.accept(new TypeMemberBuilder(registry, members, this));
+		types[type] = members;
+		return members;
+	}
+}

codemodel/src/type/member/TypeMember.zs

@@ -0,0 +1,14 @@
+export struct TypeMember<T : DefinitionMember> {
+	val priority as TypeMemberPriority : get;
+	val member as T : get;
+	
+	public resolve(other as TypeMember<T>) as TypeMember<T> {
+		if priority == other.priority {
+			if priority == SPECIFIED
+				throw new CompileException(other.member.getPosition(), MEMBER_DUPLICATE, "Duplicate " + other.member.describe());
+			return this;
+		}
+		
+		return priority < other.priority ? other : this;
+	}
+}

codemodel/src/type/member/TypeMemberPriority.zs

@@ -0,0 +1,7 @@
+public enum TypeMemberPriority {
+	BUILTIN_DEFAULT,
+	FROM_TYPE_BOUNDS,
+	INTERFACE,
+	INHERITED,
+	SPECIFIED
+}

parser/module.json

@@ -0,0 +1,10 @@
+{
+	"package": "org.openzen.zencode.parser",
+	"host": "universal",
+	"dependencies": [
+		"collections",
+		"io",
+		"shared",
+		"codemodel"
+	]
+}

parser/src/lexer/CharStream.zs

@@ -0,0 +1,111 @@
+public class CharStream {
+    val data as char[];
+    var index as int;
+
+    /**
+     * Constructs a character stream from a data string.
+     *
+     * @param data data string
+     */
+    public this(data as string) {
+        this.data = data.characters;
+        index = 0;
+    }
+	
+	public peek() as char
+		=> index == data.length ? 0 : data[index];
+	
+    /**
+     * Checks if the next character in the stream equals the specified character.
+     *
+     * @param ch checked character
+     * @return true if the next character equals the specified character
+     */
+    public peek(ch as char) as bool
+		=> index == data.length ? false : data[index] == ch;
+	
+    /**
+     * Processes an optional character. If the next character does not equal
+     * the specified character, nothing will happen.
+     *
+     * @param ch checked character
+     * @return true if the next character equals the specified character
+     */
+    public optional(ch as char) as bool {
+        if index == data.length
+			return false;
+		
+        if data[index] == ch {
+            index++;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Processes an optional range of characters. If the next character is not
+     * within the specified bounds, nothing will happen.
+     *
+     * @param from lower character value bound, inclusive
+     * @param to upper character value bound, inclusive
+     * @return the processed character
+     */
+    public optional(range as char..char) as char {
+        if index == data.length
+			return 0;
+		
+        if data[index] >= range.from && data[index] <= range.to {
+            return data[index++];
+        } else {
+            return 0;
+        }
+    }
+
+    /**
+     * Processes a required character. If the next character does not equal the
+     * specified character, an IllegalArgumentException is thrown.
+     *
+     * @param ch required character
+     */
+    public required(ch as char) as void {
+        if index >= data.length
+            throw new IllegalArgumentException("Expected " + ch + " but got EOF");
+		
+		if data[index] != ch
+            throw new IllegalArgumentException("Expected " + ch + " but got " + data[index]);
+		
+        index++;
+    }
+
+    /**
+     * Processes a required character range. If the next character is not within
+     * the specified bounds, an IllegalArgumentException is thrown.
+     *
+     * @param from lower character value bound, inclusive
+     * @param to upper character value bound, inclusive
+     * @return the processed character
+     */
+    public required(range as char..char) as char {
+        if data[index] < range.from || data[index] > range.to
+            throw new IllegalArgumentException("Unexpected character: " + data[index]);
+		
+        return data[index++];
+    }
+
+    /**
+     * Returns the next character in the stream.
+     *
+     * @return the next character
+     */
+    public next() as char
+		=> index >= data.length ? 0 : data[index++];
+	
+    /**
+     * Checks if the end of the stream has been reached.
+     *
+     * @return true if there are more characters in the stream
+     */
+    public hasMore() as bool
+		=> index < data.length;
+}

parser/src/lexer/CompiledDFA.zs

@@ -0,0 +1,72 @@
+public struct CompiledDFA<T : TokenType> {
+	public static createLexerDFA<T : TokenType : Comparable<T>>(tokenTypes as T[]) as CompiledDFA<T> {
+		val tokens = tokenTypes.filter(token => token.regexp != null);
+		val regexps = tokenTypes.filter(token => token.regexp != null).map(token => token.regexp);
+		return new NFA<T>(regexps, tokens).compile();
+	}
+	
+    val transitions as int[int][];
+    val finals as T?[];
+	
+    /**
+     * Constructs a compiled DFA from the specified transition graph and finals
+     * arrays.
+     *
+     * The transition array specifies all transitions for each state. The finals
+     * array specifies the final class index of each state, or NOFINAL if the state
+     * is not a final. There can multiple final classes, which can, for example,
+     * be used to distinguish token types.
+     *
+     * @param transitions transitions graph
+     * @param finals finals
+     */
+    public this(transitions as int[int][], finals as T?[]) {
+        this.transitions = transitions;
+        this.finals = finals;
+    }
+	
+	/**
+	 * Determines the token type for the given token. Returns null if the
+	 * given token is not a valid token.
+	 * 
+	 * @param value token value
+	 * @return token type
+	 */
+	public eval(value as string) as T? {
+		var state = 0;
+		
+		for c in value {
+			state = transitions[state][c];
+			if state == int.MIN_VALUE
+				return null;
+		}
+		
+		return finals[state];
+	}
+	
+	/**
+	 * Checks if this value evaluates to a valid token.
+	 * 
+	 * @param value value to check
+	 * @return true if matching, false otherwise
+	 */
+	public matches(value as string) as bool
+		=> eval(value) != null;
+
+    /* Used for debugging */
+	public implements StringBuildable {
+		toString(output as StringBuilder) as void {
+			for i, map in transitions {
+				for k, v in map {
+					output << "edge(" << i << ", " << k << "): " << v << "\r\n";
+				}
+			}
+			for i, f in finals {
+				if f == null
+					continue;
+				
+				output << "final(" << i << "): " << (f as string) << "\r\n";
+			}
+		}
+    }
+}

parser/src/lexer/DFA.zs

@@ -0,0 +1,167 @@
+import collections.LinkedList;
+import collections.HashSet;
+
+public class DFA<T : TokenType> {
+    static val NOFINAL as int : get = int.MIN_VALUE;
+
+    val initial as DFAState<T>;
+
+    /**
+     * Constructs a new DFA with the specified initial state.
+     *
+     * @param initial initial state
+	 * @param tokenClass token class
+     */
+    public this(initial as DFAState<T>) {
+        this.initial = initial;
+    }
+
+    /**
+     * Compiles this DFA into a more efficient structure.
+     *
+     * @return the compiled DFA
+     */
+    public compile() as CompiledDFA<T> {
+        val nodeList = [] as DFAState<T>[];
+        val nodes = new int[DFAState<T>];
+		
+        nodes[initial] = 0;
+        nodeList.add(initial);
+		
+        /* Find all reachable nodes in the dfs */
+        var counter = 1;
+        val todo = new LinkedList<DFAState<T>>();
+        todo.add(initial);
+
+        while !todo.empty {
+            val current = todo.poll();
+
+			for k, next in current.transitions {
+                if next !in nodes {
+                    todo.add(next);
+                    nodes[next] = counter++;
+                    nodeList.add(next);
+                }
+            }
+        }
+
+        /* Compile */
+        val transitions = new int[int][](counter);
+		val finals2 = new T?[](counter);
+		
+		for node in nodeList {
+            val index = nodes[node];
+            finals2[index] = node.finalCode;
+			
+			for k, next in node.transitions
+                transitions[index][k] = nodes[next];
+        }
+
+        return new CompiledDFA<T>(transitions, finals2);
+    }
+
+    /**
+     * Generates the minimal version of this DFA.
+     *
+     * @return the minimal DFA
+     */
+    public optimize() as DFA<T> {
+        val compiled = compile();
+        val transitions = compiled.transitions;
+        val size = transitions.length;
+
+        /* Collect all edges and determine alphabet */
+        val alphabet = new HashSet<int>();
+		for transition in transitions {
+			for k, v in transition
+				alphabet.add(k);
+		}
+
+        /* Initialize distinguishing array */
+        var distinguishable = new bool[,](size + 1, size + 1, (i, j) => compiled.finals[i] != compiled.finals[j]);
+		for i in 0 .. size {
+			distinguishable[i, size] = true;
+			distinguishable[size, i] = true;
+		}
+
+        /* Minimization algorithm implementation */
+        var changed = false;
+        do {
+            changed = false;
+			for x in alphabet {
+				for i in 0 .. size {
+					val ti = transitions[i].getOrDefault(x, size);
+					for j in 0 .. size {
+						if distinguishable[i, j]
+							continue;
+						
+						val tj = transitions[j].getOrDefault(x, size);
+						if distinguishable[ti, tj] {
+							distinguishable[i, j] = true;
+							changed = true;
+						}
+					}
+				}
+			}
+        } while (changed);
+
+        /* Group nodes */
+		var nodeMap = new DFAState<T>[int];
+        for i in 0 .. size {
+            for j in 0 .. size {
+                if !distinguishable[i, j] && j in nodeMap {
+                    nodeMap[i] = nodeMap[j];
+                    if compiled.finals[i] != null
+							&& nodeMap[j].finalCode != null
+							&& nodeMap[j].finalCode != compiled.finals[i]
+						throw new Exception("Two conflicting finals detected");
+					
+                    continue i;
+                }
+            }
+			
+			var node = new DFAState<T>;
+            node.finalCode = compiled.finals[i];
+            nodeMap[i] = node;
+        }
+		
+		for i, transition in compiled.transitions {
+			for k, v in transition
+				nodeMap[i].addTransition(k, nodeMap[v]);
+		}
+        
+        return new DFA<T>(nodeMap[0]);
+    }
+	
+	public implements StringBuildable {
+		public toString(output as StringBuilder) as void {
+			val dfs = compile();
+			for i, map in dfs.transitions {
+				for k, v in map {
+					output << "edge(" << i << ", " << k << "): " << v << "\r\n";
+				}
+			}
+			for i, finalCode in dfs.finals {
+				if finalCode == null
+					continue;
+				
+				output << "final(" << i << ": " << finalCode as string << "\r\n";
+			}
+		}
+	}
+
+    // ============================
+    // === Public inner classes ===
+    // ============================
+
+    /**
+     * Represents a state in a DFA.
+     */
+    public static class DFAState<T> {
+        val transitions as DFAState<T>[int] = new DFAState<T>[int];
+        var finalCode as T? : get, set = null;
+		
+        public addTransition(label as int, next as DFAState<T>) as void
+            => transitions[label] = next;
+    }
+}

parser/src/lexer/NFA.zs

@@ -0,0 +1,555 @@
+import collections.HashSet;
+import collections.LinkedList;
+
+public class NFA<T : Comparable<T>> {
+    static val EPSILON as int : get = int.MIN_VALUE + 1;
+
+    val initial as NFAState<T>;
+    val converted as DFA.DFAState<T>[NodeSet];
+
+    /**
+     * Creates a new NFA with the specified initial state.
+     *
+	 * @param tokenClass token class
+     * @param initial initial state
+     */
+    public this(initial as NFAState<T>) {
+        this.initial = initial;
+    }
+
+    /**
+     * Creates a new NFA from the specified regular expression.
+     *
+     * Note: the regular expression implementation is not complete. Shorthand
+     * character classes (\s, \w, \d), hexadecimal and unicode escape sequences and
+     * unicode properties are not implemented.
+     * 
+     * Anchors, lazy plus operators, lookbehind and lookforward are not implemented
+     * since they cannot be implemented in an NFA.
+     *
+     * @param regexp regular expression
+	 * @param state resulting state
+     */
+    public this(regexp as string, state as T) {
+        val main = processRegExp(new CharStream(regexp));
+        initial = new NFAState<T>();
+        initial.addTransition(main.tailLabel, main.tail);
+        main.head.finalCode = state;
+    }
+
+    /**
+     * Converts an array of regular expressions to an NFA. Each regular expression
+     * can have its own final class. The length of both arrays must match.
+     *
+     * @param regexp regular expression array
+     * @param finals final classes
+     */
+    public this(regexps as string?[], finals as T[]) {
+        initial = new NFAState<T>();
+		
+        for i, regexp in regexps {
+			if regexp == null
+				continue;
+			
+			try {
+				var partial = processRegExp(new CharStream(regexp));
+				partial.head.finalCode = finals[i];
+				initial.addTransition(partial.tailLabel, partial.tail);
+			} catch ex as IllegalArgumentException {
+				throw new Exception("Error parsing " + regexp[i], ex);
+			}
+        }
+    }
+
+    /**
+     * Converts this NFA to a DFA. The resulting DFA is not optimal. If the
+     * NFA is ambiguous, the token with lowest value will receive preference.
+     *
+     * @return this NFA as DFA
+     */
+    public toDFA() as DFA<T> {
+        converted = {};
+        val closure = new HashSet<NFAState<T>>;
+        this.initial.closure(closure);
+        val init = convert(new NodeSet(closure));
+        return new DFA<T>(init);
+    }
+	
+	/**
+	 * Converts the NFA to a DFA and optimizes and compiles it into an efficient
+	 * format.
+	 * 
+	 * @return compiled DFA
+	 */
+	public compile() as CompiledDFA<T>
+		=> toDFA().optimize().compile();
+
+    // =======================
+    // === Private methods ===
+    // =======================
+
+    /* Converts a set of possible states to a DFA state. */
+    private convert(nodes as NodeSet) as DFA.DFAState<T> {
+		if nodes in converted
+			return converted[nodes];
+		
+		val node = new DFA.DFAState<T>();
+		converted[nodes] = node;
+
+		val edgeSet = new HashSet<int>;
+		for n in nodes.nodes
+			n.alphabet(edgeSet);
+		
+		for i in edgeSet {
+			val edge = new HashSet<NFAState<T>>();
+			for n in nodes.nodes
+				n.edge(i, edge);
+			
+			val nodeSet = new NodeSet(edge);
+			node.addTransition(i, convert(nodeSet));
+		}
+		
+		var finalCode as T? = null;
+		for n in nodes.nodes {
+			if n.state != null {
+				if finalCode != null {
+					finalCode = n.state.compareTo(finalCode) < 0 ? n.state : finalCode;
+				} else {
+					finalCode = n.state;
+				}
+			}
+		}
+		
+		node.finalCode = finalCode;
+		return node;
+    }
+
+    /* Processes a regular expression */
+    private processRegExp(stream as CharStream) as Partial<T> {
+        val partial = processRegExp0(stream);
+        if stream.optional('|') {
+            val partials = new Partial<T>[];
+            partials.add(partial);
+            partials.add(processRegExp0(stream));
+            while stream.optional('|')
+                partials.add(processRegExp0(stream));
+			
+            val head = new NFAState<T>();
+            val tail = new NFAState<T>();
+            for p in partials {
+                tail.addTransition(p.tailLabel, p.tail);
+                p.head.addTransition(EPSILON, head);
+            }
+            return new Partial<T>(EPSILON, tail, head);
+        } else {
+            return partial;
+        }
+    }
+
+    /* Processes an element of an alternation clause */
+    private processRegExp0(stream as CharStream) as Partial<T>
+	{
+        var partial = processRegExp1(stream);
+        while !stream.peek(')') && !stream.peek('|') && stream.hasMore() {
+            val partial2 = processRegExp1(stream);
+            partial.head.addTransition(partial2.tailLabel, partial2.tail);
+            partial = new Partial<T>(partial.tailLabel, partial.tail, partial2.head);
+        }
+        return partial;
+    }
+
+    /* Processes a partial with optional repetition */
+    private processRegExp1(stream as CharStream) as Partial<T>
+	{
+        val partial = processPartial(stream);
+        if stream.optional('*') {
+            val node = new NFAState<T>();
+            partial.head.addTransition(EPSILON, node);
+            node.addTransition(partial.tailLabel, partial.tail);
+            return new Partial<T>(EPSILON, node, node);
+        } else if stream.optional('+') {
+            val node = new NFAState<T>();
+            partial.head.addTransition(EPSILON, node);
+            node.addTransition(partial.tailLabel, partial.tail);
+            return new Partial<T>(partial.tailLabel, partial.tail, node);
+        } else if stream.optional('?') {
+            val node = new NFAState<T>();
+            node.addTransition(EPSILON, partial.head);
+            node.addTransition(partial.tailLabel, partial.tail);
+            return new Partial<T>(EPSILON, node, partial.head);
+        } else if stream.optional('{') {
+            val amount = processInt(stream);
+            if amount < 0
+				throw new IllegalArgumentException("Repitition count expected");
+			
+            if stream.optional(',') {
+                val amount2 = processInt(stream);
+                stream.required('}');
+                if amount2 < 0 {
+                    // unbounded
+                    val duplicates = new Partial<T>[](amount, i => i == amount - 1 ? partial : partial.duplicate());
+					for i in 0 .. duplicates.length - 1
+                        duplicates[i].head.addTransition(duplicates[i + 1].tailLabel, duplicates[i + 1].tail);
+					
+                    duplicates[amount - 1].head.addTransition(duplicates[amount - 1].tailLabel, duplicates[amount - 1].tail);
+                    return new Partial<T>(duplicates[0].tailLabel, duplicates[0].tail, duplicates[amount - 1].head);
+                } else {
+                    val duplicates = new Partial<T>[](amount2, i => i == amount2 - 1 ? partial : partial.duplicate());
+                    for i in 0 .. duplicates.length - 1
+                        duplicates[i].head.addTransition(duplicates[i + 1].tailLabel, duplicates[i + 1].tail);
+					
+                    for i in amount .. amount2 {
+                        if (i == 0) {
+                            /* insert additional node before the chain because minimal repeat is 0 */
+                            val additional = new NFAState<T>();
+                            additional.addTransition(duplicates[0].tailLabel, duplicates[0].tail);
+                            additional.addTransition(EPSILON, duplicates[amount2 - 1].head);
+                            duplicates[0].tailLabel = EPSILON;
+                            duplicates[0].tail = additional;
+                        } else {
+                            duplicates[i - 1].head.addTransition(EPSILON, duplicates[amount2 - 1].head);
+                        }
+                    }
+                    return new Partial<T>(duplicates[0].tailLabel, duplicates[0].tail, duplicates[amount2 - 1].head);
+                }
+            } else {
+                stream.required('}');
+                
+                val duplicates = new Partial<T>[](amount, i => i == amount - 1 ? partial : partial.duplicate());
+				for i in 0 .. duplicates.length - 1
+                    duplicates[i].head.addTransition(duplicates[i + 1].tailLabel, duplicates[i + 1].tail);
+				
+                return new Partial<T>(duplicates[0].tailLabel, duplicates[0].tail, duplicates[amount - 1].head);
+            }
+        } else {
+            return partial;
+        }
+    }
+
+    /* Processes a part of a regular expression, which can be a character,
+     * expression between brackets, a dot or a character list */
+    private processPartial(stream as CharStream) as Partial<T> {
+        if stream.optional('(') {
+            val result = processRegExp(stream);
+            stream.required(')');
+            return result;
+        } else if stream.optional('[') {
+            val head = new NFAState<T>();
+            val tail = new NFAState<T>();
+			
+			for i in processCharList(stream)
+				tail.addTransition(i, head);
+			
+            stream.required(']');
+            return new Partial<T>(EPSILON, tail, head);
+        } else if (stream.optional('.')) {
+            val head = new NFAState<T>();
+            val tail = new NFAState<T>();
+			
+			for i in 0 .. 257 // 256 means 'any other unicode character'
+				tail.addTransition(i, head);
+			
+            return new Partial<T>(EPSILON, tail, head);
+        } else {
+            val node = new NFAState<T>();
+            return new Partial<T>(processChar(stream), node, node);
+        }
+    }
+
+    /* Processes a character list */
+    private processCharList(stream as CharStream) as HashSet<int>
+	{
+        val invert = stream.optional('^');
+        val base = new HashSet<int>;
+        do {
+            processCharPartial(base, stream);
+        } while !stream.peek(']');
+		
+        if invert {
+            val result = new HashSet<int>();
+			for i in 0 .. 257 {
+				if i !in base
+					result.add(i);
+            }
+            return result;
+        } else {
+            return base;
+        }
+    }
+
+    /* Processes a character partial, which can be a single character or a range
+     * of characters. */
+    private processCharPartial(out as HashSet<int>, stream as CharStream) as void
+	{
+        if stream.optional('.') {
+			for i in 0 .. 257
+				out.add(i);
+        } else {
+			val from = processChar(stream);
+            if stream.optional('-') {
+                val to = processChar(stream);
+				for i in from .. to
+                    out.add(i);
+            } else {
+                out.add(from);
+            }
+        }
+    }
+
+    /* Processes a single character */
+    private processChar(stream as CharStream) as int
+	{
+        if (stream.optional('\\')) { //'
+			val c = stream.next();
+			switch (c) {
+				case 'e': return -1;
+				case 'r': return '\r';
+				case 'n': return '\n';
+				case 't': return '\t';
+				case '[': return '[';
+				case ']': return ']';
+				case '(': return '(';
+				case ')': return ')';
+				case '.': return '.';
+				case '+': return '+';
+				case '-': return '-';
+				case '\\': return '\\';//'
+				case '{': return '{';
+				case '}': return '}';
+				case '?': return '?';
+				case '*': return '*';
+				case '~': return '~';
+				case '|': return '|';
+				case '^': return '^';
+				default:
+		            throw new IllegalArgumentException("Invalid character: " + (c as char));
+			}
+        } else {
+			val c = stream.next();
+			switch (c) {
+				case '[':
+				case ']':
+				case '(':
+				case ')':
+				case '{':
+				case '}':
+				case '.':
+				case '?':
+				case '*':
+	                throw new IllegalArgumentException("Invalid character: " + (c as char));
+				default:
+					return c;
+			}
+        }
+    }
+
+    /* Processes an optional integer, returns -1 if the next character do not
+     * represent an integer */
+    private processInt(stream as CharStream) as int
+	{
+        var data = stream.optional('0'..'9') - '0';
+        if data < 0
+			return -1;
+		
+        var ch = stream.optional('0'..'9');
+        while ch != 0 {
+            data = data * 10 + (ch - '0');
+            ch = stream.optional('0'..'9');
+        }
+        return data;
+    }
+
+    // ============================
+    // === Public inner classes ===
+    // ============================
+
+    /**
+     * Represents an NFA state.
+	 * 
+	 * @param <T> final type
+     */
+    public static class NFAState<T>
+	{
+        static var counter as int = 1;
+
+        val transitions as Transition[] = [];
+		var closure as NFAState<T>[]? = null;
+		val index as int = counter++;
+		val state as T?;
+		
+        /**
+         * Adds a transition.
+         *
+         * @param label transition label
+         * @param next next state
+         */
+        public addTransition(label as int, next as NFAState<T>) as void
+			=> transitions.add({ label, next });
+		
+        /**
+         * Sets the final state of this state.
+         *
+         * @param finalCode final code
+         */
+        public set finalCode as T 
+		{
+            if this.state == $
+				return;
+			
+            this.state = $;
+
+            for t in transitions
+                if t.label == EPSILON
+                    t.next.finalCode = $;
+        }
+
+        // =======================
+        // === Private methods ===
+        // =======================
+
+        /**
+         * Determines the (partial) closure of this state.
+         *
+         * @param output output to store the closure in
+         */
+        private closure(output as HashSet<NFAState<T>>) as void {
+            for node in closure()
+				output.add(node);
+        }
+
+        /**
+         * Calculates the (full) closure of this state.
+         *
+         * @return this state's closure
+         */
+        private closure() as NFAState<T>[] {
+            if closure == null {
+                closure = [];
+                val tmp = new HashSet<NFAState<T>>();
+                tmp.add(this);
+                for transition in transitions {
+                    if transition.label == EPSILON {
+                        if transition.next !in tmp {
+                            tmp.add(transition.next);
+                            transition.next.closure(tmp);
+                        }
+                    }
+                }
+                for node in tmp
+					closure.add(node);
+            }
+			
+            return closure;
+        }
+
+        /**
+         * Calculates the possible set of states after a transition with the
+         * specified value
+         *
+         * @param label transition label
+         * @param output possible set of states (out)
+         */
+        private edge(label as int, output as HashSet<NFAState<T>>) as void {
+            for transition in transitions {
+                if transition.label == label {
+                    if transition.next !in output {
+                        output.add(transition.next);
+                        transition.next.closure(output);
+                    }
+                }
+            }
+        }
+
+        /**
+         * Calculates the alphabet of this state.
+         *
+         * @param output alphabet (out)
+         */
+        private alphabet(output as HashSet<int>) as void
+		{
+            for node in closure() {
+                for t in node.transitions {
+                    if t.label != EPSILON
+                        output.add(t.label);
+                }
+            }
+        }
+
+        // ===================
+        // === Inner class ===
+        // ===================
+		
+        private struct Transition {
+            var label as int;
+			val next as NFAState<T>;
+        }
+    }
+
+    /* Hashable set of nodes */
+    private class NodeSet
+	{
+        val nodes as NFAState<T>[];
+		
+        public this(nodes as HashSet<NFAState<T>>)
+		{
+            this.nodes = new NFAState<T>[](nodes.size);
+			var i = 0;
+            for node in nodes
+				this.nodes[i++] = node;
+			
+            this.nodes.sort((o1, o2) => o1.index - o2.index);
+        }
+		
+		public implements Hashable<NodeSet> {
+			hashCode() as int
+				=> nodes.objectHashCode;
+			
+			==(other as NodeSet) as bool
+				=> nodes === other.nodes;
+		}
+    }
+
+    /**
+     * Contains a partially parsed regular expression. Has a head and a tail.
+     *
+     * The tail is a transition and thus has a label and a next node. The head
+     * is the 'final' state of the partial.
+     */
+    private static struct Partial<T>
+	{
+        var tailLabel as int;
+        var tail as NFAState<T>;
+        var head as NFAState<T>;
+		
+		public this(tailLabel as int, tail as NFAState<T>, head as NFAState<T>) {
+			this.tailLabel = tailLabel;
+			this.tail = tail;
+			this.head = head;
+		}
+		
+        /**
+         * Duplicates the NFA of this partial.
+         *
+         * @return a duplicate of this partial
+         */
+        public duplicate() as Partial<T>
+		{
+			val nodes = new NFAState<T>[NFAState<T>];
+			val todo = new LinkedList<NFAState<T>>;
+            todo.add(tail);
+            nodes[tail] = new NFAState<T>;
+            while !todo.empty {
+                val node = todo.poll();
+                for t in node.transitions {
+                    if t.next !in nodes {
+                        nodes[t.next] = new NFAState<T>;
+                        todo.add(t.next);
+                    }
+                    nodes[node].addTransition(t.label, nodes[t.next]);
+                }
+            }
+
+            return new Partial<T>(tailLabel, nodes[tail], nodes[head]);
+        }
+    }
+}

parser/src/lexer/Token.zs

@@ -0,0 +1,8 @@
+import shared.CodePosition;
+
+export interface Token<TT : TokenType> {
+	get position as CodePosition;
+	get type as TT;
+	get content as string;
+	get whitespaceBefore as string;
+}

parser/src/lexer/TokenStream.zs

@@ -0,0 +1,314 @@
+import collections.LinkedList;
+import collections.Stack;
+import io.Reader;
+import io.StringReader;
+import shared.CodePosition;
+
+/**
+ * Represents a token stream. A token stream reads characters from a reader and
+ * presents it as a series of tokens. Can be used to implement LL(*) parsers.
+ *
+ * Token classes with a negative class are considered to be whitespace.
+ *
+ * @author Stan Hebben
+ * @param <T> token class
+ * @param <TT> token type class
+ */
+export abstract class TokenStream<T : Token<TT>, TT : TokenType> {
+	val filename as string : get;
+    val reader as CountingReader;
+    val dfa as CompiledDFA<TT>;
+    val tokenMemory as LinkedList<T>;
+    val marks as Stack<int>;
+	val eof as TT;
+	val tabSize as int = 4;
+	
+    val next as T;
+	val nextChar as int;
+	val line as int : get;
+	val lineOffset as int : get;
+	
+    val tokenMemoryOffset as int;
+    val tokenMemoryCurrent as int;
+    
+    /**
+     * Creates a token stream using the specified reader and DFA.
+     *
+	 * @param filename filename
+     * @param reader reader to read characters from
+     * @param dfa DFA to tokenize the stream
+	 * @param eof end of file token type
+     */
+	public this(filename as string, reader as Reader, dfa as CompiledDFA<TT>, eof as TT) {
+		if eof.isWhitespace // important for the advance() method
+			throw new IllegalArgumentException("EOF cannot be whitespace");
+		
+        tokenMemoryOffset = 0;
+        tokenMemoryCurrent = 0;
+        tokenMemory = new LinkedList<T>();
+        marks = new Stack<int>();
+        
+        this.reader = new CountingReader(reader);
+        this.dfa = dfa;
+		this.filename = filename;
+		this.eof = eof;
+		
+		nextChar = this.reader.read();
+		
+        line = 1;
+        lineOffset = 1;
+        advance();
+    }
+
+    /**
+     * Creates a token stream which reads data from the specified string.
+     *
+	 * @param filename filename
+     * @param data data to read
+     * @param dfa DFA to tokenize the stream
+	 * @param eof end of file token type
+     */
+	public this(filename as string, data as string, dfa as CompiledDFA<TT>, eof as TT) {
+        this(filename, new StringReader(data), dfa, eof);
+    }
+    
+    public peek() as T {
+        if tokenMemoryCurrent < tokenMemoryOffset + tokenMemory.size {
+            return tokenMemory[tokenMemoryCurrent - tokenMemoryOffset];
+        } else {
+            return next;
+        }
+    }
+
+    public isNext(type as TT) as bool
+		=> peek().type == type;
+	
+    public optional(type as TT) as T?
+		=> peek().type == type ? next() : null;
+	
+    public required(type as TT, error as string) as T {
+		val t = peek();
+        if t.type == type {
+            return next();
+        } else {
+			return requiredTokenNotFound(position, error, t);
+        }
+    }
+	
+	public get position as CodePosition
+		=> peek().position;
+	
+	// =====================
+    // === LL(*) ability ===
+	// =====================
+
+    /**
+     * Pushes a mark on the mark stack.
+     */
+    public pushMark() as void {
+        marks.push(tokenMemoryCurrent);
+    }
+
+    /**
+     * Pops a mark from the mark stack without reset.
+     */
+    public popMark() as void {
+        marks.pop();
+
+        if marks.empty {
+            tokenMemoryOffset = tokenMemoryCurrent;
+            tokenMemory.clear();
+        }
+    }
+
+    /**
+     * Pops a mark from the mark stack and resets the stream's position to it
+     */
+    public reset() as void {
+        tokenMemoryCurrent = marks.pop();
+    }
+	
+	/**
+	 * Replaces the current token with another one. Used to split composite tokens.
+	 * 
+	 * @param other 
+	 */
+	public replace(other as TT) as void {
+		next = createToken(next.position, next.whitespaceBefore, next.content, other);
+	}
+
+    public get hasMore as bool
+		=> next.type === eof;
+	
+    public next() as T {
+        if (tokenMemoryCurrent < tokenMemoryOffset + tokenMemory.size) {
+            return tokenMemory[(tokenMemoryCurrent++) - tokenMemoryOffset];
+        } else {
+            val result = next;
+            if marks.empty {
+                tokenMemoryOffset++;
+            } else {
+                tokenMemory.add(result);
+            }
+            tokenMemoryCurrent++;
+            advance();
+            return result;
+        }
+    }
+
+    // ==================================
+    // === Protected abstract methods ===
+    // ==================================
+	
+	/**
+	 * Called to create a token. May also be used to postprocess tokens while
+	 * generating them.
+	 * 
+	 * @param position token position (range)
+	 * @param value token value
+	 * @param tokenType token type
+	 * @return newly created token
+	 */
+	protected abstract createToken(
+			position as CodePosition,
+			whitespaceBefore as string,
+			value as string,
+			tokenType as TT) as T;
+	
+	/**
+	 * Called when a required token could not be found. Should log an error or
+	 * throw an exception. If no exception is thrown, the calling required
+	 * method will return the returned value as token value.
+	 * 
+	 * @param position erroring position
+	 * @param error error to be logged
+	 * @param token incorrect token
+	 */
+	protected abstract requiredTokenNotFound(
+			position as CodePosition,
+			error as string,
+			token as T) as T;
+	
+	/**
+	 * Called when the input contains an invalid token. Should either create
+	 * a token indicating an invalid token, or throw an exception.
+	 * 
+	 * @param position erroring position
+	 * @param token token value
+	 * @return a token marking an invalid token
+	 */
+	protected abstract invalidToken(
+			position as CodePosition,
+			whitespaceBefore as string,
+			token as string) as T;
+	
+    // =======================
+    // === Private methods ===
+    // =======================
+
+    /**
+     * Advances to the next non - whitespace token.
+     */
+    private advance() as void {
+		val whitespace = new StringBuilder();
+        while true {
+            advanceToken(whitespace);
+			if next.type.isWhitespace
+				whitespace << next.content;
+			else
+				break;
+        }
+    }
+
+    /**
+     * Advances to the next token.
+     */
+    private advanceToken(whitespace as string) as void {
+        if nextChar < 0 {
+			val position = new CodePosition(
+					filename,
+					line,
+					lineOffset,
+					line,
+					lineOffset);
+			
+            next = createToken(position, whitespace, "", eof);
+            return;
+        }
+		
+		var state = 0;
+		val value = new StringBuilder();
+		val fromLine = line;
+		val fromLineOffset = lineOffset;
+		while nextChar in dfa.transitions[state] {
+			value << nextChar as char;
+			state = dfa.transitions[state][nextChar];
+			line = reader.line;
+			lineOffset = reader.lineOffset;
+			nextChar = reader.read();
+		}
+		
+		if dfa.finals[state] != null {
+			if state == 0 {
+				value << nextChar as char;
+				next = invalidToken(new CodePosition(filename, fromLine, fromLineOffset, line, lineOffset),
+						whitespace,
+						value);
+				nextChar = reader.read();
+			}
+			
+			next = createToken(new CodePosition(filename, fromLine, fromLineOffset, line, lineOffset),
+					whitespace,
+					value,
+					dfa.finals[state]);
+		} else {
+			if nextChar < 0 && value.empty
+				return; // happens on comments at the end of files
+			
+			value << nextChar as char;
+			next = invalidToken(new CodePosition(filename, fromLine, fromLineOffset, line, lineOffset),
+					whitespace,
+					value);
+			nextChar = reader.read();
+		}
+    }
+
+    // =============================
+    // === Private inner classes ===
+    // =============================
+
+    /**
+     * Keeps a line and line offset count.
+     */
+    private static class CountingReader
+	{
+		var line as int;
+		var lineOffset as int;
+		val reader as Reader;
+		var eof as bool;
+		
+		public this(reader as Reader) {
+			this.reader = reader;
+			line = 1;
+			lineOffset = 1;
+		}
+
+        public read() as int
+		{
+            val ch = reader.read();
+            if ch == -1 {
+                eof = true;
+                return ch;
+            }
+            if ch == '\n' {
+                line++;
+                lineOffset = 1;
+            } else if ch == '\t' {
+				lineOffset += tabSize;
+			} else {
+                lineOffset++;
+            }
+            return ch;
+        }
+    }
+}

parser/src/lexer/TokenType.zs

@@ -0,0 +1,5 @@
+export interface TokenType {
+	get regexp as string?;
+	get isWhitespace as bool;
+	as string;
+}

parser/src/lexer/ZSToken.zs

@@ -0,0 +1,17 @@
+import shared.CodePosition;
+
+export class ZSToken {
+	val position as CodePosition : public get;
+	val type as ZSTokenType : public get;
+	val content as string : public get;
+	val whitespaceBefore as string : public get;
+	
+	public this(position as CodePosition, type as ZSTokenType, content as string, whitespaceBefore as string) {
+		this.position = position;
+		this.type = type;
+		this.content = content;
+		this.whitespaceBefore = whitespaceBefore;
+	}
+	
+	public implements Token<ZSTokenType> {}
+}

parser/src/lexer/ZSTokenStream.zs

@@ -0,0 +1,160 @@
+import io.Reader;
+import codemodel.WhitespaceInfo;
+import shared.CompileException;
+import shared.CompileExceptionCode;
+import shared.CodePosition;
+
+/**
+ *
+ * @author Stan Hebben
+ */
+public class ZSTokenStream : TokenStream<ZSToken, ZSTokenType> {
+	private static val DFA as CompiledDFA<ZSTokenType> = CompiledDFA.createLexerDFA<ZSTokenType>(ZSTokenType.VALUES);
+	private static val KEYWORDS as ZSTokenType[string];
+	
+	static {
+		KEYWORDS = {
+			"import": K_IMPORT,
+			"alias": K_ALIAS,
+			"class": K_CLASS,
+			"interface": K_INTERFACE,
+			"enum": K_ENUM,
+			"struct": K_STRUCT,
+			"expand": K_EXPAND,
+			"function": K_FUNCTION,
+			"variant": K_VARIANT,
+		
+			"abstract": K_ABSTRACT,
+			"final": K_FINAL,
+			"override": K_OVERRIDE,
+			"const": K_CONST,
+			"private": K_PRIVATE,
+			"public": K_PUBLIC,
+			"export": K_EXPORT,
+			"static": K_STATIC,
+			"protected": K_PROTECTED,
+			"implicit": K_IMPLICIT,
+			"virtual": K_VIRTUAL,
+			"extern": K_EXTERN,
+		
+			"val": K_VAL,
+			"var": K_VAR,
+			"get": K_GET,
+			"implements": K_IMPLEMENTS,
+			"set": K_SET,
+		
+			"void": K_VOID,
+			"any": K_ANY,
+			"bool": K_BOOL,
+			"byte": K_BYTE,
+			"sbyte": K_SBYTE,
+			"short": K_SHORT,
+			"ushort": K_USHORT,
+			"int": K_INT,
+			"uint": K_UINT,
+			"long": K_LONG,
+			"ulong": K_ULONG,
+			"float": K_FLOAT,
+			"double": K_DOUBLE,
+			"char": K_CHAR,
+			"string": K_STRING,
+		
+			"if": K_IF,
+			"else": K_ELSE,
+			"do": K_DO,
+			"while": K_WHILE,
+			"for": K_FOR,
+			"throw": K_THROW,
+			"lock": K_LOCK,
+			"try": K_TRY,
+			"catch": K_CATCH,
+			"finally": K_FINALLY,
+			"return": K_RETURN,
+			"break": K_BREAK,
+			"continue": K_CONTINUE,
+			"switch": K_SWITCH,
+			"case": K_CASE,
+			"default": K_DEFAULT,
+		
+			"in": K_IN,
+			"is": K_IS,
+			"as": K_AS,
+			"match": K_MATCH,
+			"throws": K_THROWS,
+		
+			"this": K_THIS,
+			"super": K_SUPER,
+			"null": K_NULL,
+			"true": K_TRUE,
+			"false": K_FALSE,
+			"new": K_NEW
+		};
+	}
+	
+	var whitespaceBuffer as string? = null;
+	
+	public this(filename as string, reader as Reader) {
+		super(filename, reader, DFA, EOF);
+	}
+	
+	public loadWhitespace() as string {
+		if whitespaceBuffer == null
+			whitespaceBuffer = peek().whitespaceBefore;
+		
+		return whitespaceBuffer;
+	}
+	
+	public reloadWhitespace() as void {
+		whitespaceBuffer = peek().whitespaceBefore;
+	}
+	
+	public grabWhitespace() as string {
+		val result = loadWhitespace();
+		whitespaceBuffer = null;
+		return result;
+	}
+	
+	public grabWhitespaceLine() as string {
+		val whitespace = loadWhitespace();
+		if '\n' in whitespace {
+			var index = whitespace.indexOf('\n');
+			whitespaceBuffer = whitespace[(index + 1) .. $];
+			return whitespace[0 .. index];
+		} else {
+			whitespaceBuffer = "";
+			return whitespace;
+		}
+	}
+	
+	public skipWhitespaceNewline() as void {
+		loadWhitespace();
+		val index = whitespaceBuffer.indexOf('\n');
+		if index >= 0
+			whitespaceBuffer = whitespaceBuffer[(index + 1) .. $];
+	}
+	
+	public collectWhitespaceInfoForBlock(whitespace as string) as WhitespaceInfo
+		=> WhitespaceInfo.from(whitespace, "", false);
+	
+	public collectWhitespaceInfo(whitespace as string, skipLineBefore as bool) as WhitespaceInfo
+		=> WhitespaceInfo.from(whitespace, grabWhitespaceLine(), skipLineBefore);
+	
+	override createToken(
+		position as CodePosition,
+		whitespaceBefore as string,
+		value as string,
+		tokenType as ZSTokenType) as ZSToken
+	{
+		if tokenType == T_IDENTIFIER && value in KEYWORDS
+			tokenType = KEYWORDS[value];
+		
+		return new ZSToken(position, tokenType, value, whitespaceBefore);
+	}
+
+	override requiredTokenNotFound(position as CodePosition, error as string, token as ZSToken) as void {
+		throw new CompileException(position, UNEXPECTED_TOKEN, error);
+	}
+
+	override invalidToken(position as CodePosition, whitespaceBefore as string, token as string) as ZSToken
+		=> new ZSToken(position, INVALID, token, whitespaceBefore);
+}

parser/src/lexer/ZSTokenType.zs

@@ -0,0 +1,164 @@
+export enum ZSTokenType {
+	T_COMMENT_SCRIPT("#[^\n]*[\n\\e]", true),
+	T_COMMENT_SINGLELINE("//[^\n]*[\n\\e]", true),
+	T_COMMENT_MULTILINE("/\\*([^\\*]|(\\*+([^\\*/])))*\\*+/", true),
+	T_WHITESPACE("[ \t\r\n]*", true),
+	T_IDENTIFIER("[a-zA-Z_][a-zA-Z_0-9]*"),
+	T_FLOAT("\\-?(0|[1-9][0-9]*)\\.[0-9]+([eE][\\+\\-]?[0-9]+)?"),
+	T_INT("\\-?(0|[1-9][0-9]*)"),
+	T_STRING_SQ("\"([^\"\\\\]|\\\\([\'\"\\\\/bfnrt&]|u[0-9a-fA-F]{4}))*\""), //"
+	T_STRING_DQ("\'([^\'\\\\]|\\\\([\'\"\\\\/bfnrt&]|u[0-9a-fA-F]{4}))*\'"), //'
+	T_AOPEN("\\{"),
+	T_ACLOSE("\\}"),
+	T_SQOPEN("\\["),
+	T_SQCLOSE("\\]"),
+	T_DOT3("\\.\\.\\."),
+	T_DOT2("\\.\\."),
+	T_DOT("\\."),
+	T_COMMA(","),
+	T_INCREMENT("\\+\\+"),
+	T_ADDASSIGN("\\+="),
+	T_ADD("\\+"),
+	T_DECREMENT("\\-\\-"),
+	T_SUBASSIGN("\\-="),
+	T_SUB("\\-"),
+	T_CATASSIGN("~="),
+	T_CAT("~"),
+	T_MULASSIGN("\\*="),
+	T_MUL("\\*"),
+	T_DIVASSIGN("/="),
+	T_DIV("/"),
+	T_MODASSIGN("%="),
+	T_MOD("%"),
+	T_ORASSIGN("\\|="),
+	T_OROR("\\|\\|"),
+	T_OR("\\|"),
+	T_ANDASSIGN("&="),
+	T_ANDAND("&&"),
+	T_AND("&"),
+	T_XORASSIGN("\\^="),
+	T_XOR("\\^"),
+	T_COALESCE("\\?\\?"),
+	T_QUEST("\\?"),
+	T_COLON(":"),
+	T_BROPEN("\\("),
+	T_BRCLOSE("\\)"),
+	T_SEMICOLON(";"),
+	T_LESSEQ("<="),
+	T_SHLASSIGN("<<="),
+	T_SHL("<<"),
+	T_LESS("<"),
+	T_GREATEREQ(">="),
+	T_USHR(">>>"),
+	T_USHRASSIGN(">>>="),
+	T_SHRASSIGN(">>="),
+	T_SHR(">>"),
+	T_GREATER(">"),
+	T_LAMBDA("=>"),
+	T_EQUAL3("==="),
+	T_EQUAL2("=="),
+	T_ASSIGN("="),
+	T_NOTEQUAL2("!=="),
+	T_NOTEQUAL("!="),
+	T_NOT("!"),
+	T_DOLLAR("$"),
+	
+	K_IMPORT,
+	K_ALIAS,
+	K_CLASS,
+	K_FUNCTION,
+	K_INTERFACE,
+	K_ENUM,
+	K_STRUCT,
+	K_EXPAND,
+	K_VARIANT,
+	
+	K_ABSTRACT,
+	K_FINAL,
+	K_OVERRIDE,
+	K_CONST,
+	K_PRIVATE,
+	K_PUBLIC,
+	K_EXPORT,
+	K_STATIC,
+	K_PROTECTED,
+	K_IMPLICIT,
+	K_VIRTUAL,
+	K_EXTERN,
+	
+	K_VAL,
+	K_VAR,
+	K_GET,
+	K_IMPLEMENTS,
+	K_SET,
+	
+	K_VOID,
+	K_ANY,
+	K_BOOL,
+	K_BYTE,
+	K_SBYTE,
+	K_SHORT,
+	K_USHORT,
+	K_INT,
+	K_UINT,
+	K_LONG,
+	K_ULONG,
+	K_FLOAT,
+	K_DOUBLE,
+	K_CHAR,
+	K_STRING,
+	
+	K_IF,
+	K_ELSE,
+	K_DO,
+	K_WHILE,
+	K_FOR,
+	K_THROW,
+	K_LOCK,
+	K_TRY,
+	K_CATCH,
+	K_FINALLY,
+	K_RETURN,
+	K_BREAK,
+	K_CONTINUE,
+	K_SWITCH,
+	K_CASE,
+	K_DEFAULT,
+	
+	K_IN,
+	K_IS,
+	K_AS,
+	K_MATCH,
+	K_THROWS,
+	
+	K_SUPER,
+	K_THIS,
+	K_NULL,
+	K_TRUE,
+	K_FALSE,
+	K_NEW,
+	
+	INVALID,
+	EOF
+	;
+	
+	val regexp as string? : public get;
+	val whitespace as bool : public get;
+	
+	this() {
+		this.regexp = null;
+		this.whitespace = false;
+	}
+	
+	this(regexp as string) {
+		this.regexp = regexp;
+		this.whitespace = false;
+	}
+	
+	this(regexp as string, whitespace as bool) {
+		this.regexp = regexp;
+		this.whitespace = whitespace;
+	}
+	
+	public implements TokenType {}
+}

project.json

@@ -0,0 +1,19 @@
+{
+	"targets": [
+		{ "module": "shared", "type": "javaSource", "output": "shared/outputJava", "name": "SharedJavaSource" }
+	],
+	"modules": [
+		"shared",
+		"codemodel",
+		"parser"
+	],
+	"libraries": {
+		"StdLib": {
+			"directory": "../StdLibs",
+			"modules": [
+				"collections",
+				"io"
+			]
+		}
+	}
+}

shared/module.json

@@ -0,0 +1,4 @@
+{
+	"package": "org.openzen.zencode.shared",
+	"host": "universal"
+}

shared/src/CodePosition.zs

@@ -0,0 +1,38 @@
+export struct CodePosition {
+	public const BUILTIN as CodePosition  = new CodePosition("builtin", 0, 0, 0, 0);
+	public const NATIVE as CodePosition = new CodePosition("native", 0, 0, 0, 0);
+	
+	val filename as string : get;
+	val fromLine as int : get;
+	val fromLineOffset as int : get;
+	val toLine as int : get;
+	val toLineOffset as int : get;
+	
+	public this(
+			filename as string,
+			fromLine as int, fromLineOffset as int,
+			toLine as int, toLineOffset as int)
+	{
+		this.filename = filename;
+		this.fromLine = fromLine;
+		this.fromLineOffset = fromLineOffset;
+		this.toLine = toLine;
+		this.toLineOffset = toLineOffset;
+	}
+	
+	public toShortString() as string {
+		val lastSeparator = filename.lastIndexOf('/');
+		val shortFilename = lastSeparator >= 0 ? filename[(lastSeparator + 1) .. $] : filename;
+		if fromLine == 0 && fromLineOffset == 0
+			return shortFilename;
+		
+		return shortFilename + ":" + fromLine + ":" + fromLineOffset;
+	}
+	
+	[Precondition(ENFORCE, this.filename == to.filename, "From and to positions must be in the same file!")]
+	public ..(to as CodePosition) as CodePosition
+		=> new CodePosition(this.filename, this.fromLine, this.fromLineOffset, to.toLine, to.toLineOffset);
+	
+	public implicit as string
+		=> fromLine == 0 && fromLineOffset == 0 ? filename : filename + ":" + fromLine + ":" + fromLineOffset;
+}

shared/src/CompileException.zs

@@ -0,0 +1,15 @@
+public class CompileException : Exception {
+	public static internalError(message as string) as CompileException {
+		return new CompileException(CodePosition.BUILTIN, INTERNAL_ERROR, message);
+	}
+	
+	val position as CodePosition : get;
+	val code as CompileExceptionCode : get;
+	
+	public this(position as CodePosition, code as CompileExceptionCode, message as string) {
+		super((position as string) + ": [" + code + "] " + message);
+		
+		this.position = position;
+		this.code = code;
+	}
+}

shared/src/CompileExceptionCode.zs

@@ -0,0 +1,50 @@
+public enum CompileExceptionCode {
+	UNEXPECTED_TOKEN,
+	IMPORT_NOT_FOUND,
+	NO_OUTER_BECAUSE_NOT_INNER,
+	NO_OUTER_BECAUSE_STATIC,
+	NO_OUTER_BECAUSE_OUTSIDE_TYPE,
+	TYPE_ARGUMENTS_INVALID_NUMBER,
+	TYPE_ARGUMENTS_NOT_INFERRABLE,
+	USING_STATIC_ON_INSTANCE,
+	CANNOT_ASSIGN,
+	UNAVAILABLE_IN_CLOSURE,
+	USING_PACKAGE_AS_EXPRESSION,
+	USING_PACKAGE_AS_CALL_TARGET,
+	USING_TYPE_AS_EXPRESSION,
+	MEMBER_NO_SETTER,
+	MEMBER_NO_GETTER,
+	MEMBER_NOT_STATIC,
+	MEMBER_IS_FINAL,
+	MEMBER_DUPLICATE,
+	CALL_AMBIGUOUS,
+	CALL_NO_VALID_METHOD,
+	ENUM_VALUE_DUPLICATE,
+	INVALID_CAST,
+	NO_SUCH_INNER_TYPE,
+	NO_DOLLAR_HERE,
+	UNSUPPORTED_XML_EXPRESSIONS,
+	UNSUPPORTED_NAMED_ARGUMENTS,
+	TYPE_CANNOT_UNITE,
+	BRACKET_MULTIPLE_EXPRESSIONS,
+	SUPER_CALL_NO_SUPERCLASS,
+	LAMBDA_HEADER_INVALID,
+	COALESCE_TARGET_NOT_OPTIONAL,
+	MULTIPLE_MATCHING_HINTS,
+	MISSING_MAP_KEY,
+	NO_SUCH_MEMBER,
+	USING_THIS_OUTSIDE_TYPE,
+	USING_THIS_STATIC,
+	UNDEFINED_VARIABLE,
+	METHOD_BODY_REQUIRED,
+	BREAK_OUTSIDE_LOOP,
+	CONTINUE_OUTSIDE_LOOP,
+	NO_SUCH_ITERATOR,
+	NO_SUCH_TYPE,
+	RETURN_VALUE_REQUIRED,
+	RETURN_VALUE_VOID,
+	INVALID_CONDITION,
+	INTERNAL_ERROR,
+	CANNOT_SET_FINAL_VARIABLE,
+	MISSING_PARAMETER
+}

shared/src/SourceFile.zs

@@ -0,0 +1,7 @@
+public class SourceFile {
+	val filename as string : get;
+	
+	public this(filename as string) {
+		this.filename = filename;
+	}
+}

shared/src/StringExpansion.zs

@@ -0,0 +1,496 @@
+export expand string {
+	static val NAMED_CHARACTER_ENTITIES as CharacterEntity[string];
+	
+	static {
+		val entities = getCharacterEntities();
+		
+		// TODO: getCharacterEntities().index(e => e.stringValue);
+		NAMED_CHARACTER_ENTITIES = {};
+		for entity in entities
+			NAMED_CHARACTER_ENTITIES[entity.stringValue] = entity;
+	}
+	
+	private static getCharacterEntities() as CharacterEntity[] {
+		return [
+			{ 'quot', 34 },
+			{ 'amp', 38 },
+			{ 'apos', 39 },
+			{ 'lt', 60 },
+			{ 'gt', 62 },
+			{ 'nbsp', 160 },
+			{ 'iexcl', 161 },
+			{ 'cent', 162 },
+			{ 'pound', 163 },
+			{ 'curren', 164 },
+			{ 'yen', 165 },
+			{ 'brvbar', 166 },
+			{ 'sect', 167 },
+			{ 'uml', 168 },
+			{ 'copy', 169 },
+			{ 'ordf', 170 },
+			{'laquo', 171},
+			{ 'not', 172 },
+			{ 'shy', 173 },
+			{ 'reg', 174 },
+			{ 'macr', 175 },
+			{ 'deg', 176 },
+			{ 'plusmn', 177 },
+			{ 'sup2', 178 },
+			{ 'sup3', 179 },
+			{ 'acute', 180 },
+			{ 'micro', 181 },
+			{ 'para', 182 },
+			{ 'middot', 183 },
+			{ 'cedil', 184 },
+			{ 'sup1', 185 },
+			{ 'ordm', 186 },
+			{ 'raquo', 187 },
+			{ 'frac14', 188 },
+			{ 'frac12', 189 },
+			{ 'frac34', 190 },
+			{ 'iquest', 191 },
+
+			{ 'Agrave', 192 },
+			{ 'Aacute', 193 },
+			{ 'Acirc', 194 },
+			{ 'Atilde', 195 },
+			{ 'Auml', 196 },
+			{ 'Aring', 197 },
+			{ 'AElig', 198 },
+			{ 'Ccedil', 199 },
+			{ 'Egrave', 200 },
+			{ 'Eacute', 201 },
+			{ 'Ecirc', 202 },
+			{ 'Euml', 203 },
+			{ 'lgrave', 204 },
+			{ 'lacute', 205 },
+			{ 'lcirc', 206 },
+			{ 'luml', 207 },
+			{ 'ETH', 208 },
+			{ 'Ntilde', 209 },
+			{ 'Ograve', 210 },
+			{ 'Oacute', 211 },
+			{ 'Ocirc', 212 },
+			{ 'Otilde', 213 },
+			{ 'Ouml', 214 },
+			{ 'times', 215 },
+			{ 'Oslash', 216 },
+			{ 'Ugrave', 217 },
+			{ 'Uacute', 218 },
+			{ 'Ucirc', 219 },
+			{ 'Uuml', 220 },
+			{ 'Yacute', 221 },
+			{ 'THORN', 222 },
+			{ 'szlig', 223 },
+			{ 'agrave', 224 },
+			{ 'aacute', 225 },
+			{ 'acirc', 226 },
+			{ 'atilde', 227 },
+			{ 'auml', 228 },
+			{ 'aring', 229 },
+			{ 'aelig', 230 },
+			{ 'ccedil', 231 },
+			{ 'egrave', 232 },
+			{ 'eacute', 233 },
+			{ 'ecirc', 234 },
+			{ 'euml', 235 },
+			{ 'igrave', 236 },
+			{ 'iacute', 237 },
+			{ 'icirc', 238 },
+			{ 'iuml', 239 },
+			{ 'eth', 240 },
+			{ 'ntilde', 241 },
+			{ 'ograve', 242 },
+			{ 'oacute', 243 },
+			{ 'ocirc', 244 },
+			{ 'otilde', 245 },
+			{ 'ouml', 246 },
+			{ 'divide', 247 },
+			{ 'oslash', 248 },
+			{ 'ugrave', 249 },
+			{ 'uacute', 250 },
+			{ 'ucirc', 251 },
+			{ 'uuml', 252 },
+			{ 'yacute', 253 },
+			{ 'thorn', 254 },
+			{ 'yuml', 255 },
+
+			{ 'OElig', 338 },
+			{ 'oelig', 339 },
+			{ 'Scaron', 352 },
+			{ 'scaron', 353 },
+			{ 'Yuml', 376 },
+
+			{ 'fnof', 402 },
+
+			{ 'circ', 710 },
+			{ 'tilde', 732 },
+
+			{ 'Alpha', 913 },
+			{ 'Beta', 914 },
+			{ 'Gamma', 915 },
+			{ 'Delta', 916 },
+			{ 'Epsilon', 917 },
+			{ 'Zeta', 918 },
+			{ 'Eta', 919 },
+			{ 'Theta', 920 },
+			{ 'Iota', 921 },
+			{ 'Kappa', 922 },
+			{ 'Lambda', 923 },
+			{ 'Mu', 924 },
+			{ 'Nu', 925 },
+			{ 'Xi', 926 },
+			{ 'Omicron', 927 },
+			{ 'Pi', 928 },
+			{ 'Rho', 929 },
+			{ 'Sigma', 931 },
+			{ 'Tau', 932 },
+			{ 'Upsilon', 933 },
+			{ 'Phi', 934 },
+			{ 'Chi', 935 },
+			{ 'Psi', 936 },
+			{ 'Omega', 937 },
+
+			{ 'alpha', 945 },
+			{ 'beta', 946 },
+			{ 'gamma', 947 },
+			{ 'delta', 948 },
+			{ 'epsilon', 949 },
+			{ 'zeta', 950 },
+			{ 'eta', 951 },
+			{ 'theta', 952 },
+			{ 'iota', 953 },
+			{ 'kappa', 954 },
+			{ 'lambda', 955 },
+			{ 'mu', 956 },
+			{ 'nu', 957 },
+			{ 'xi', 958 },
+			{ 'omicron', 959 },
+			{ 'pi', 960 },
+			{ 'rho', 961 },
+			{ 'sigmaf', 962 },
+			{ 'sigma', 963 },
+			{ 'tau', 964 },
+			{ 'upsilon', 965 },
+			{ 'phi', 966 },
+			{ 'chi', 967 },
+			{ 'psi', 968 },
+			{ 'omega', 969 },
+			{ 'thetasym', 977 },
+			{ 'upsih', 978 },
+			{ 'piv', 982 },
+
+			{ 'ensp', 8194 },
+			{ 'emsp', 8195 },
+			{ 'thinsp', 8201 },
+			{ 'zwnj', 8204 },
+			{ 'zwj', 8205 },
+			{ 'lrm', 8206 },
+			{ 'rlm', 8207 },
+			{ 'ndash', 8211 },
+			{ 'mdash', 8212 },
+			{ 'lsquo', 8216 },
+			{ 'rsquo', 8217 },
+			{ 'sbquo', 8218 },
+			{ 'ldquo', 8220 },
+			{ 'rdquo', 8221 },
+			{ 'bdquo', 8222 },
+			{ 'dagger', 8224 },
+			{ 'Dagger', 8225 },
+			{ 'bull', 8226 },
+			{ 'hellip', 8230 },
+			{ 'permil', 8240 },
+			{ 'prime', 8242 },
+			{ 'Prime', 8243 },
+			{ 'lsaquo', 8249 },
+			{ 'rsaquo', 8250 },
+			{ 'oline', 8254 },
+			{ 'frasl', 8260 },
+
+			{ 'euro', 8364 },
+
+			{ 'image', 8465 },
+			{ 'weierp', 8472 },
+			{ 'real', 8476 },
+			{ 'trade', 8482 },
+			{ 'alefsym', 8501 },
+
+			{ 'larr', 8592 },
+			{ 'uarr', 8593 },
+			{ 'rarr', 8594 },
+			{ 'darr', 8595 },
+			{ 'harr', 8596 },
+			{ 'crarr', 8629 },
+			{ 'lArr', 8656 },
+			{ 'uArr', 8657 },
+			{ 'rArr', 8658 },
+			{ 'dArr', 8659 },
+			{ 'hArr', 8660 },
+
+			{ 'forall', 8704 },
+			{ 'part', 8706 },
+			{ 'exist', 8707 },
+			{ 'empty', 8709 },
+			{ 'nabla', 8711 },
+			{ 'isin', 8712 },
+			{ 'notin', 8713 },
+			{ 'ni', 8715 },
+			{ 'prod', 8719 },
+			{ 'sum', 8721 },
+			{ 'minus', 8722 },
+			{ 'lowast', 8727 },
+			{ 'radic', 8730 },
+			{ 'prop', 8733 },
+			{ 'infin', 8734 },
+			{ 'ang', 8736 },
+			{ 'and', 8743 },
+			{ 'or', 8744 },
+			{ 'cap', 8745 },
+			{ 'cup', 8746 },
+			{ 'int', 8747 },
+			{ 'there4', 8756 },
+			{ 'sim', 8764 },
+			{ 'cong', 8773 },
+			{ 'asymp', 8776 },
+			{ 'ne', 8800 },
+			{ 'equiv', 8801 },
+			{ 'le', 8804 },
+			{ 'ge', 8805 },
+			{ 'sub', 8834 },
+			{ 'sup', 8835 },
+			{ 'nsub', 8836 },
+			{ 'sube', 8838 },
+			{ 'supe', 8839 },
+			{ 'oplus', 8853 },
+			{ 'otimes', 8855 },
+			{ 'perp', 8869 },
+			{ 'sdot', 8901 },
+
+			{ 'lceil', 8968 },
+			{ 'rceil', 8969 },
+			{ 'lfloor', 8970 },
+			{ 'rfloor', 8971 },
+			{ 'lang', 9001 },
+			{ 'rang', 9002 },
+			{ 'loz', 9674 },
+			{ 'spades', 9824 },
+			{ 'clubs', 8927 },
+			{ 'hearts', 9829 },
+			{ 'diams', 9830 },
+		];
+	}
+
+	
+	/**
+	 * Unescapes a string escaped in one of following ways:
+	 * 
+	 * <ul>
+	 * <li>A string escaped with single quotes (<code>'Hello "my" world'</code>)</li>
+	 * <li>A string escaped with double quotes (<code>"Hello 'my' world"</code>)</li>
+	 * <li>A near-literal string (<code>@"C:\Program Files\"</code>) in which escape sequences
+	 * aren't processed but the " character cannot occur</li>
+	 * </ul>
+	 * 
+	 * The following escape sequences are recognized:
+	 * <ul>
+	 * <li>\\</li>
+	 * <li>\'</li>
+	 * <li>\"</li>
+	 * <li>\&amp;namedCharacterEntity; (note that although redundant, \&amp;#ddd; and \&amp;#xXXXX; are also allowed)</li>
+	 * <li>\t</li>
+	 * <li>\n</li>
+	 * <li>\r</li>
+	 * <li>\b</li>
+	 * <li>\f</li>
+	 * <li>\&amp;uXXXX for unicode character points</li>
+	 * </ul>
+	 * 
+	 * @param escapedString escaped string
+	 * @return unescaped string
+	 */
+	[Precondition(ENFORCE, this.length >= 2, "String is not quoted")]
+	[Precondition(ENFORCE, (this[0] == '@' && this[1] in ['"', '\'']) || (this[0] in ['"', '\'']), "String is not quoted")]
+	[Precondition(ENFORCE, this[0] == this[$ - 1], "Unbalanced quotes")]
+	public const unescape() as Result<string, string>
+	{
+		val isLiteral = this[0] == '@';
+		var quoted = this;
+		if isLiteral
+			quoted = quoted[1 .. $];
+		
+		val quoteCharacter = this[0];
+		if isLiteral
+			return Ok(quoted[1 .. $ - 1]);
+		
+		val result = new StringBuilder(this.length - 2);
+		var i = 1;
+		while i < quoted.length - 1 {
+			if quoted[i] == '\\' {
+				if i >= quoted.length - 1
+					return Error('Unfinished escape sequence');
+				
+				switch quoted[i + 1] {
+					case '\\':
+						i++;
+						result << '\\';
+						break;
+					case '&':
+						val characterEntity = try!readCharacterEntity(quoted, i + 1);
+						i += characterEntity.stringValue.length + 2;
+						result << characterEntity.charValue;
+						break;
+					case 't': i++; result << '\t'; break;
+					case 'r': i++; result << '\r'; break;
+					case 'n': i++; result << '\n'; break;
+					case 'b': i++; result << '\b'; break;
+					case 'f': i++; result << '\f'; break;
+					case '"': i++; result << '\"'; break;
+					case '\'': i++; result << '\''; break;
+					case 'u':
+						if i >= quoted.length - 5
+							return Error('Unfinished escape sequence');
+						val hex0 = try!readHexCharacter(quoted[i + 2]);
+						val hex1 = try!readHexCharacter(quoted[i + 3]);
+						val hex2 = try!readHexCharacter(quoted[i + 4]);
+						val hex3 = try!readHexCharacter(quoted[i + 5]);
+						i += 5;
+						result << ((hex0 << 12) | (hex1 << 8) | (hex2 << 4) | hex3) as char;
+						break;
+					default:
+						return Error('Illegal escape sequence');
+				}
+			} else {
+				result << quoted[i];
+			}
+		}
+		
+		return Ok(result as string);
+	}
+	
+	/**
+	 * Escapes special characters in the given string, including ". (but not ').
+	 * Adds opening and closing quotes.
+	 * 
+	 * @param value value to be escaped
+	 * @param quote character (' or ")
+	 * @param escapeUnicode true to escape any non-ascii value, false to leave them be
+	 * @return escaped value
+	 */
+	public const escape(quote as char, escapeUnicode as bool) as string
+	{
+		val output = new StringBuilder();
+		output << quote;
+		for c in this {
+			switch c {
+				case '"':
+					if quote == '"'
+						output << "\\\"";
+					break;
+				case '\'':
+					if quote == '\''
+						output << "\\\'";
+					break;
+				case '\n': output << "\\n"; break;
+				case '\r': output << "\\r"; break;
+				case '\t': output << "\\t"; break;
+				default:
+					if escapeUnicode && c > 127 {
+						output << "\\u" << (c as int).toHexString().lpad(4, '0');
+					} else {
+						output << c;
+					}
+			}
+		}
+		
+		output << quote;
+		return output;
+	}
+	
+	/**
+	 * Reads a single hex digit and converts it to a value 0-15.
+	 * 
+	 * @param hex hex digit
+	 * @return converted value
+	 */
+	private static readHexCharacter(hex as char) as Result<int, string>
+	{
+		if hex >= '0' && hex <= '9'
+			return Ok(hex - '0');
+		
+		if hex >= 'A' && hex <= 'F'
+			return Ok(hex - 'A' + 10);
+		
+		if hex >= 'a' && hex <= 'f'
+			return Ok(hex - 'a' + 10);
+		
+		return Error("Illegal hex character: " + hex);
+	}
+	
+	/**
+	 * Reads a single character entity (formatted as &amp;characterEntity;) at the
+	 * given string offset.
+	 * 
+	 * The following formats are supported:
+	 * <ul>
+	 * <li>&amp;namedCharacterEntity;</li>
+	 * <li>&amp;#ddd</li>
+	 * <li>&amp;#xXXXX</li>
+	 * </ul>
+	 * 
+	 * The returned value includes the character entity, without the enclosing
+	 * &amp; and ; characters.
+	 * 
+	 * @param str string value to search in
+	 * @param offset offset to look at
+	 * @return character entity
+	 * @throws IllegalArgumentException if the given string does not contain a
+	 *	valid character entity at the given position
+	 */
+	[Precondition(ENFORCE, str[offset] == '&', 'Not a proper character entity')]
+	private static readCharacterEntity(str as string, offset as int) as Result<CharacterEntity, string>
+	{
+		if offset + 3 >= str.length
+			return Error('Incomplete character entity');
+		
+		val semi = str.indexOf(';', offset);
+		if semi < 0
+			return Error('Incomplete character entity');
+		
+		val entity = str[(offset + 1) .. semi];
+		if entity.isEmpty
+			return Error('Character entity cannot be empty');
+		
+		if entity in NAMED_CHARACTER_ENTITIES
+			return Ok(NAMED_CHARACTER_ENTITIES[entity]);
+		
+		if entity[0] == '#' {
+			if entity.length < 2
+				return Error('Character entity number too short');
+			
+			if str[1] == 'x' {
+				// hex character entity
+				if entity.length != 7
+					return Error('Hexadecimal character entity must have 4 hex digits');
+				
+				val ivalue = int.parse(entity[2 .. $], 16);
+				return Ok(new CharacterEntity(entity, ivalue as char));
+			} else {
+				// decimal character entity
+				val ivalue = int.parse(entity[1 .. $]);
+				return Ok(new CharacterEntity(entity, ivalue as char));
+			}
+		}
+		
+		return Error('Not a valid named character entity');
+	}
+}
+
+public struct CharacterEntity {
+	val charValue as char : get;
+	val stringValue as string : get;
+	
+	public this(stringValue as string, charValue as char) {
+		this.charValue = charValue;
+		this.stringValue = stringValue;
+	}
+}

shared/src/Taggable.zs

@@ -0,0 +1,12 @@
+public virtual class Taggable {
+	val tags as T[<T>] = {};
+	
+	public setTag<T>(tag as T) as void
+		=> tags.put<T>(tag);
+	
+	public getTag<T>() as T?
+		=> tags.getOptional<T>();
+	
+	public hasTag<T>() as bool
+		=> tags.contains<T>();
+}