Merge remote-tracking branch 'Stan/development' into development

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

 import org.openzen.zenscript.codemodel.expression.GetFieldExpression;
 import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
 import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.GetMatchingVariantField;
 import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
 import org.openzen.zenscript.codemodel.expression.GetterExpression;
 import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
 	public ExpressionString visitGetLocalVariable(GetLocalVariableExpression expression) {
 		return new ExpressionString(expression.variable.name, ZenScriptOperator.PRIMARY);
 	}
+	
+	@Override
+	public ExpressionString visitGetMatchingVariantField(GetMatchingVariantField expression) {
+		return new ExpressionString(expression.value.parameters[expression.index], ZenScriptOperator.PRIMARY);
+	}
 
 	@Override
 	public ExpressionString visitGetStaticField(GetStaticFieldExpression expression) {

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

 		hasUnknowns = hasUnknowns(parameters, returnType);
 	}
 	
-	public FunctionHeader(TypeParameter[] genericParameters, ITypeID returnType, ITypeID thrownType, FunctionParameter... parameters) {
+	public FunctionHeader(TypeParameter[] typeParameters, ITypeID returnType, ITypeID thrownType, FunctionParameter... parameters) {
 		if (returnType == null)
 			throw new NullPointerException();
-		if (genericParameters == null)
+		if (typeParameters == null)
 			throw new NullPointerException();
 		
-		this.typeParameters = genericParameters;
+		this.typeParameters = typeParameters;
 		this.returnType = returnType;
 		this.parameters = parameters;
 		this.thrownType = thrownType;
 	}
 	
 	public boolean canOverride(TypeScope scope, FunctionHeader other) {
+		if (other == null)
+			throw new NullPointerException();
 		if (parameters.length != other.parameters.length)
 			return false;
 		if (returnType != BasicTypeID.UNDETERMINED && !scope.getTypeMembers(returnType).canCastImplicit(other.returnType))

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

 import org.openzen.zenscript.codemodel.annotations.DefinitionAnnotation;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
 import org.openzen.zenscript.codemodel.definition.DefinitionVisitor;
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 	}
 	
 	public void normalize(TypeScope scope) {
+		DestructorMember destructor = null;
+		List<FieldMember> fields = new ArrayList();
+		
 		for (IDefinitionMember member : members) {
 			member.normalize(scope);
+			
+			if (member instanceof DestructorMember)
+				destructor = (DestructorMember)member;
+			if (member instanceof FieldMember)
+				fields.add((FieldMember)member);
+		}
+		
+		if (isDestructible() && destructor == null && !(this instanceof ExpansionDefinition)) {
+			System.out.println("Added destructor to " + position);
+			destructor = new DestructorMember(position, this, Modifiers.PUBLIC);
+			members.add(destructor);
+		}
+		
+		for (FieldMember field : fields) {
+			if (field.autoGetter != null)
+				members.add(field.autoGetter);
+			if (field.autoSetter != null)
+				members.add(field.autoSetter);
 		}
 	}
 	

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

 import java.util.List;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
  * @author Hoofdgebruiker
  */
 public class CompilingPackage {
+	private final ZSPackage pkg;
 	private final Map<String, CompilingPackage> packages = new HashMap<>();
 	private final Map<String, CompilingType> types = new HashMap<>();
 	
+	public CompilingPackage(ZSPackage pkg) {
+		this.pkg = pkg;
+	}
+	
+	public ZSPackage getPackage() {
+		return pkg;
+	}
+	
+	public CompilingPackage getOrCreatePackage(String name) {
+		if (packages.containsKey(name))
+			return packages.get(name);
+		
+		CompilingPackage newPackage = new CompilingPackage(pkg.getOrCreatePackage(name));
+		packages.put(name, newPackage);
+		return newPackage;
+	}
+	
 	public void addPackage(String name, CompilingPackage package_) {
 		packages.put(name, package_);
 	}
 	
 	private HighLevelDefinition getImportType(TypeResolutionContext context, CompilingType type, List<String> name, int index) {
 		if (index == name.size())
-			return type.load(context);
+			return type.load();
 		
 		return getImportType(context, type.getInner(name.get(index)), name, index + 1);
 	}
 		
 		if (types.containsKey(name.get(index).name)) {
 			CompilingType type = types.get(name.get(index).name);
-			DefinitionTypeID result = context.getTypeRegistry().getForDefinition(type.load(context), name.get(index).arguments);
+			DefinitionTypeID result = context.getTypeRegistry().getForDefinition(type.load(), name.get(index).arguments);
 			return getInner(context, name, index + 1, type, result);
 		}
 		
 		if (innerType == null)
 			return null;
 		
-		DefinitionTypeID innerResult = context.getTypeRegistry().getForDefinition(innerType.load(context), name.get(index).arguments, result);
+		DefinitionTypeID innerResult = context.getTypeRegistry().getForDefinition(innerType.load(), name.get(index).arguments, result);
 		return getInner(context, name, index + 1, innerType, innerResult);
 	}
 }

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 
 /**
  *
 public interface CompilingType {
 	CompilingType getInner(String name);
 	
-	HighLevelDefinition load(TypeResolutionContext context);
+	HighLevelDefinition load();
 	
-	default DefinitionTypeID getInnerType(TypeResolutionContext context, List<GenericName> name, int index, DefinitionTypeID outer) {
-		DefinitionTypeID type = context.getTypeRegistry().getForDefinition(load(context), name.get(index).arguments, outer);
+	default DefinitionTypeID getInnerType(GlobalTypeRegistry registry, List<GenericName> name, int index, DefinitionTypeID outer) {
+		DefinitionTypeID type = registry.getForDefinition(load(), name.get(index).arguments, outer);
 		index++;
 		if (index == name.size())
 			return type;
 		if (innerType == null)
 			return null;
 		
-		return innerType.getInnerType(context, name, index, type);
+		return innerType.getInnerType(registry, name, index, type);
 	}
 }

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

  */
 public class FileResolutionContext implements TypeResolutionContext {
 	private final ModuleTypeResolutionContext module;
+	private final CompilingPackage modulePackage;
 	private final Map<String, HighLevelDefinition> imports = new HashMap<>();
 	
-	public FileResolutionContext(ModuleTypeResolutionContext module) {
+	public FileResolutionContext(ModuleTypeResolutionContext module, CompilingPackage modulePackage) {
 		this.module = module;
+		this.modulePackage = modulePackage;
 	}
 	
 	public void addImport(String name, HighLevelDefinition definition) {
 					1);
 		}
 		
+		ITypeID moduleType = modulePackage.getType(this, name);
+		if (moduleType != null)
+			return moduleType;
+		
 		return module.getType(position, name);
 	}
 

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

 		if (type != null) {
 			CompilingType compiling = type.getInner(name.get(0).name);
 			if (compiling != null) {
-				DefinitionTypeID outer = getTypeRegistry().getForMyDefinition(type.load(this));
-				return compiling.getInnerType(this, name, 0, outer);
+				DefinitionTypeID outer = getTypeRegistry().getForMyDefinition(type.load());
+				return compiling.getInnerType(getTypeRegistry(), name, 0, outer);
 			}
 		}
 		
 	
 	@Override
 	public ITypeID getThisType() {
-		return type == null ? null : getTypeRegistry().getForMyDefinition(type.load(this));
+		return type == null ? null : getTypeRegistry().getForMyDefinition(type.load());
 	}
 }

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

 		baseInterfaces.add(baseInterface);
 	}
 	
+	@Override
+	public boolean isDestructible() {
+		for (ITypeID baseInterface : baseInterfaces)
+			if (baseInterface.isDestructible())
+				return true;
+		
+		return super.isDestructible();
+	}
+	
 	@Override
 	public boolean isStatic() {
 		return true;

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

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

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

 	
 	public T visitGetLocalVariable(GetLocalVariableExpression expression);
 	
+	public T visitGetMatchingVariantField(GetMatchingVariantField expression);
+	
 	public T visitGetStaticField(GetStaticFieldExpression expression);
 	
 	public T visitGetter(GetterExpression expression);

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.expression;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class GetMatchingVariantField extends Expression {
+	public final VariantOptionSwitchValue value;
+	public final int index;
+	
+	public GetMatchingVariantField(CodePosition position, VariantOptionSwitchValue value, int index) {
+		super(position, value.option.types[index], null);
+		
+		this.value = value;
+		this.index = index;
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitGetMatchingVariantField(this);
+	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/switchvalue/VariantOptionSwitchValue.java

 package org.openzen.zenscript.codemodel.expression.switchvalue;
 
 import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
-import org.openzen.zenscript.codemodel.statement.VarStatement;
 
 /**
  *
  */
 public class VariantOptionSwitchValue implements SwitchValue {
 	public final VariantOptionRef option;
-	public final VarStatement[] parameters;
+	public final String[] parameters;
 	
-	public VariantOptionSwitchValue(VariantOptionRef option, VarStatement[] parameters) {
+	public VariantOptionSwitchValue(VariantOptionRef option, String[] parameters) {
 		this.option = option;
 		this.parameters = parameters;
 	}

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
-import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;

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

 		type = type.getNormalized();
 		value = value.normalize(scope);
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

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

 	public final CodePosition position;
 	public final HighLevelDefinition definition;
 	public final String name;
-	public final int value;
+	public final int ordinal;
 	
 	public NewExpression constructor;
 	
-	public EnumConstantMember(CodePosition position, HighLevelDefinition definition, String name, int value) {
+	public EnumConstantMember(CodePosition position, HighLevelDefinition definition, String name, int ordinal) {
 		this.position = position;
 		this.definition = definition;
 		this.name = name;
-		this.value = value;
+		this.ordinal = ordinal;
 	}
 }

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

 		if (initializer != null)
 			initializer = initializer.normalize(scope);
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

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

 		if (body != null)
 			body = body.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class));
 	}
+	
+	@Override
+	public boolean isAbstract() {
+		return body == null && builtin == null;
+	}
 }

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
+import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 		this.type = type;
 	}
 	
+	@Override
+	public void setBody(Statement body) {
+		super.setBody(body);
+		
+		if (type == BasicTypeID.UNDETERMINED)
+			type = body.getReturnType();
+	}
+	
 	@Override
 	public ITypeID getType() {
 		return type;

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

 	DefinitionMemberRef getOverrides();
 
 	public void normalize(TypeScope scope);
+	
+	boolean isAbstract();
 }

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

  */
 package org.openzen.zenscript.codemodel.member;
 
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
  *
  * @author Hoofdgebruiker
  */
-public interface IPropertyMember {
+public interface IPropertyMember extends IDefinitionMember {
 	ITypeID getType();
 	
-	CodePosition getPosition();
-	
-	String describe();
-
-	<T> T getTag(Class<T> type);
-	
 	boolean isStatic();
 	
 	boolean isFinal();

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

 		for (IDefinitionMember member : members)
 			member.normalize(scope);
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

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

 	public void normalize(TypeScope scope) {
 		innerDefinition.normalize(scope);
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

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

 	public void normalize(TypeScope scope) {
 		body = body.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class));
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/ArrayIteratorKeyValues.java

 	public void normalize(TypeScope scope) {
 		
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/ArrayIteratorValues.java

 	public void normalize(TypeScope scope) {
 		
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/AssocIterator.java

 	public void normalize(TypeScope scope) {
 		
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/RangeIterator.java

 	public void normalize(TypeScope scope) {
 		
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/StringCharIterator.java

 	public void normalize(TypeScope scope) {
 		
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/CasterMemberRef.java

 import org.openzen.zenscript.codemodel.expression.CastExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.CasterMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 	public MemberAnnotation[] getAnnotations() {
 		return member.annotations;
 	}
+
+	@Override
+	public IDefinitionMember getTarget() {
+		return member;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/DefinitionMemberRef.java

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 
 /**
  *
 	FunctionHeader getHeader();
 	
 	MemberAnnotation[] getAnnotations();
+	
+	IDefinitionMember getTarget();
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/ImplementationMemberRef.java

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 	public MemberAnnotation[] getAnnotations() {
 		return member.annotations;
 	}
+
+	@Override
+	public IDefinitionMember getTarget() {
+		return member;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/IteratorMemberRef.java

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.IIteratorMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 			return null;
 		}
 	}
+
+	@Override
+	public IDefinitionMember getTarget() {
+		return target;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/PropertyRef.java

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.IPropertyMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	public final MemberAnnotation[] getAnnotations() {
 		return member.getAnnotations();
 	}
+	
+	@Override
+	public final IDefinitionMember getTarget() {
+		return member;
+	}
 }

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.GetMatchingVariantField;
+import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 	
 	public final List<ITypeID> hints;
 	public final Map<TypeParameter, ITypeID> genericInferenceMap;
-	public final Map<String, VarStatement> innerVariables = new HashMap<>();
+	public final Map<String, Function<CodePosition, Expression>> innerVariables = new HashMap<>();
 	
 	public ExpressionScope(BaseScope outer) {
 		this.outer = outer;
 			List<ITypeID> hints,
 			Function<CodePosition, Expression> dollar,
 			Map<TypeParameter, ITypeID> genericInferenceMap,
-			Map<String, VarStatement> innerVariables) {
+			Map<String, Function<CodePosition, Expression>> innerVariables) {
 		this.outer = scope;
 		this.hints = hints;
 		this.dollar = dollar;
 	}
 	
 	public void addInnerVariable(VarStatement variable) {
-		innerVariables.put(variable.name, variable);
+		innerVariables.put(variable.name, position -> new GetLocalVariableExpression(position, variable));
+	}
+	
+	public void addMatchingVariantOption(String name, int index, VariantOptionSwitchValue value) {
+		innerVariables.put(name, position -> new GetMatchingVariantField(position, value, index));
 	}
 	
 	public List<ITypeID> getResultTypeHints() {
 	@Override
 	public IPartialExpression get(CodePosition position, GenericName name) {
 		if (name.hasNoArguments() && innerVariables.containsKey(name.name))
-			return new GetLocalVariableExpression(position, innerVariables.get(name.name));
+			return innerVariables.get(name.name).apply(position);
 		
 		return outer.get(position, name);
 	}

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

 
 	@Override
 	public Statement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
-		Expression tValue = value.transform(transformer);
+		Expression tValue = value == null ? null : value.transform(transformer);
 		return tValue == value ? this : new ReturnStatement(position, tValue);
 	}
 
 	@Override
 	public Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
-		Expression tValue = value.transform(transformer);
+		Expression tValue = value == null ? null : value.transform(transformer);
 		return tValue == value ? this : new ReturnStatement(position, tValue);
 	}
 
 	@Override
 	public Statement normalize(TypeScope scope, ConcatMap<LoopStatement, LoopStatement> modified) {
-		return new ReturnStatement(position, value.normalize(scope));
+		return new ReturnStatement(position, value == null ? null : value.normalize(scope));
 	}
 }

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

 				for (ITypeID resultHint : typeHints) {
 					Map<TypeParameter, ITypeID> mapping = new HashMap<>();
 					if (header.returnType.inferTypeParameters(scope.getMemberCache(), resultHint, mapping)) {
-						header = header.withGenericArguments(new GenericMapper(scope.getTypeRegistry(), mapping));
+						header = header.withGenericArguments(scope.getLocalTypeParameters().getInner(mapping));
 						break;
 					}
 				}

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

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.InnerDefinition;
 import org.openzen.zenscript.codemodel.member.ref.CasterMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
 		return null;
 	}
 	
+	public List<IDefinitionMember> getUnimplementedMembers(Set<IDefinitionMember> implemented) {
+		List<IDefinitionMember> result = new ArrayList<>();
+		for (TypeMember<CasterMemberRef> caster : casters) {
+			if (caster.member.member.isAbstract() && !implemented.contains(caster.member.member))
+				result.add(caster.member.member);
+		}
+		for (TypeMember<IteratorMemberRef> iterator : iterators) {
+			if (iterator.member.target.isAbstract() && !implemented.contains(iterator.member.target))
+				result.add(iterator.member.target);
+		}
+		for (Map.Entry<String, DefinitionMemberGroup> entry : members.entrySet()) {
+			DefinitionMemberGroup group = entry.getValue();
+			if (group.getGetter() != null && group.getGetter().member.isAbstract() && !implemented.contains(group.getGetter().member))
+				result.add(group.getGetter().member);
+			if (group.getSetter() != null && group.getSetter().member.isAbstract() && !implemented.contains(group.getSetter().member))
+				result.add(group.getSetter().member);
+			for (TypeMember<FunctionalMemberRef> member : group.getMethodMembers())
+				if (member.member.getTarget().isAbstract() && !implemented.contains(member.member.getTarget()))
+					result.add(member.member.getTarget());
+		}
+		for (Map.Entry<OperatorType, DefinitionMemberGroup> entry : operators.entrySet()) {
+			if (entry.getKey() == OperatorType.DESTRUCTOR)
+				continue; // destructor doesn't have to be implemented; the compiler can do so automatically
+			
+			DefinitionMemberGroup group = entry.getValue();
+			if (group.getGetter() != null && group.getGetter().member.isAbstract() && !implemented.contains(group.getGetter().member))
+				result.add(group.getGetter().member);
+			if (group.getSetter() != null && group.getSetter().member.isAbstract() && !implemented.contains(group.getSetter().member))
+				result.add(group.getSetter().member);
+			for (TypeMember<FunctionalMemberRef> member : group.getMethodMembers())
+				if (member.member.getTarget().isAbstract() && !implemented.contains(member.member.getTarget()))
+					result.add(member.member.getTarget());
+		}
+		return result;
+	}
+	
 	public void addConstructor(FunctionalMemberRef constructor, TypeMemberPriority priority) {
 		getOrCreateGroup(OperatorType.CONSTRUCTOR).addMethod(constructor, priority);
 	}

Constructor/src/main/java/org/openzen/zenscript/constructor/Module.java

 		}
 	}
 	
-	public ParsedFile[] parse(ZSPackage pkg, CompilingPackage compilingPackage) throws IOException {
+	public ParsedFile[] parse(CompilingPackage compilingPackage) throws IOException {
 		// TODO: load bracket parsers from host plugins
 		List<ParsedFile> files = new ArrayList<>();
-		parse(files, pkg, compilingPackage, null, sourceDirectory);
+		parse(files, compilingPackage, null, sourceDirectory);
 		return files.toArray(new ParsedFile[files.size()]);
 	}
 	
-	private void parse(List<ParsedFile> files, ZSPackage pkg, CompilingPackage compilingPackage, BracketExpressionParser bracketParser, File directory) throws IOException {
+	private void parse(List<ParsedFile> files, CompilingPackage pkg, BracketExpressionParser bracketParser, File directory) throws IOException {
 		for (File file : directory.listFiles()) {
 			if (file.getName().endsWith(".zs")) {
 				try {
-					files.add(ParsedFile.parse(pkg, compilingPackage, bracketParser, file));
+					files.add(ParsedFile.parse(pkg, bracketParser, file));
 				} catch (CompileException ex) {
 					exceptionLogger.accept(ex);
 				}
 			} else if (file.isDirectory()) {
-				CompilingPackage innerPackage = new CompilingPackage();
-				compilingPackage.addPackage(file.getName(), innerPackage);
-				parse(files, pkg.getOrCreatePackage(file.getName()), innerPackage, bracketParser, file);
+				CompilingPackage innerPackage = pkg.getOrCreatePackage(file.getName());
+				pkg.addPackage(file.getName(), innerPackage);
+				parse(files, innerPackage, bracketParser, file);
 			}
 		}
 	}
 	public static SemanticModule compileSyntaxToSemantic(
 			String name,
 			String[] dependencies,
-			ZSPackage pkg,
-			CompilingPackage compilingPkg,
+			CompilingPackage pkg,
 			ParsedFile[] files,
 			ModuleSpace registry,
 			Consumer<CompileException> exceptionLogger) {
 				registry.compilationUnit.globalTypeRegistry,
 				registry.getAnnotations(),
 				rootPackage,
-				compilingPkg,
+				pkg,
 				globals);
 		
+		for (ParsedFile file : files) {
+			file.registerTypes(moduleContext, rootPackage, pkg);
+		}
+		
 		for (ParsedFile file : files) {
 			// compileMembers will register all definition members to their
 			// respective definitions, such as fields, constructors, methods...
 			// It doesn't yet compile the method contents.
 			try {
-				file.compileTypes(moduleContext, rootPackage, compilingPkg);
+				file.compileTypes(moduleContext, rootPackage, pkg);
 			} catch (CompileException ex) {
 				exceptionLogger.accept(ex);
 				failed = true;
 		}
 		
 		if (failed)
-			return new SemanticModule(name, dependencies, SemanticModule.State.INVALID, rootPackage, pkg, definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations());
+			return new SemanticModule(name, dependencies, SemanticModule.State.INVALID, rootPackage, pkg.getPackage(), definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations());
 		
 		// scripts will store all the script blocks encountered in the files
 		PrecompilationState precompiler = new PrecompilationState();
 		for (ParsedFile file : files) {
-			file.registerMembers(moduleContext, precompiler, rootPackage, compilingPkg, expansions, globals);
+			file.registerMembers(moduleContext, precompiler, rootPackage, pkg, expansions, globals);
 		}
 		
 		List<ScriptBlock> scripts = new ArrayList<>();
 			// into semantic code. This semantic code can then be compiled
 			// to various targets.
 			try {
-				file.compileCode(moduleContext, precompiler, rootPackage, compilingPkg, expansions, scripts, globals);
+				file.compileCode(moduleContext, precompiler, rootPackage, pkg, expansions, scripts, globals);
 			} catch (CompileException ex) {
 				exceptionLogger.accept(ex);
 				failed = true;
 			}
 		}
 		
-		return new SemanticModule(name, dependencies, SemanticModule.State.ASSEMBLED, rootPackage, pkg, definitions, scripts, registry.compilationUnit, expansions, registry.getAnnotations());
+		return new SemanticModule(name, dependencies, SemanticModule.State.ASSEMBLED, rootPackage, pkg.getPackage(), definitions, scripts, registry.compilationUnit, expansions, registry.getAnnotations());
 	}
 }

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

 
 			Module module = new Module(moduleName, directory, jsonFile, exceptionLogger);
 			ZSPackage pkg = isStdlib ? unit.globalTypeRegistry.stdlib : new ZSPackage(null, module.packageName);
-			CompilingPackage compilingPackage = new CompilingPackage();
+			CompilingPackage compilingPackage = new CompilingPackage(pkg);
 			
-			ParsedFile[] parsedFiles = module.parse(pkg, compilingPackage);
-			SemanticModule result = Module.compileSyntaxToSemantic(module.name, module.dependencies, pkg, compilingPackage, parsedFiles, space, exceptionLogger);
+			ParsedFile[] parsedFiles = module.parse(compilingPackage);
+			SemanticModule result = Module.compileSyntaxToSemantic(module.name, module.dependencies, compilingPackage, parsedFiles, space, exceptionLogger);
 			
 			JSONObject globals = json.optJSONObject("globals");
 			if (globals != null) {

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaCompiler.java

 
 	@Override
 	public void addDefinition(HighLevelDefinition definition, SemanticModule module) {
-		String className = getClassName(definition.position.filename);
+		String className = getClassName(definition.position.getFilename());
 		JavaScriptFile scriptFile = getScriptFile(className);
 		target.register(definition.name, definition.accept(new JavaDefinitionVisitor(scriptFile.classWriter)));
 	}

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

 	}
 
 	public static String calcClasName(CodePosition position) {
-		return position.filename.substring(0, position.filename.lastIndexOf('.')).replace("/", "_");
+		return position.getFilename().substring(0, position.getFilename().lastIndexOf('.')).replace("/", "_");
 	}
 
 	public static void tagMethodParameters(FunctionHeader header, boolean isStatic) {
 
 		@Override
 		public Integer acceptEnumConstant(EnumConstantSwitchValue value) {
-			return value.constant.value;
+			return value.constant.ordinal;
 		}
 
 		@Override

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

 		return null;
 	}
 
+	@Override
+	public Void visitGetMatchingVariantField(GetMatchingVariantField expression) {
+		throw new UnsupportedOperationException(); // TODO
+	}
+
 	@Override
 	public Void visitGetStaticField(GetStaticFieldExpression expression) {
 		if (!checkAndGetFieldInfo(expression.field, true))

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

 		return null;
 	}
 
+	@Override
+	public Void visitGetMatchingVariantField(GetMatchingVariantField expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
 	@Override
 	public Void visitGetStaticField(GetStaticFieldExpression expression) {
 		if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))

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

 		return null;
 	}
 
+	@Override
+	public Void visitGetMatchingVariantField(GetMatchingVariantField expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
 	@Override
 	public Void visitGetStaticField(GetStaticFieldExpression expression) {
 		if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))

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

 
 	@Override
 	public byte[] visitEnum(EnumDefinition definition) {
-		System.out.println("Compiling enum " + definition.name + " in " + definition.position.filename);
+		System.out.println("Compiling enum " + definition.name + " in " + definition.position.getFilename());
 
 		final Type superType;
 		if (definition.getSuperType() == null)

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

 				clinitWriter.newObject(internalName);
 				clinitWriter.dup();
 				clinitWriter.constant(constant.name);
-				clinitWriter.constant(constant.value);
+				clinitWriter.constant(constant.ordinal);
 				for (Expression argument : constant.constructor.arguments.arguments) {
 					argument.accept(clinitStatementVisitor.expressionVisitor);
 				}
 
 			for (EnumConstantMember enumConstant : enumConstants) {
 				clinitWriter.dup();
-				clinitWriter.constant(enumConstant.value);
+				clinitWriter.constant(enumConstant.ordinal);
 				clinitWriter.getStaticField(definition.name, enumConstant.name, "L" + definition.name + ";");
 				clinitWriter.arrayStore(Type.getType("L" + definition.name + ";"));
 			}

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

 import org.openzen.zenscript.codemodel.expression.GetFieldExpression;
 import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
 import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.GetMatchingVariantField;
 import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
 import org.openzen.zenscript.codemodel.expression.GetterExpression;
 import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
 		return false;
 	}
 
+	@Override
+	public Boolean visitGetMatchingVariantField(GetMatchingVariantField expression) {
+		return false;
+	}
+
 	@Override
 	public Boolean visitGetStaticField(GetStaticFieldExpression expression) {
 		return false;

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

 	@Override
 	public Void visitClass(ClassDefinition definition) {
 		JavaSourceFileScope scope = createScope(definition);
+		JavaSourceClass cls = definition.getTag(JavaSourceClass.class);
 		
 		output.append(indent);
 		convertModifiers(definition.modifiers);
-		output.append("class ").append(definition.name);
+		output.append("class ").append(cls.getName());
 		JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, definition.genericParameters, false);
 		if (definition.getSuperType() != null) {
 			output.append(" extends ");
 			}
 		}
 		
-		if (mergedImplementations.size() > 0 || definition.isDestructible()) {
+		if (mergedImplementations.size() > 0 || cls.destructible) {
 			output.append(" implements ");
 			boolean first = true;
 			for (int i = 0; i < mergedImplementations.size(); i++) {
 				output.append(scope.type(implementation.type));
 			}
 			
-			if (definition.isDestructible()) {
+			if (cls.destructible) {
 				if (first)
 					first = false;
 				else
 	@Override
 	public Void visitInterface(InterfaceDefinition definition) {
 		JavaSourceFileScope scope = createScope(definition);
+		JavaSourceClass cls = definition.getTag(JavaSourceClass.class);
 		
 		output.append(indent);
 		convertModifiers(definition.modifiers | Modifiers.VIRTUAL); // to prevent 'final'
-		output.append("interface ").append(definition.name);
+		output.append("interface ").append(cls.getName());
 		JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, definition.genericParameters, false);
-			
+		
+		boolean firstExtends = true;
 		if (definition.isDestructible()) {
 			output.append(" extends ");
 			output.append(scope.importer.importType(new JavaSourceClass("java.lang", "AutoCloseable")));
+			firstExtends = false;
+		}
+		
+		for (ITypeID base : definition.baseInterfaces) {
+			if (firstExtends) {
+				firstExtends = false;
+				output.append(" extends ");
+			} else {
+				output.append(", ");
+			}
+			output.append(scope.type(base));
 		}
 		
 		output.append(" {\n");
 				String name = option.types.length == 1 ? "value" : "value" + (i + 1);
 				output.append(scope.type(option.types[i])).append(' ').append(name);
 			}
-			output.append("){\n");
+			output.append(") {\n");
 			for (int i = 0; i < option.types.length; i++) {
 				if (i > 0)
 					output.append(indent).append(settings.indent).append(settings.indent).append(settings.indent).append(";\n");

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

 
 	@Override
 	public Void visitDestructor(DestructorMember member) {
-		throw new UnsupportedOperationException("Expansions cannot declare destructors");
+		return null; // ignore
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.ConstMember;
 import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
+import org.openzen.zenscript.codemodel.statement.BlockStatement;
 import org.openzen.zenscript.codemodel.statement.EmptyStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 		
 		output.append(indent).append("@Override\n");
 		output.append(indent).append("public void close()");
-		compileBody(member.body, member.header);
+		
+		Statement body = member.body;
+		if ((body == null || body instanceof EmptyStatement) && !(definition instanceof InterfaceDefinition))
+			body = new BlockStatement(member.position, Collections.emptyList());
+		
+		compileBody(body, member.header);
 		return null;
 	}
 
 	}
 	
 	public void finish() {
-		// TODO: needs to be moved elsewhere (normalization stage?)
-		for (FieldMember field : fields) {
-			if (field.autoGetter != null)
-				visitGetter(field.autoGetter);
-			if (field.autoSetter != null)
-				visitSetter(field.autoSetter);
-		}
+		
 	}
 }

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

 import org.openzen.zenscript.codemodel.expression.GetFieldExpression;
 import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
 import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.GetMatchingVariantField;
 import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
 import org.openzen.zenscript.codemodel.expression.GetterExpression;
 import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
 		return new ExpressionString(expression.variable.name, JavaOperator.PRIMARY);
 	}
 
+	@Override
+	public ExpressionString visitGetMatchingVariantField(GetMatchingVariantField expression) {
+		return new ExpressionString(expression.value.parameters[expression.index], JavaOperator.PRIMARY);
+	}
+
 	@Override
 	public ExpressionString visitGetStaticField(GetStaticFieldExpression expression) {
 		JavaSourceField field = expression.field.getTag(JavaSourceField.class);
 					throw new UnsupportedOperationException("Not yet supported!");
 				}
 			}
-			case ARRAY_CONSTRUCTOR_PROJECTED_INDEXED:
+			case ARRAY_CONSTRUCTOR_PROJECTED_INDEXED: {
 				ArrayTypeID type = (ArrayTypeID) expression.type;
 				
 				if (type.dimension == 1) {
 					// TODO: implement
 					throw new UnsupportedOperationException("Not yet supported!");
 				}
+			}
+			case CLASS_DEFAULT_CONSTRUCTOR:
+				return new ExpressionString("new " + scope.type(expression.type) + "()", JavaOperator.NEW);
 		}
 		
 		throw new UnsupportedOperationException("Unknown builtin constructor: " + expression.constructor.getBuiltin());

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

 				String header = switchValue == null ? "default:" : "case " + switchValue.option.getName() + ":";
 				List<String> statements = new ArrayList<>();
 				if (switchValue != null) {
-					for (VarStatement var : switchValue.parameters) {
+					for (int i = 0; i < switchValue.parameters.length; i++) {
 						StringBuilder statementOutput = new StringBuilder();
-						statementOutput.append(scope.type(var.type)).append(" ").append(var.name).append(" = ((").append(variantTypeName).append(".").append(switchValue.option.getName());
+						statementOutput.append(scope.type(switchValue.option.types[i])).append(" ").append(switchValue.parameters[i]).append(" = ((").append(variantTypeName).append(".").append(switchValue.option.getName());
 						if (variant.genericParameters != null && variant.genericParameters.length > 0) {
 							statementOutput.append("<");
-							for (int i = 0; i < variantType.typeParameters.length; i++) {
-								if (i > 0)
+							for (int j = 0; j < variantType.typeParameters.length; j++) {
+								if (j > 0)
 									statementOutput.append(", ");
-								statementOutput.append(scope.type(variantType.typeParameters[i]));
+								statementOutput.append(scope.type(variantType.typeParameters[j]));
 							}
 							statementOutput.append(">");
 						}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaNativeClass.java

 public class JavaNativeClass {
 	public final JavaSourceClass cls;
 	private final Map<String, JavaSourceMethod> methods = new HashMap<>();
+	public final boolean nonDestructible;
 	
 	public JavaNativeClass(JavaSourceClass cls) {
+		this(cls, false);
+	}
+	
+	public JavaNativeClass(JavaSourceClass cls, boolean nonDestructible) {
 		this.cls = cls;
+		this.nonDestructible = nonDestructible;
 	}
 	
 	public void addMethod(String key, JavaSourceMethod method) {

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareClassMethodVisitor.java

 import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.javasource.JavaSourceTypeNameVisitor;
 import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 import org.openzen.zenscript.javasource.tags.JavaSourceField;
  * @author Hoofdgebruiker
  */
 public class JavaSourcePrepareClassMethodVisitor implements MemberVisitor<Void> {
+	private static final boolean DEBUG_EMPTY = true;
+	
+	private final JavaSourcePrepareDefinitionVisitor definitionPreparer;
 	private final String filename;
 	private final JavaSourceClass cls;
 	private final JavaNativeClass nativeClass;
 	
-	public JavaSourcePrepareClassMethodVisitor(String filename, JavaSourceClass cls, JavaNativeClass nativeClass, boolean startsEmpty) {
+	public JavaSourcePrepareClassMethodVisitor(
+			JavaSourcePrepareDefinitionVisitor definitionPreparer,
+			String filename,
+			JavaSourceClass cls,
+			JavaNativeClass nativeClass,
+			boolean startsEmpty) {
+		this.definitionPreparer = definitionPreparer;
 		this.filename = filename;
 		this.cls = cls;
 		this.nativeClass = nativeClass;
+		
 		cls.empty = startsEmpty;
 	}
 	
 	@Override
 	public Void visitConst(ConstMember member) {
+		if (DEBUG_EMPTY && cls.empty)
+			System.out.println("Class " + cls.fullName + " not empty because of const " + member.name);
+		
 		cls.empty = false;
 		member.setTag(JavaSourceField.class, new JavaSourceField(cls, member.name));
 		return null;
 	
 	@Override
 	public Void visitField(FieldMember member) {
-		cls.empty = false;
 		member.setTag(JavaSourceField.class, new JavaSourceField(cls, member.name));
 		if (member.hasAutoGetter())
 			visitGetter(member.autoGetter);
 
 	@Override
 	public Void visitDestructor(DestructorMember member) {
+		if (DEBUG_EMPTY && cls.empty)
+			System.out.println("Class " + cls.fullName + " not empty because of destructor");
+		
 		cls.empty = false;
 		return null;
 	}
 
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
-		cls.empty = false;
+		definitionPreparer.prepare(member.type);
+		
 		if (canMergeImplementation(member)) {
 			member.setTag(JavaSourceImplementation.class, new JavaSourceImplementation(true, cls));
 			for (IDefinitionMember m : member.members)
 				m.accept(this);
 		} else {
+			if (DEBUG_EMPTY && cls.empty)
+				System.out.println("Class " + cls.fullName + " not empty because of unmergeable implementation");
+			
+			cls.empty = false;
+			
 			JavaSourceClass implementationClass = new JavaSourceClass(cls, member.type.accept(new JavaSourceTypeNameVisitor()) + "Implementation");
 			member.setTag(JavaSourceImplementation.class, new JavaSourceImplementation(false, implementationClass));
 			
-			JavaSourcePrepareClassMethodVisitor visitor = new JavaSourcePrepareClassMethodVisitor(filename, implementationClass, null, true);
+			JavaSourcePrepareClassMethodVisitor visitor = new JavaSourcePrepareClassMethodVisitor(definitionPreparer, filename, implementationClass, null, true);
 			for (IDefinitionMember m : member.members)
 				m.accept(visitor);
 		}
 		JavaSourcePrepareDefinitionVisitor innerDefinitionPrepare = new JavaSourcePrepareDefinitionVisitor(filename, cls);
 		member.innerDefinition.accept(innerDefinitionPrepare);
 		
+		if (DEBUG_EMPTY && cls.empty)
+			System.out.println("Class " + cls.fullName + " not empty because of inner definition " + member.innerDefinition.name);
 		cls.empty = false;
 		return null;
 	}
 
 	@Override
 	public Void visitStaticInitializer(StaticInitializerMember member) {
+		if (DEBUG_EMPTY && cls.empty)
+			System.out.println("Class " + cls.fullName + " not empty because of static initializer");
+		
 		cls.empty = false;
 		return null;
 	}
 		JavaSourceMethod method = null;
 		if (nativeTag != null && nativeClass != null)
 			method = nativeClass.getMethod(nativeTag.value);
-		if (method == null)
+		
+		if (member.getOverrides() != null) {
+			DefinitionMemberRef base = member.getOverrides();
+			JavaSourceMethod baseMethod = base.getTarget().getTag(JavaSourceMethod.class);
+			if (baseMethod == null)
+				throw new IllegalStateException("Base method not yet prepared!");
+			
+			method = new JavaSourceMethod(cls, baseMethod.kind, baseMethod.name, true);
+		} else if (method == null) {
 			method = new JavaSourceMethod(cls, getKind(member), name, true);
+		}
 		
-		if (method.compile)
+		if (method.compile) {
+			if (DEBUG_EMPTY && cls.empty)
+				System.out.println("Class " + cls.fullName + " not empty because of " + member.describe());
+			
 			cls.empty = false;
+		}
 		
 		member.setTag(JavaSourceMethod.class, method);
 	}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareDefinitionVisitor.java

 import org.openzen.zenscript.codemodel.expression.CastExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.formattershared.ExpressionString;
 import org.openzen.zenscript.javasource.JavaOperator;
 import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 			list.addInstanceMethod("insert", "add");
 			list.addInstanceMethod("remove", "remove");
 			list.addInstanceMethod("indexOf", "indexOf");
+			list.addInstanceMethod("lastIndexOf", "lastIndexOf");
 			list.addInstanceMethod("getAtIndex", "get");
 			list.addInstanceMethod("setAtIndex", "set");
 			list.addInstanceMethod("contains", "contains");
 			list.addMethod("toArray", new JavaSourceMethod((formatter, call) -> formatter.listToArray((CastExpression)call)));
-			list.addInstanceMethod("length", "length");
+			list.addInstanceMethod("length", "size");
 			list.addInstanceMethod("isEmpty", "isEmpty");
+			list.addInstanceMethod("iterate", "iterator");
 			nativeClasses.put("stdlib::List", list);
 		}
 		
+		{
+			JavaNativeClass iterable = new JavaNativeClass(new JavaSourceClass("java.lang", "Iterable"));
+			iterable.addInstanceMethod("iterate", "iterator");
+			nativeClasses.put("stdlib::Iterable", iterable);
+		}
+		
+		{
+			JavaNativeClass iterator = new JavaNativeClass(new JavaSourceClass("java.lang", "Iterator"));
+			iterator.addInstanceMethod("hasNext", "hasNext");
+			iterator.addInstanceMethod("next", "next");
+			nativeClasses.put("stdlib::Iterator", iterator);
+		}
+		
 		{
 			JavaNativeClass comparable = new JavaNativeClass(new JavaSourceClass("java.lang", "Comparable"));
 			comparable.addInstanceMethod("compareTo", "compareTo");
 		}
 		
 		{
-			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.io", "StringReader"));
-			cls.addInstanceMethod("constructor", "");
+			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.io", "StringReader"), true);
+			cls.addConstructor("constructor", "");
 			cls.addInstanceMethod("destructor", "close");
 			cls.addInstanceMethod("readCharacter", "read");
 			cls.addInstanceMethod("readSlice", "read");
 		this.outerClass = outerClass;
 	}
 	
+	private boolean isPrepared(HighLevelDefinition definition) {
+		return definition.hasTag(JavaSourceClass.class);
+	}
+	
+	public void prepare(ITypeID type) {
+		if (!(type instanceof DefinitionTypeID))
+			return;
+			
+		HighLevelDefinition definition = ((DefinitionTypeID)type).definition;
+		definition.accept(this);
+	}
+	
 	@Override
 	public JavaSourceClass visitClass(ClassDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaSourceClass.class);
+		
 		return visitClassCompiled(definition, true);
 	}
 
 	@Override
 	public JavaSourceClass visitInterface(InterfaceDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaSourceClass.class);
+		
+		for (ITypeID baseType : definition.baseInterfaces)
+			prepare(baseType);
+		
 		return visitClassCompiled(definition, true);
 	}
 
 	@Override
 	public JavaSourceClass visitEnum(EnumDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaSourceClass.class);
+		
 		return visitClassCompiled(definition, false);
 	}
 
 	@Override
 	public JavaSourceClass visitStruct(StructDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaSourceClass.class);
+		
 		return visitClassCompiled(definition, true);
 	}
 
 	@Override
 	public JavaSourceClass visitFunction(FunctionDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaSourceClass.class);
+		
 		JavaSourceClass cls = new JavaSourceClass(definition.pkg.fullName, filename);
 		definition.setTag(JavaSourceClass.class, cls);
 		JavaSourceMethod method = new JavaSourceMethod(cls, JavaSourceMethod.Kind.STATIC, definition.name, true);
 
 	@Override
 	public JavaSourceClass visitExpansion(ExpansionDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaSourceClass.class);
+		
 		NativeTag nativeTag = definition.getTag(NativeTag.class);
 		JavaNativeClass nativeClass = null;
 		if (nativeTag != null) {
 
 	@Override
 	public JavaSourceClass visitVariant(VariantDefinition variant) {
+		if (isPrepared(variant))
+			return variant.getTag(JavaSourceClass.class);
+		
 		JavaSourceClass cls = new JavaSourceClass(variant.pkg.fullName, variant.name);
 		variant.setTag(JavaSourceClass.class, cls);
 		
 	}
 	
 	private JavaSourceClass visitClassCompiled(HighLevelDefinition definition, boolean startsEmpty) {
+		if (definition.getSuperType() != null)
+			prepare(definition.getSuperType());
+		
 		NativeTag nativeTag = definition.getTag(NativeTag.class);
 		JavaNativeClass nativeClass = nativeTag == null ? null : nativeClasses.get(nativeTag.value);
 		if (nativeClass == null) {
 			JavaSourceClass cls = outerClass == null ? new JavaSourceClass(definition.pkg.fullName, definition.name) : new JavaSourceClass(outerClass, definition.name);
+			cls.destructible = definition.isDestructible();
 			definition.setTag(JavaSourceClass.class, cls);
 			visitClassMembers(definition, cls, null, startsEmpty);
 			return cls;
 			definition.setTag(JavaSourceClass.class, nativeClass.cls);
 			definition.setTag(JavaNativeClass.class, nativeClass);
 			visitExpansionMembers(definition, cls, nativeClass);
+			
+			if (nativeClass.nonDestructible)
+				cls.destructible = false;
+			
 			return cls;
 		}
 	}
 	
 	private void visitClassMembers(HighLevelDefinition definition, JavaSourceClass cls, JavaNativeClass nativeClass, boolean startsEmpty) {
-		JavaSourcePrepareClassMethodVisitor methodVisitor = new JavaSourcePrepareClassMethodVisitor(filename, cls, nativeClass, startsEmpty);
+		JavaSourcePrepareClassMethodVisitor methodVisitor = new JavaSourcePrepareClassMethodVisitor(this, filename, cls, nativeClass, startsEmpty);
 		for (IDefinitionMember member : definition.members) {
 			member.accept(methodVisitor);
 		}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareExpansionMethodVisitor.java

  * @author Hoofdgebruiker
  */
 public class JavaSourcePrepareExpansionMethodVisitor implements MemberVisitor<Void> {
+	private static final boolean DEBUG_EMPTY = true;
+	
 	private final JavaSourceClass cls;
 	private final JavaNativeClass nativeClass;
 	
 	@Override
 	public Void visitConst(ConstMember member) {
 		member.setTag(JavaSourceField.class, new JavaSourceField(cls, member.name));
+		
+		if (DEBUG_EMPTY && cls.empty)
+			System.out.println("Class " + cls.fullName + " not empty because of const");
+		
 		cls.empty = false;
 		return null;
 	}
 
 	@Override
 	public Void visitDestructor(DestructorMember member) {
+		if (nativeClass != null && nativeClass.nonDestructible)
+			return null;
+		
 		visitFunctional(member, "");
 		return null;
 	}
 		if (method == null)
 			method = new JavaSourceMethod(cls, getKind(member), name, true); 
 		
-		if (method.compile)
+		if (method.compile) {
+			if (DEBUG_EMPTY && cls.empty)
+				System.out.println("Class " + cls.fullName + " not empty because of " + member.describe());
+			
 			cls.empty = false;
+		}
 		
 		member.setTag(JavaSourceMethod.class, method);
 	}

Parser/src/main/java/org/openzen/zenscript/lexer/ZSTokenType.java

 	T_WHITESPACE_TAB(true, "\t", "\t"),
 	T_WHITESPACE_NEWLINE(true, "\n", "\n", true),
 	T_WHITESPACE_CARRIAGE_RETURN(true, "\r", "\r"),
-	T_IDENTIFIER("[a-zA-Z_][a-zA-Z_0-9]*"),
+	T_IDENTIFIER("@?[a-zA-Z_][a-zA-Z_0-9]*"),
+	T_LOCAL_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("\"([^\"\\\\\\n]|\\\\([\'\"\\\\/bfnrt&]|u[0-9a-fA-F]{4}))*\""),
 	K_PRIVATE(true, "private"),
 	K_PUBLIC(true, "public"),
 	K_EXPORT(true, "export"),
+	K_INTERNAL(true, "internal"),
 	K_STATIC(true, "static"),
 	K_PROTECTED(true, "protected"),
 	K_IMPLICIT(true, "implicit"),

Parser/src/main/java/org/openzen/zenscript/parser/ParsedDefinition.java

  */
 package org.openzen.zenscript.parser;
 
-import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.CompilingType;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import static org.openzen.zenscript.lexer.ZSTokenType.*;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
  *
  * @author Hoofdgebruiker
  */
-public abstract class ParsedDefinition implements CompilingType {
-	public static ParsedDefinition parse(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
+public abstract class ParsedDefinition {
+	public static ParsedDefinition parse(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
 		if (tokens.optional(K_CLASS) != null) {
 			return ParsedClass.parseClass(pkg, position, modifiers, annotations, tokens, outerDefinition);
 		} else if (tokens.optional(K_INTERFACE) != null) {
 	public final CodePosition position;
 	public final int modifiers;
 	public final ParsedAnnotation[] annotations;
+	public final CompilingPackage pkg;
 	
-	public ParsedDefinition(CodePosition position, int modifiers, ParsedAnnotation[] annotations) {
+	public ParsedDefinition(CodePosition position, int modifiers, CompilingPackage pkg, ParsedAnnotation[] annotations) {
 		this.position = position;
+		this.pkg = pkg;
 		this.modifiers = modifiers;
 		this.annotations = annotations;
 	}
 		return modifiers;
 	}
 	
+	public abstract CompilingType getCompiling(TypeResolutionContext context);
+	
 	public abstract HighLevelDefinition getCompiled();
 	
 	public abstract void linkTypes(TypeResolutionContext context);

Parser/src/main/java/org/openzen/zenscript/parser/ParsedFile.java

 import org.openzen.zencode.shared.FileSourceFile;
 import org.openzen.zencode.shared.LiteralSourceFile;
 import org.openzen.zencode.shared.SourceFile;
-import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.PackageDefinitions;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.statement.Statement;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import static org.openzen.zenscript.lexer.ZSTokenType.*;
 import org.openzen.zenscript.codemodel.scope.FileScope;
  * @author Hoofdgebruiker
  */
 public class ParsedFile {
-	public static ParsedFile parse(ZSPackage pkg, CompilingPackage compilingPackage, BracketExpressionParser bracketParser, File file) throws IOException {
-		return parse(pkg, compilingPackage, bracketParser, new FileSourceFile(file.getName(), file));
+	public static ParsedFile parse(CompilingPackage compilingPackage, BracketExpressionParser bracketParser, File file) throws IOException {
+		return parse(compilingPackage, bracketParser, new FileSourceFile(file.getName(), file));
 	}
 	
-	public static ParsedFile parse(ZSPackage pkg, CompilingPackage compilingPackage, BracketExpressionParser bracketParser, String filename, String content) {
+	public static ParsedFile parse(CompilingPackage compilingPackage, BracketExpressionParser bracketParser, String filename, String content) {
 		try {
-			return parse(pkg, compilingPackage, bracketParser, new LiteralSourceFile(filename, content));
+			return parse(compilingPackage, bracketParser, new LiteralSourceFile(filename, content));
 		} catch (IOException ex) {
 			throw new AssertionError(); // shouldn't happen
 		}
 	}
 	
-	public static ParsedFile parse(ZSPackage pkg, CompilingPackage compilingPackage, BracketExpressionParser bracketParser, SourceFile file) throws IOException {
+	public static ParsedFile parse(CompilingPackage compilingPackage, BracketExpressionParser bracketParser, SourceFile file) throws IOException {
 		ZSTokenParser tokens = ZSTokenParser.create(file, bracketParser, 4);
-		return parse(pkg, compilingPackage, tokens);
+		return parse(compilingPackage, tokens);
 	}
 	
-	public static ParsedFile parse(ZSPackage pkg, CompilingPackage compilingPackage, ZSTokenParser tokens) {
+	public static ParsedFile parse(CompilingPackage compilingPackage, ZSTokenParser tokens) {
 		ParsedFile result = new ParsedFile(tokens.getFile());
 
 		while (true) {
 			} else if ((tokens.optional(EOF)) != null) {
 				break;
 			} else {
-				ParsedDefinition definition = ParsedDefinition.parse(pkg, position, modifiers, annotations, tokens, null);
+				ParsedDefinition definition = ParsedDefinition.parse(compilingPackage, position, modifiers, annotations, tokens, null);
 				if (definition == null) {
 					result.statements.add(ParsedStatement.parse(tokens, annotations));
 				} else {
 					result.definitions.add(definition);
 					definition.getCompiled().setTag(SourceFile.class, tokens.getFile());
-					
-					if (definition.getName() != null)
-						compilingPackage.addType(definition.getName(), definition);
 				}
 			}
 		}
 		}
 	}
 	
+	public void registerTypes(
+			ModuleTypeResolutionContext moduleContext,
+			ZSPackage rootPackage,
+			CompilingPackage modulePackage) {
+		FileResolutionContext context = new FileResolutionContext(moduleContext, modulePackage);
+		loadImports(context, rootPackage, modulePackage);
+		
+		for (ParsedDefinition definition : this.definitions) {
+			if (definition.getName() != null)
+				definition.pkg.addType(definition.getName(), definition.getCompiling(context));
+		}
+	}
+	
 	public void compileTypes(
 			ModuleTypeResolutionContext moduleContext,
 			ZSPackage rootPackage,
 			CompilingPackage modulePackage) {
-		FileResolutionContext context = new FileResolutionContext(moduleContext);
+		FileResolutionContext context = new FileResolutionContext(moduleContext, modulePackage);
 		loadImports(context, rootPackage, modulePackage);
+		
+		for (ParsedDefinition definition : this.definitions) {
+			if (definition.getName() != null)
+				modulePackage.addType(definition.getName(), definition.getCompiling(context));
+		}
+		
 		for (ParsedDefinition definition : this.definitions) {
-			definition.linkTypes(context);
+			definition.getCompiling(context).load();
 		}
 	}
 	
 			CompilingPackage modulePackage,
 			List<ExpansionDefinition> expansions,
 			Map<String, ISymbol> globals) {
-		FileResolutionContext context = new FileResolutionContext(moduleContext);
+		FileResolutionContext context = new FileResolutionContext(moduleContext, modulePackage);
 		loadImports(context, rootPackage, modulePackage);
 		
 		FileScope scope = new FileScope(context, expansions, globals, precompiler);
 			List<ExpansionDefinition> expansions,
 			List<ScriptBlock> scripts,
 			Map<String, ISymbol> globals) {
-		FileResolutionContext context = new FileResolutionContext(moduleContext);
+		FileResolutionContext context = new FileResolutionContext(moduleContext, modulePackage);
 		loadImports(context, rootPackage, modulePackage);
 		
 		FileScope scope = new FileScope(context, expansions, globals, precompiler);

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

 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.CompilingType;
 import org.openzen.zenscript.codemodel.context.LocalTypeResolutionContext;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 public abstract class BaseParsedDefinition extends ParsedDefinition {
 	protected final List<ParsedDefinitionMember> members = new ArrayList<>();
 	private boolean typesCompiled = false;
-	private final Map<String, CompilingType> innerTypes = new HashMap<>();
+	private final Map<String, ParsedDefinition> innerTypes = new HashMap<>();
 	private boolean isCompiled = false;
 	
-	public BaseParsedDefinition(CodePosition position, int modifiers, ParsedAnnotation[] annotations) {
-		super(position, modifiers, annotations);
+	public BaseParsedDefinition(CodePosition position, int modifiers, CompilingPackage pkg, ParsedAnnotation[] annotations) {
+		super(position, modifiers, pkg, annotations);
 	}
 	
 	public void addMember(ParsedDefinitionMember member) {
 		typesCompiled = true;
 		
 		System.out.println("compileTypes " + getCompiled().name);
-		LocalTypeResolutionContext localContext = new LocalTypeResolutionContext(context, this, getCompiled().genericParameters);
-		linkTypesLocal(localContext);
+		linkTypesLocal(context);
 	}
 	
 	protected void linkTypesLocal(TypeResolutionContext localContext) {
 		for (ParsedDefinitionMember member : members)
 			member.compile(innerScope);
 	}
-	
+
 	@Override
-	public HighLevelDefinition load(TypeResolutionContext context) {
-		linkTypes(context);
-		return getCompiled();
+	public CompilingType getCompiling(TypeResolutionContext context) {
+		return new Compiling(context);
 	}
 	
-	@Override
-	public CompilingType getInner(String name) {
-		return innerTypes.get(name);
+	private class Compiling implements CompilingType {
+		private final TypeResolutionContext context;
+		
+		public Compiling(TypeResolutionContext context) {
+			this.context = new LocalTypeResolutionContext(context, this, getCompiled().genericParameters);
+		}
+		
+		@Override
+		public HighLevelDefinition load() {
+			linkTypes(context);
+			return getCompiled();
+		}
+
+		@Override
+		public CompilingType getInner(String name) {
+			if (!innerTypes.containsKey(name))
+				return null;
+			
+			return innerTypes.get(name).getCompiling(context);
+		}
 	}
 }

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

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.CompilingType;
 import org.openzen.zenscript.codemodel.context.LocalTypeResolutionContext;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
  * @author Hoofdgebruiker
  */
 public class ParsedAlias extends ParsedDefinition {
-	public static ParsedAlias parseAlias(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedAlias parseAlias(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		List<ParsedTypeParameter> parameters = ParsedTypeParameter.parseAll(tokens);
 		tokens.required(ZSTokenType.K_AS, "as expected");
 	private final AliasDefinition compiled;
 	private boolean typesLinked = false;
 	
-	public ParsedAlias(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> parameters, IParsedType type, HighLevelDefinition outerDefinition) {
-		super(position, modifiers, annotations);
+	public ParsedAlias(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> parameters, IParsedType type, HighLevelDefinition outerDefinition) {
+		super(position, modifiers, pkg, annotations);
 		
 		this.name = name;
 		this.parameters = parameters;
 		this.type = type;
 		
-		compiled = new AliasDefinition(position, pkg, name, modifiers, outerDefinition);
+		compiled = new AliasDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
 		
 		if (parameters != null && parameters.size() > 0) {
 			TypeParameter[] typeParameters = new TypeParameter[parameters.size()];
 			return;
 		typesLinked = true;
 		
-		LocalTypeResolutionContext localContext = new LocalTypeResolutionContext(context, this, compiled.genericParameters);
-		compiled.setType(type.compile(localContext));
+		compiled.setType(type.compile(context));
 		
 		for (int i = 0; i < compiled.genericParameters.length; i++) {
 			TypeParameter output = compiled.genericParameters[i];
 			ParsedTypeParameter input = this.parameters.get(i);
 			for (ParsedGenericBound bound : input.bounds) {
-				output.addBound(bound.compile(localContext));
+				output.addBound(bound.compile(context));
 			}
 		}
 	}
 	}
 
 	@Override
-	public CompilingType getInner(String name) {
-		// TODO: this should be possible too
-		return null;
+	public CompilingType getCompiling(TypeResolutionContext context) {
+		return new Compiling(context);
 	}
+	
+	private class Compiling implements CompilingType {
+		private final TypeResolutionContext context;
+		
+		public Compiling(TypeResolutionContext context) {
+			this.context = new LocalTypeResolutionContext(context, this, compiled.genericParameters);
+		}
+		
+		@Override
+		public CompilingType getInner(String name) {
+			// TODO: this should be possible too
+			return null;
+		}
 
-	@Override
-	public HighLevelDefinition load(TypeResolutionContext context) {
-		linkTypes(context);
-		return compiled;
+		@Override
+		public HighLevelDefinition load() {
+			linkTypes(context);
+			return compiled;
+		}
 	}
 }

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

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.parser.ParsedAnnotation;
  * @author Stan Hebben
  */
 public class ParsedClass extends BaseParsedDefinition {
-	public static ParsedClass parseClass(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedClass parseClass(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		List<ParsedTypeParameter> genericParameters = ParsedTypeParameter.parseAll(tokens);
 		
 		
 		ParsedClass result = new ParsedClass(pkg, position, modifiers, annotations, name, genericParameters, superclass, outerDefinition);
 		while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
-			result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled, null));
+			result.addMember(ParsedDefinitionMember.parse(tokens, result, null));
 		}
 		return result;
 	}
 	
-	private final List<ParsedTypeParameter> genericParameters;
+	private final List<ParsedTypeParameter> parameters;
 	private final IParsedType superclass;
 	
 	private final ClassDefinition compiled;
 	
-	public ParsedClass(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> genericParameters, IParsedType superclass, HighLevelDefinition outerDefinition) {
-		super(position, modifiers, annotations);
+	public ParsedClass(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> parameters, IParsedType superclass, HighLevelDefinition outerDefinition) {
+		super(position, modifiers, pkg, annotations);
 		
-		this.genericParameters = genericParameters;
+		this.parameters = parameters;
 		this.superclass = superclass;
 		
-		compiled = new ClassDefinition(position, pkg, name, modifiers, outerDefinition);
-		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(genericParameters));
+		compiled = new ClassDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
+		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(parameters));
 	}
 
 	@Override
 
 	@Override
 	protected void linkTypesLocal(TypeResolutionContext context) {
+		ParsedTypeParameter.compile(context, compiled.genericParameters, this.parameters);
+		
 		if (superclass != null)
 			compiled.setSuperType(superclass.compile(context));
 		

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

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.parser.ParsedAnnotation;
-import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
 
 /**
  * @author Hoofdgebruiker
  */
 public class ParsedEnum extends BaseParsedDefinition {
-	public static ParsedEnum parseEnum(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedEnum parseEnum(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		tokens.required(ZSTokenType.T_AOPEN, "{ expected");
 		
 		
 		if (tokens.optional(ZSTokenType.T_SEMICOLON) != null) {
 			while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
-				result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled, null));
+				result.addMember(ParsedDefinitionMember.parse(tokens, result, null));
 			}
 		} else {
 			tokens.required(ZSTokenType.T_ACLOSE, "} expected");
 	
 	private final EnumDefinition compiled;
 	
-	public ParsedEnum(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, HighLevelDefinition outerDefinition) {
-		super(position, modifiers, annotations);
+	public ParsedEnum(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, HighLevelDefinition outerDefinition) {
+		super(position, modifiers, pkg, annotations);
 		
-		compiled = new EnumDefinition(position, pkg, name, modifiers, outerDefinition);
+		compiled = new EnumDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
 	}
 	
 	public void addEnumValue(ParsedEnumConstant value) {

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

 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.context.LocalTypeResolutionContext;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
-import org.openzen.zenscript.codemodel.scope.BaseScope;
-import org.openzen.zenscript.codemodel.scope.GenericFunctionScope;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
 import org.openzen.zenscript.parser.type.IParsedType;
  * @author Hoofdgebruiker
  */
 public class ParsedExpansion extends BaseParsedDefinition {
-	public static ParsedExpansion parseExpansion(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedExpansion parseExpansion(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
 		List<ParsedTypeParameter> parameters = ParsedTypeParameter.parseAll(tokens);
 		IParsedType target = IParsedType.parse(tokens);
 		tokens.required(ZSTokenType.T_AOPEN, "{ expected");
 		
 		ParsedExpansion result = new ParsedExpansion(pkg, position, modifiers, annotations, parameters, target, outerDefinition);
 		while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
-			result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled, null));
+			result.addMember(ParsedDefinitionMember.parse(tokens, result, null));
 		}
 		return result;
 	}
 	private final IParsedType target;
 	private final ExpansionDefinition compiled;
 	
-	public ParsedExpansion(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, List<ParsedTypeParameter> genericParameters, IParsedType target, HighLevelDefinition outerDefinition) {
-		super(position, modifiers, annotations);
+	public ParsedExpansion(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, List<ParsedTypeParameter> genericParameters, IParsedType target, HighLevelDefinition outerDefinition) {
+		super(position, modifiers, pkg, annotations);
 		
 		this.parameters = genericParameters;
 		this.target = target;
 		
-		compiled = new ExpansionDefinition(position, pkg, modifiers, outerDefinition);
+		compiled = new ExpansionDefinition(position, pkg.getPackage(), modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(genericParameters));
 	}
 	

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

 import org.openzen.zencode.shared.CodePosition;
 import static org.openzen.zenscript.lexer.ZSTokenType.*;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.CompilingType;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.scope.FunctionScope;
  * @author Stanneke
  */
 public class ParsedFunction extends ParsedDefinition {
-	public static ParsedFunction parseFunction(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser parser, HighLevelDefinition outerDefinition) {
+	public static ParsedFunction parseFunction(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser parser, HighLevelDefinition outerDefinition) {
 		String name = parser.required(T_IDENTIFIER, "identifier expected").content;
 		ParsedFunctionHeader header = ParsedFunctionHeader.parse(parser);
 		ParsedFunctionBody body = ParsedStatement.parseFunctionBody(parser);
 
 	private final FunctionDefinition compiled;
 	
-	private ParsedFunction(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, ParsedFunctionHeader header, ParsedFunctionBody body, HighLevelDefinition outerDefinition) {
-		super(position, modifiers, annotations);
+	private ParsedFunction(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, ParsedFunctionHeader header, ParsedFunctionBody body, HighLevelDefinition outerDefinition) {
+		super(position, modifiers, pkg, annotations);
 		
 		this.header = header;
 		this.body = body;
 		
-		compiled = new FunctionDefinition(position, pkg, name, modifiers, outerDefinition);
+		compiled = new FunctionDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
 	}
 
 	@Override
 	}
 
 	@Override
-	public CompilingType getInner(String name) {
-		return null;
+	public CompilingType getCompiling(TypeResolutionContext context) {
+		return new Compiling(context);
 	}
 
-	@Override
-	public HighLevelDefinition load(TypeResolutionContext context) {
-		return compiled;
+	private class Compiling implements CompilingType {
+		private final TypeResolutionContext context;
+		
+		public Compiling(TypeResolutionContext context) {
+			this.context = context;
+		}
+		
+		@Override
+		public CompilingType getInner(String name) {
+			return null;
+		}
+
+		@Override
+		public HighLevelDefinition load() {
+			return compiled;
+		}
 	}
 }

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

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.parser.ParsedAnnotation;
  * @author Hoofdgebruiker
  */
 public class ParsedInterface extends BaseParsedDefinition {
-	public static ParsedInterface parseInterface(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedInterface parseInterface(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		List<ParsedTypeParameter> genericParameters = ParsedTypeParameter.parseAll(tokens);
 		List<IParsedType> superInterfaces = Collections.emptyList();
 		
 		ParsedInterface result = new ParsedInterface(pkg, position, modifiers, annotations, name, genericParameters, superInterfaces, outerDefinition);
 		while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
-			result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled, null));
+			result.addMember(ParsedDefinitionMember.parse(tokens, result, null));
 		}
 		return result;
 	}
 	
 	private final InterfaceDefinition compiled;
 	
-	public ParsedInterface(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> typeParameters, List<IParsedType> superInterfaces, HighLevelDefinition outerDefinition) {
-		super(position, modifiers, annotations);
+	public ParsedInterface(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> typeParameters, List<IParsedType> superInterfaces, HighLevelDefinition outerDefinition) {
+		super(position, modifiers, pkg, annotations);
 		
 		this.typeParameters = typeParameters;
 		this.superInterfaces = superInterfaces;
 		
-		compiled = new InterfaceDefinition(position, pkg, name, modifiers, outerDefinition);
+		compiled = new InterfaceDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(typeParameters));
 	}
 

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

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.StructDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
-import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
 
  * @author Hoofdgebruiker
  */
 public class ParsedStruct extends BaseParsedDefinition {
-	public static ParsedStruct parseStruct(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedStruct parseStruct(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		List<ParsedTypeParameter> parameters = ParsedTypeParameter.parseAll(tokens);
 		
 		
 		ParsedStruct result = new ParsedStruct(pkg, position, modifiers, annotations, name, parameters, outerDefinition);
 		while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
-			result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled, null));
+			result.addMember(ParsedDefinitionMember.parse(tokens, result, null));
 		}
 		return result;
 	}
 	
 	private final StructDefinition compiled;
 	
-	public ParsedStruct(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> genericParameters, HighLevelDefinition outerDefinition) {
-		super(position, modifiers, annotations);
+	public ParsedStruct(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> genericParameters, HighLevelDefinition outerDefinition) {
+		super(position, modifiers, pkg, annotations);
 		
 		this.parameters = genericParameters;
 		
-		compiled = new StructDefinition(position, pkg, name, modifiers, outerDefinition);
+		compiled = new StructDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(genericParameters));
 	}
 

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

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.parser.ParsedAnnotation;
  * @author Hoofdgebruiker
  */
 public class ParsedVariant extends BaseParsedDefinition {
-	public static ParsedVariant parseVariant(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedVariant parseVariant(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		List<ParsedTypeParameter> typeParameters = ParsedTypeParameter.parseAll(tokens);
 		tokens.required(ZSTokenType.T_AOPEN, "{ expected");
 		
 		ParsedVariant result = new ParsedVariant(pkg, position, modifiers, annotations, name, typeParameters, outerDefinition);
 		
+		int ordinal = 0;
 		while (!tokens.isNext(ZSTokenType.T_ACLOSE) && !tokens.isNext(ZSTokenType.T_SEMICOLON)) {
 			String optionName = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 			List<IParsedType> types = new ArrayList<>();
 				}
 				tokens.required(ZSTokenType.T_BRCLOSE, ") expected");
 			}
-			result.addVariant(new ParsedVariantOption(optionName, types));
+			result.addVariant(new ParsedVariantOption(optionName, ordinal++, types));
 			if (tokens.optional(ZSTokenType.T_COMMA) == null)
 				break;
 		}
 		
 		if (tokens.optional(ZSTokenType.T_SEMICOLON) != null) {
 			while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
-				result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled, null));
+				result.addMember(ParsedDefinitionMember.parse(tokens, result, null));
 			}
 		} else {
 			tokens.required(ZSTokenType.T_ACLOSE, "} expected");
 	
 	private final VariantDefinition compiled;
 	
-	public ParsedVariant(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> typeParameters, HighLevelDefinition outerDefinition) {
-		super(position, modifiers, annotations);
+	public ParsedVariant(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> typeParameters, HighLevelDefinition outerDefinition) {
+		super(position, modifiers, pkg, annotations);
 		
 		this.typeParameters = typeParameters;
-		compiled = new VariantDefinition(position, pkg, name, modifiers, outerDefinition);
+		compiled = new VariantDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(typeParameters));
 	}
 	

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

 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.parser.type.IParsedType;
 
 /**
  */
 public class ParsedVariantOption {
 	public final String name;
+	public final int ordinal;
 	public final List<IParsedType> types;
 	
-	public ParsedVariantOption(String name, List<IParsedType> types) {
+	public ParsedVariantOption(String name, int ordinal, List<IParsedType> types) {
 		this.name = name;
+		this.ordinal = ordinal;
 		this.types = types;
 	}
 	
 		for (int i = 0; i < cTypes.length; i++)
 			cTypes[i] = types.get(i).compile(context);
 		
-		return new VariantDefinition.Option(name, cTypes);
+		return new VariantDefinition.Option(name, ordinal, cTypes);
 	}
 }

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

 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
-import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
 			if (option == null)
 				throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Variant option does not exist: " + name);
 			
-			VarStatement[] values = new VarStatement[arguments.arguments.size()];
+			String[] values = new String[arguments.arguments.size()];
 			for (int i = 0; i < values.length; i++) {
 				ParsedExpression argument = arguments.arguments.get(i);
 				ParsedFunctionParameter lambdaHeader = argument.toLambdaParameter();
-				values[i] = new VarStatement(argument.position, lambdaHeader.name, option.types[i], null, true);
+				values[i] = lambdaHeader.name;
 			}
 			
 			return new VariantOptionSwitchValue(option, values);

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

 			if (option.types.length > 0)
 				throw new CompileException(position, CompileExceptionCode.MISSING_VARIANT_CASEPARAMETERS, "Variant case is missing parameters");
 			
-			return new VariantOptionSwitchValue(option, new VarStatement[0]);
+			return new VariantOptionSwitchValue(option, new String[0]);
 		} else {
 			throw new CompileException(position, CompileExceptionCode.INVALID_SWITCH_CASE, "Invalid switch case");
 		}

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

 import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
 import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
-import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
-import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 			if (switchValue instanceof VariantOptionSwitchValue) {
 				VariantOptionSwitchValue variantSwitchValue = (VariantOptionSwitchValue)switchValue;
 				
-				for (VarStatement var : variantSwitchValue.parameters)
-					innerScope.addInnerVariable(var);
+				for (int i = 0; i < variantSwitchValue.parameters.length; i++)
+					innerScope.addMatchingVariantOption(variantSwitchValue.parameters[i], i, variantSwitchValue);
 			}
 			
 			Expression value = this.value.compile(innerScope).eval();

Parser/src/main/java/org/openzen/zenscript/parser/member/ParsedDefinitionMember.java

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.OperatorType;
-import org.openzen.zenscript.codemodel.context.CompilingType;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.lexer.ZSToken;
  * @author Hoofdgebruiker
  */
 public abstract class ParsedDefinitionMember {
-	public static ParsedDefinitionMember parse(ZSTokenParser tokens, HighLevelDefinition forDefinition, ParsedImplementation forImplementation) {
+	public static ParsedDefinitionMember parse(ZSTokenParser tokens, ParsedDefinition forDefinition, ParsedImplementation forImplementation) {
 		CodePosition start = tokens.getPosition();
 		ParsedAnnotation[] annotations = ParsedAnnotation.parseAnnotations(tokens);
 		int modifiers = 0;
 					initializer = ParsedExpression.parse(tokens);
 				}
 				tokens.required(ZSTokenType.T_SEMICOLON, "; expected");
-				return new ParsedField(start, forDefinition, modifiers, annotations, name, type, initializer, t.type == ZSTokenType.K_VAL, autoGetter, autoSetter);
+				return new ParsedField(start, forDefinition.getCompiled(), modifiers, annotations, name, type, initializer, t.type == ZSTokenType.K_VAL, autoGetter, autoSetter);
 			}
 			case K_THIS: {
 				tokens.next();
 				if (body == null)
 					throw new CompileException(start, CompileExceptionCode.METHOD_BODY_REQUIRED, "Function body is required for constructors");
 				
-				return new ParsedConstructor(start, forDefinition, forImplementation, modifiers, annotations, header, body);
+				return new ParsedConstructor(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, header, body);
 			}
 			case T_IDENTIFIER: {
 				String name = tokens.next().content;
 					tokens.required(ZSTokenType.T_ASSIGN, "= expected");
 					ParsedExpression value = ParsedExpression.parse(tokens);
 					tokens.required(ZSTokenType.T_SEMICOLON, "; expected");
-					return new ParsedConst(start, forDefinition, modifiers & ~Modifiers.CONST, annotations, name, type, value);
+					return new ParsedConst(start, forDefinition.getCompiled(), modifiers & ~Modifiers.CONST, annotations, name, type, value);
 				}
 				
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedMethod(start, forDefinition, forImplementation, modifiers, annotations, name, header, body);
+				return new ParsedMethod(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, name, header, body);
 			}
 			case K_SET: {
 				tokens.next();
 					type = IParsedType.parse(tokens);
 				}
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedSetter(start, forDefinition, forImplementation, modifiers, annotations, name, type, body);
+				return new ParsedSetter(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, name, type, body);
 			}
 			case K_GET: {
 				tokens.next();
 					type = IParsedType.parse(tokens);
 				}
 				ParsedFunctionBody statements = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedGetter(start, forDefinition, forImplementation, modifiers, annotations, name, type, statements);
+				return new ParsedGetter(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, name, type, statements);
 			}
 			case K_IMPLEMENTS: {
 				tokens.next();
 				IParsedType type = IParsedType.parse(tokens);
-				ParsedImplementation implementation = new ParsedImplementation(start, forDefinition, modifiers, annotations, type);
+				ParsedImplementation implementation = new ParsedImplementation(start, forDefinition.getCompiled(), modifiers, annotations, type);
 				if (tokens.optional(ZSTokenType.T_SEMICOLON) == null) {
 					tokens.required(ZSTokenType.T_AOPEN, "{ expected");
 					while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
 			case T_BROPEN: {
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedCaller(start, forDefinition, forImplementation, modifiers, annotations, header, body);
+				return new ParsedCaller(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, header, body);
 			}
 			case T_SQOPEN: {
 				tokens.next();
 				}
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedOperator(start, forDefinition, forImplementation, modifiers, annotations, operator, header, body);
+				return new ParsedOperator(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, operator, header, body);
 			}
 			case T_CAT:
 				tokens.pushMark();
 					
 					// destructor
 					ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-					return new ParsedDestructor(start, forDefinition, forImplementation, modifiers, annotations, body);
+					return new ParsedDestructor(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, body);
 				}
 				tokens.reset();
 				// else it is a ~ operator, continue...
 				ZSToken token = tokens.next();
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedOperator(start, forDefinition, forImplementation, modifiers, annotations, getOperator(token.type), header, body);
+				return new ParsedOperator(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, getOperator(token.type), header, body);
 			}
 			case T_EQUAL2: {
 				tokens.next();
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedOperator(start, forDefinition, forImplementation, modifiers, annotations, OperatorType.EQUALS, header, body);
+				return new ParsedOperator(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, OperatorType.EQUALS, header, body);
 			}
 			case K_AS: {
 				tokens.next();
 				IParsedType type = IParsedType.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedCaster(start, forDefinition, forImplementation, modifiers, annotations, type, body);
+				return new ParsedCaster(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, type, body);
 			}
 			case K_IN: {
 				tokens.next();
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedOperator(start, forDefinition, forImplementation, modifiers, annotations, OperatorType.CONTAINS, header, body);
+				return new ParsedOperator(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, OperatorType.CONTAINS, header, body);
 			}
 			case K_CLASS:
 			case K_INTERFACE:
 			case K_ALIAS:
 			case K_STRUCT:
 			case K_ENUM:
-				return new ParsedInnerDefinition(forDefinition, ParsedDefinition.parse(forDefinition.pkg, start, modifiers, annotations, tokens, forDefinition));
+				return new ParsedInnerDefinition(forDefinition.getCompiled(), ParsedDefinition.parse(forDefinition.pkg, start, modifiers, annotations, tokens, forDefinition.getCompiled()));
 			case K_FOR: {
 				tokens.next();
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedIterator(start, forDefinition, modifiers, annotations, header, body);
+				return new ParsedIterator(start, forDefinition.getCompiled(), modifiers, annotations, header, body);
 			}
 			default:
 				if (modifiers == Modifiers.STATIC && tokens.peek().type == ZSTokenType.T_AOPEN) {
 					ParsedStatementBlock body = ParsedStatementBlock.parseBlock(tokens, annotations, true);
-					return new ParsedStaticInitializer(forDefinition, tokens.getPosition(), annotations, body);
+					return new ParsedStaticInitializer(forDefinition.getCompiled(), tokens.getPosition(), annotations, body);
 				}
 				throw new CompileException(tokens.getPosition(), CompileExceptionCode.UNEXPECTED_TOKEN, "Unexpected token: " + tokens.peek().content);
 		}
 	
 	public abstract void linkTypes(TypeResolutionContext context);
 	
-	public void registerInnerTypes(Map<String, CompilingType> innerTypes) {}
+	public void registerInnerTypes(Map<String, ParsedDefinition> innerTypes) {}
 	
 	public abstract IDefinitionMember getCompiled();
 	

Parser/src/main/java/org/openzen/zenscript/parser/member/ParsedInnerDefinition.java

 
 import java.util.Map;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.context.CompilingType;
+import org.openzen.zenscript.codemodel.context.LocalTypeResolutionContext;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.member.InnerDefinitionMember;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 	}
 	
 	@Override
-	public void registerInnerTypes(Map<String, CompilingType> inner) {
+	public void registerInnerTypes(Map<String, ParsedDefinition> inner) {
 		inner.put(innerDefinition.getCompiled().name, innerDefinition);
 	}
 	

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

 		File[] inputFiles = Optional.ofNullable(inputDirectory.listFiles((dir, name) -> name.endsWith(".zs"))).orElseGet(() -> new File[0]);
 		
 		ZSPackage pkg = new ZSPackage(null, "");
-		CompilingPackage compilingPkg = new CompilingPackage();
+		CompilingPackage compilingPkg = new CompilingPackage(pkg);
 		ParsedFile[] parsedFiles = parse(pkg, compilingPkg, inputFiles);
 		
 		ZSPackage global = new ZSPackage(null, "");
 	private static ParsedFile[] parse(ZSPackage pkg, CompilingPackage compilingPkg, File[] files) throws IOException {
 		ParsedFile[] parsedFiles = new ParsedFile[files.length];
 		for (int i = 0; i < files.length; i++) {
-			parsedFiles[i] = ParsedFile.parse(pkg, compilingPkg, new TestBracketParser(), files[i]);
+			parsedFiles[i] = ParsedFile.parse(compilingPkg, new TestBracketParser(), files[i]);
 		}
 		return parsedFiles;
 	}
 		SemanticModule result = Module.compileSyntaxToSemantic(
 				"scripts",
 				new String[0],
-				pkg,
 				compiling,
 				files,
 				space,

Shared/src/main/java/listeners/DummyListenerHandle.java

+package listeners;
+
+
+public final class DummyListenerHandle<T> implements ListenerHandle<T>, AutoCloseable {
+    public final T listener;
+    
+    public DummyListenerHandle(T listener) {
+        this.listener = listener;
+    }
+    
+    @Override
+    public void close() {
+    }
+    
+    public T getListener() {
+        return listener;
+    }
+}

Shared/src/main/java/listeners/ListenerHandle.java

+package listeners;
+
+
+public interface ListenerHandle<T> extends AutoCloseable {
+    @Override
+    public void close();
+    
+    T getListener();
+}

Shared/src/main/java/listeners/ListenerList.java

+package listeners;
+
+import listeners.ListenerList;
+import zsynthetic.FunctionTToVoid;
+
+public final class ListenerList<T> {
+    public static final int PRIORITY_HIGH = 100;
+    public static final int PRIORITY_DEFAULT = 0;
+    public static final int PRIORITY_LOW = -100;
+    private ListenerList<T>.EventListenerNode first = null;
+    private ListenerList<T>.EventListenerNode last = null;
+    
+    public ListenerHandle<T> add(T listener) {
+        return this.add(listener, ListenerList.PRIORITY_DEFAULT);
+    }
+    
+    public ListenerHandle<T> add(T listener, int priority) {
+        ListenerList<T>.EventListenerNode node = new ListenerList<T>.EventListenerNode(listener, priority);
+        if (first == null) {
+            this.first = this.last = node;
+        }
+        else {
+            ListenerList<T>.EventListenerNode previousNode = last;
+            while (previousNode != null && priority > previousNode.priority)
+                previousNode = previousNode.prev;
+            if (previousNode == null) {
+                node.next = first;
+                first.prev = previousNode;
+                this.first = node;
+            }
+            else {
+                if (previousNode.next == null)
+                    this.last = node;
+                else
+                    previousNode.next.prev = node;
+                previousNode.next = node;
+                node.prev = previousNode;
+            }
+        }
+        return node;
+    }
+    
+    public void clear() {
+        this.first = this.last = null;
+    }
+    
+    public void accept(FunctionTToVoid<T> consumer) {
+        ListenerList<T>.EventListenerNode current = first;
+        while (current != null) {
+            consumer.invoke(current.getListener());
+            current = current.next;
+        }
+    }
+    
+    public boolean getIsEmpty() {
+        return first == null;
+    }
+    private final class EventListenerNode implements ListenerHandle<T>, AutoCloseable {
+        public final T listener;
+        private final int priority;
+        private ListenerList<T>.EventListenerNode next = null;
+        private ListenerList<T>.EventListenerNode prev = null;
+        
+        public EventListenerNode(T listener, int priority) {
+            this.listener = listener;
+            this.priority = priority;
+        }
+        
+        @Override
+        public void close() {
+            if (prev == null)
+                ListenerList.this.first = next;
+            else
+                prev.next = next;
+            if (next == null)
+                ListenerList.this.last = prev;
+            else
+                next.prev = prev;
+        }
+        
+        public T getListener() {
+            return listener;
+        }
+    }
+}

Shared/src/main/java/live/ImmutableLiveBool.java

+package live;
+
+import listeners.DummyListenerHandle;
+import listeners.ListenerHandle;
+import live.ImmutableLiveBool;
+import zsynthetic.FunctionBoolBoolToVoid;
+
+public final class ImmutableLiveBool implements LiveBool {
+    public static final ImmutableLiveBool TRUE = new ImmutableLiveBool(true);
+    public static final ImmutableLiveBool FALSE = new ImmutableLiveBool(false);
+    public final boolean value;
+    
+    private ImmutableLiveBool(boolean value) {
+        this.value = value;
+    }
+    
+    @Override
+    public ListenerHandle<FunctionBoolBoolToVoid> addListener(FunctionBoolBoolToVoid listener) {
+        return new DummyListenerHandle<FunctionBoolBoolToVoid>(listener);
+    }
+    
+    public boolean getValue() {
+        return value;
+    }
+}

Shared/src/main/java/live/ImmutableLiveObject.java

+package live;
+
+import listeners.DummyListenerHandle;
+import listeners.ListenerHandle;
+import zsynthetic.FunctionTTToVoid;
+
+public final class ImmutableLiveObject<T> implements LiveObject<T> {
+    public final T value;
+    
+    public ImmutableLiveObject(T value) {
+        this.value = value;
+    }
+    
+    @Override
+    public ListenerHandle<FunctionTTToVoid<T>> addListener(FunctionTTToVoid<T> listener) {
+        return new DummyListenerHandle<FunctionTTToVoid<T>>(listener);
+    }
+    
+    public T getValue() {
+        return value;
+    }
+}

Shared/src/main/java/live/ImmutableLiveString.java

+package live;
+
+import listeners.DummyListenerHandle;
+import listeners.ListenerHandle;
+import zsynthetic.FunctionStringStringToVoid;
+
+public final class ImmutableLiveString implements LiveString {
+    public final String value;
+    
+    public ImmutableLiveString(String value) {
+        this.value = value;
+    }
+    
+    @Override
+    public ListenerHandle<FunctionStringStringToVoid> addListener(FunctionStringStringToVoid listener) {
+        return new DummyListenerHandle<FunctionStringStringToVoid>(listener);
+    }
+    
+    public String getValue() {
+        return value;
+    }
+}

Shared/src/main/java/live/InverseLiveBool.java

+package live;
+
+import listeners.ListenerHandle;
+import zsynthetic.FunctionBoolBoolToVoid;
+
+public final class InverseLiveBool implements LiveBool {
+    private final LiveBool source;
+    
+    public InverseLiveBool(LiveBool source) {
+        this.source = source;
+    }
+    
+    @Override
+    public boolean getValue() {
+        return !source.getValue();
+    }
+    
+    @Override
+    public ListenerHandle<FunctionBoolBoolToVoid> addListener(FunctionBoolBoolToVoid listener) {
+        return source.addListener((oldVal, newVal) -> 
+        listener.invoke(!oldVal, !newVal));
+    }
+}

Shared/src/main/java/live/LiveArrayList.java

+package live;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import listeners.ListenerHandle;
+import listeners.ListenerList;
+
+final class LiveArrayList<T> implements MutableLiveList<T>, AutoCloseable {
+    private final List<T> values = new ArrayList<T>();
+    private final ListenerList<LiveList.Listener<T>> listeners = new ListenerList<LiveList.Listener<T>>();
+    
+    @Override
+    public void add(T value) {
+        int index = values.size();
+        values.add(value);
+        listeners.accept(listener -> 
+        listener.onInserted(index, value));
+    }
+    
+    @Override
+    public void insert(int index, T value) {
+        values.add(index, value);
+        listeners.accept(listener -> 
+        listener.onInserted(index, value));
+    }
+    
+    @Override
+    public void setAt(int index, T value) {
+        T oldValue = values.get(index);
+        values.set(index, value);
+        listeners.accept(listener -> 
+        listener.onChanged(index, oldValue, value));
+    }
+    
+    @Override
+    public void remove(int index) {
+        T oldValue = values.remove(index);
+        listeners.accept(listener -> 
+        listener.onRemoved(index, oldValue));
+    }
+    
+    @Override
+    public void remove(T value) {
+        int index = this.indexOf(value);
+        if (index < 0)
+            return;
+        this.remove(index);
+    }
+    
+    @Override
+    public void clear() {
+        int i = this.getLength();
+        while (i > 0) {
+            i--;
+            this.remove(i);
+        }
+    }
+    
+    @Override
+    public Iterator<T> iterator() {
+        return values.iterator();
+    }
+    
+    @Override
+    public int indexOf(T value) {
+        return values.indexOf(value);
+    }
+    
+    @Override
+    public int getLength() {
+        return values.size();
+    }
+    
+    @Override
+    public T getAt(int index) {
+        return values.get(index);
+    }
+    
+    @Override
+    public ListenerHandle<LiveList.Listener<T>> addListener(LiveList.Listener<T> listener) {
+        return listeners.add(listener);
+    }
+    
+    @Override
+    public void close() {
+    }
+}

Shared/src/main/java/live/LiveBool.java

+package live;
+
+import listeners.ListenerHandle;
+import zsynthetic.FunctionBoolBoolToVoid;
+
+public interface LiveBool {
+    boolean getValue();
+    
+    ListenerHandle<FunctionBoolBoolToVoid> addListener(FunctionBoolBoolToVoid listener);
+}

Shared/src/main/java/live/LiveInt.java

+package live;
+
+import listeners.ListenerHandle;
+import zsynthetic.FunctionIntIntToVoid;
+
+public interface LiveInt {
+    int getValue();
+    
+    void setValue(int value);
+    
+    ListenerHandle<FunctionIntIntToVoid> addListener(FunctionIntIntToVoid listener);
+}

Shared/src/main/java/live/LiveList.java

+package live;
+
+import listeners.ListenerHandle;
+
+public interface LiveList<T> extends AutoCloseable, Iterable<T> {
+    @Override
+    public void close();
+    
+    int getLength();
+    
+    int indexOf(T value);
+    
+    T getAt(int index);
+    
+    ListenerHandle<LiveList.Listener<T>> addListener(LiveList.Listener<T> listener);
+    public interface Listener<T> {
+        void onInserted(int index, T value);
+        
+        void onChanged(int index, T oldValue, T newValue);
+        
+        void onRemoved(int index, T oldValue);
+    }
+}

Shared/src/main/java/live/LiveObject.java

+package live;
+
+import listeners.ListenerHandle;
+import zsynthetic.FunctionTTToVoid;
+
+public interface LiveObject<T> {
+    T getValue();
+    
+    ListenerHandle<FunctionTTToVoid<T>> addListener(FunctionTTToVoid<T> listener);
+}

Shared/src/main/java/live/LiveString.java

+package live;
+
+import listeners.ListenerHandle;
+import zsynthetic.FunctionStringStringToVoid;
+
+public interface LiveString {
+    String getValue();
+    
+    ListenerHandle<FunctionStringStringToVoid> addListener(FunctionStringStringToVoid listener);
+}

Shared/src/main/java/live/MutableLiveList.java

+package live;
+
+
+public interface MutableLiveList<T> extends AutoCloseable, LiveList<T> {
+    void add(T value);
+    
+    void insert(int index, T value);
+    
+    void setAt(int index, T value);
+    
+    void remove(int index);
+    
+    void remove(T value);
+    
+    void clear();
+    
+    @Override
+    public void close();
+}

Shared/src/main/java/org/openzen/zencode/shared/CharacterEntity.java

 package org.openzen.zencode.shared;
 
 public final class CharacterEntity {
-	public final char charValue;
-	public final String stringValue;
-	
-	public CharacterEntity(String stringValue, char charValue) {
-	    this.charValue = charValue;
-	    this.stringValue = stringValue;
-	}
-	
-	public char getCharValue() {
-	    return charValue;
-	}
-	
-	public String getStringValue() {
-	    return stringValue;
-	}
+    public final char charValue;
+    public final String stringValue;
+    
+    public CharacterEntity(String stringValue, char charValue) {
+        this.charValue = charValue;
+        this.stringValue = stringValue;
+    }
+    
+    public char getCharValue() {
+        return charValue;
+    }
+    
+    public String getStringValue() {
+        return stringValue;
+    }
 }

Shared/src/main/java/org/openzen/zencode/shared/CodePosition.java

 package org.openzen.zencode.shared;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.VirtualSourceFile;
 
 public final class CodePosition {
-	public static final CodePosition BUILTIN = new CodePosition(new VirtualSourceFile("builtin"), 0, 0, 0, 0);
-	public static final CodePosition NATIVE = new CodePosition(new VirtualSourceFile("native"), 0, 0, 0, 0);
-	public final String filename;
-	public final SourceFile file;
-	public final int fromLine;
-	public final int fromLineOffset;
-	public final int toLine;
-	public final int toLineOffset;
-	
-	public CodePosition(SourceFile file, int fromLine, int fromLineOffset, int toLine, int toLineOffset) {
-		this.file = file;
-	    this.filename = file.getFilename();
-	    this.fromLine = fromLine;
-	    this.fromLineOffset = fromLineOffset;
-	    this.toLine = toLine;
-	    this.toLineOffset = toLineOffset;
-	}
-	
-	public String toShortString() {
-	    int lastSeparator = filename.lastIndexOf('/');
-	    String shortFilename = lastSeparator >= 0 ? filename.substring(lastSeparator + 1, (filename).length()) : filename;
-	    if (fromLine == 0 && fromLineOffset == 0)
-	        return shortFilename;
-	    return shortFilename + ":" + Integer.toString(fromLine) + ":" + Integer.toString(fromLineOffset);
-	}
-	
-	public CodePosition until(CodePosition to) {
-	    if (!filename.equals(to.filename))
-	        throw new AssertionError("From and to positions must be in the same file!");
-	    return new CodePosition(file, fromLine, fromLineOffset, to.toLine, to.toLineOffset);
-	}
-	
-	public String toString() {
-	    return fromLine == 0 && fromLineOffset == 0 ? filename : filename + ":" + Integer.toString(fromLine) + ":" + Integer.toString(fromLineOffset);
-	}
-	
-	public String getFilename() {
-	    return filename;
-	}
-	
-	public int getFromLine() {
-	    return fromLine;
-	}
-	
-	public int getFromLineOffset() {
-	    return fromLineOffset;
-	}
-	
-	public int getToLine() {
-	    return toLine;
-	}
-	
-	public int getToLineOffset() {
-	    return toLineOffset;
-	}
+    public static final CodePosition BUILTIN = new CodePosition(new VirtualSourceFile("builtin"), 0, 0, 0, 0);
+    public static final CodePosition NATIVE = new CodePosition(new VirtualSourceFile("native"), 0, 0, 0, 0);
+    public final SourceFile file;
+    public final int fromLine;
+    public final int fromLineOffset;
+    public final int toLine;
+    public final int toLineOffset;
+    
+    public CodePosition(SourceFile file, int fromLine, int fromLineOffset, int toLine, int toLineOffset) {
+        this.file = file;
+        this.fromLine = fromLine;
+        this.fromLineOffset = fromLineOffset;
+        this.toLine = toLine;
+        this.toLineOffset = toLineOffset;
+    }
+    
+    public String getFilename() {
+        return file.getFilename();
+    }
+    
+    public String toShortString() {
+        int lastSeparator = file.getFilename().lastIndexOf('/');
+        String shortFilename = lastSeparator >= 0 ? file.getFilename().substring(lastSeparator + 1, (file.getFilename()).length()) : file.getFilename();
+        if (fromLine == 0 && fromLineOffset == 0)
+            return shortFilename;
+        return shortFilename + ":" + Integer.toString(fromLine) + ":" + Integer.toString(fromLineOffset);
+    }
+    
+    public CodePosition until(CodePosition to) {
+        if (!(file == to.file))
+            throw new AssertionError("From and to positions must be in the same file!");
+        return new CodePosition(file, fromLine, fromLineOffset, to.toLine, to.toLineOffset);
+    }
+    
+    public String toString() {
+        return fromLine == 0 && fromLineOffset == 0 ? file.getFilename() : file.getFilename() + ":" + Integer.toString(fromLine) + ":" + Integer.toString(fromLineOffset);
+    }
+    
+    public SourceFile getFile() {
+        return file;
+    }
+    
+    public int getFromLine() {
+        return fromLine;
+    }
+    
+    public int getFromLineOffset() {
+        return fromLineOffset;
+    }
+    
+    public int getToLine() {
+        return toLine;
+    }
+    
+    public int getToLineOffset() {
+        return toLineOffset;
+    }
 }

Shared/src/main/java/org/openzen/zencode/shared/CompileException.java

 package org.openzen.zencode.shared;
 
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 
 public final class CompileException extends RuntimeException {
-	public static CompileException internalError(String message) {
-	    return new CompileException(CodePosition.BUILTIN, CompileExceptionCode.INTERNAL_ERROR, message);
-	}
-	
-	public final CodePosition position;
-	public final CompileExceptionCode code;
-	
-	public CompileException(CodePosition position, CompileExceptionCode code, String message) {
-	    super(position.toString() + ": [" + code.toString() + "] " + message);
-	    
-	    this.position = position;
-	    this.code = code;
-	}
-	
-	public CodePosition getPosition() {
-	    return position;
-	}
-	
-	public CompileExceptionCode getCode() {
-	    return code;
-	}
+    public static CompileException internalError(String message) {
+        return new CompileException(CodePosition.BUILTIN, CompileExceptionCode.INTERNAL_ERROR, message);
+    }
+    
+    public final CodePosition position;
+    public final CompileExceptionCode code;
+    
+    public CompileException(CodePosition position, CompileExceptionCode code, String message) {
+        super(position.toString() + ": [" + code.toString() + "] " + message);
+        this.position = position;
+        this.code = code;
+    }
+    
+    public CodePosition getPosition() {
+        return position;
+    }
+    
+    public CompileExceptionCode getCode() {
+        return code;
+    }
 }

Shared/src/main/java/org/openzen/zencode/shared/CompileExceptionCode.java

 package org.openzen.zencode.shared;
 
 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,
-	STATEMENT_OUTSIDE_SWITCH_CASE,
-	MISSING_VARIANT_CASEPARAMETERS,
-	INVALID_SWITCH_CASE,
-	TRY_CONVERT_OUTSIDE_FUNCTION,
-	TRY_CONVERT_ILLEGAL_TARGET,
-	TRY_RETHROW_NOT_A_RESULT,
-	DIFFERENT_EXCEPTIONS,
-	UNKNOWN_ANNOTATION,
-	OVERRIDE_WITHOUT_BASE,
-	OVERRIDE_AMBIGUOUS,
-	OVERRIDE_CONSTRUCTOR,
-	PRECOMPILE_FAILED,
-	UNTYPED_EMPTY_ARRAY,
-	UNTYPED_EMPTY_MAP,
-	VAR_WITHOUT_TYPE_OR_INITIALIZER,
-	NO_BRACKET_PARSER,
-	INVALID_BRACKET_EXPRESSION
+	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(),
+	STATEMENT_OUTSIDE_SWITCH_CASE(),
+	MISSING_VARIANT_CASEPARAMETERS(),
+	INVALID_SWITCH_CASE(),
+	TRY_CONVERT_OUTSIDE_FUNCTION(),
+	TRY_CONVERT_ILLEGAL_TARGET(),
+	TRY_RETHROW_NOT_A_RESULT(),
+	DIFFERENT_EXCEPTIONS(),
+	UNKNOWN_ANNOTATION(),
+	OVERRIDE_WITHOUT_BASE(),
+	OVERRIDE_AMBIGUOUS(),
+	OVERRIDE_CONSTRUCTOR(),
+	PRECOMPILE_FAILED(),
+	UNTYPED_EMPTY_ARRAY(),
+	UNTYPED_EMPTY_MAP(),
+	VAR_WITHOUT_TYPE_OR_INITIALIZER(),
+	NO_BRACKET_PARSER(),
+	INVALID_BRACKET_EXPRESSION()
 }

Shared/src/main/java/org/openzen/zencode/shared/ConcatMap.java

 package org.openzen.zencode.shared;
 
+import org.openzen.zencode.shared.ConcatMap;
 import stdlib.EqualsComparable;
 
-public final class ConcatMap<K extends EqualsComparable<K>, V>  {
-	public static final <K extends EqualsComparable<K>, V> ConcatMap<K, V> empty(Class<K> typeOfK, Class<V> typeOfV) {
-	    return new ConcatMap<K, V>(null, null, null);
-	}
-	
-	private final K key;
-	private final V value;
-	private final ConcatMap<K, V> remaining;
-	
-	private ConcatMap(K key, V value, ConcatMap<K, V> remaining) {
-	    this.key = key;
-	    this.value = value;
-	    this.remaining = remaining;
-	}
-	
-	public boolean getIsEmpty() {
-	    return key == null;
-	}
-	
-	public ConcatMap<K, V> concat(K key, V value) {
-	    return new ConcatMap<K, V>(key, value, this);
-	}
-	
-	public boolean contains(K key) {
-	    if (this.key == null)
-	        return false;
-	    if (key.equals_(this.key))
-	        return true;
-	    if (remaining == null)
-	        return false;
-	    return remaining.contains(key);
-	}
-	
-	public V getAt(K key) {
-	    if (this.key == null)
-	        return null;
-	    if (key.equals_(this.key))
-	        return value;
-	    return remaining.getAt(key);
-	}
-	
-	public V getOrDefault(K key, V defaultValue) {
-	    if (this.key == null)
-	        return defaultValue;
-	    if (key.equals_(this.key))
-	        return value;
-	    return remaining.getOrDefault(key, defaultValue);
-	}
+public final class ConcatMap<K extends EqualsComparable<K>, V> {
+    public static final <K extends EqualsComparable<K>, V> ConcatMap<K, V> empty(Class<K> typeOfK, Class<V> typeOfV) {
+        return new ConcatMap<K, V>(null, null, null);
+    }
+    
+    private final K key;
+    private final V value;
+    private final ConcatMap<K, V> remaining;
+    
+    private ConcatMap(K key, V value, ConcatMap<K, V> remaining) {
+        this.key = key;
+        this.value = value;
+        this.remaining = remaining;
+    }
+    
+    public boolean getIsEmpty() {
+        return key == null;
+    }
+    
+    public ConcatMap<K, V> concat(K key, V value) {
+        return new ConcatMap<K, V>(key, value, this);
+    }
+    
+    public boolean contains(K key) {
+        if (this.key == null)
+            return false;
+        if (key.equals_(this.key))
+            return true;
+        if (remaining == null)
+            return false;
+        return remaining.contains(key);
+    }
+    
+    public V getAt(K key) {
+        if (this.key == null)
+            return null;
+        if (key.equals_(this.key))
+            return value;
+        return remaining.getAt(key);
+    }
+    
+    public V getOrDefault(K key, V defaultValue) {
+        if (this.key == null)
+            return defaultValue;
+        if (key.equals_(this.key))
+            return value;
+        return remaining.getOrDefault(key, defaultValue);
+    }
 }

Shared/src/main/java/org/openzen/zencode/shared/LiteralSourceFile.java

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
 package org.openzen.zencode.shared;
 
 import java.io.IOException;
 import java.io.Reader;
 import java.io.StringReader;
 
-/**
- *
- * @author Hoofdgebruiker
- */
-public class LiteralSourceFile implements SourceFile {
-	private final String filename;
-	private final String contents;
-	
-	public LiteralSourceFile(String filename, String contents) {
-		this.filename = filename;
-		this.contents = contents;
-	}
-
-	@Override
-	public String getFilename() {
-		return filename;
-	}
-
-	@Override
-	public Reader open() throws IOException {
-		return new StringReader(contents);
-	}
-
-	@Override
-	public void update(String content) throws IOException {
-		throw new UnsupportedOperationException("Cannot update literal source files");
-	}
+public final class LiteralSourceFile implements SourceFile {
+    public final String filename;
+    private final String contents;
+    
+    public LiteralSourceFile(String filename, String contents) {
+        this.filename = filename;
+        this.contents = contents;
+    }
+    
+    @Override
+    public Reader open() throws IOException {
+        return new StringReader(contents);
+    }
+    
+    @Override
+    public void update(String contents) throws IOException {
+        throw new AssertionError("Cannot update literal source files");
+    }
+    
+    public String getFilename() {
+        return filename;
+    }
 }

Shared/src/main/java/org/openzen/zencode/shared/SourceFile.java

 import java.io.Reader;
 
 public interface SourceFile {
-	String getFilename();
-	
-	Reader open() throws IOException;
-	
-	void update(String content) throws IOException;
+    String getFilename();
+    
+    Reader open() throws IOException;
+    
+    void update(String content) throws IOException;
 }

Shared/src/main/java/org/openzen/zencode/shared/StringExpansion.java

 	
 	static  {
 	    CharacterEntity[] entities = StringExpansion.getCharacterEntities();
-	    // TODO: getCharacterEntities().index(e => e.stringValue);
-	    
 	    NAMED_CHARACTER_ENTITIES = new HashMap<>();
 	    for (CharacterEntity entity : entities)
-	        
 	        StringExpansion.NAMED_CHARACTER_ENTITIES.put(entity.stringValue, entity);
 	}
 	
 	                return new Error("Unfinished escape sequence");
 	            switch (quoted.charAt(i + 1)) {
 	                case '\\':
-	                    
 	                    i++;
 	                    result.append('\\');
 	                    break;
 	                case '&':
-	                    
 	                    Result<CharacterEntity, String> temp1 = StringExpansion.readCharacterEntity(quoted, i + 1);
 	                    if (temp1 instanceof Result.Error)
 	                        return new Result.Error<>(((Result.Error<CharacterEntity, String>)temp1).value);
 	                    result.append('\'');
 	                    break;
 	                case 'u':
-	                    
 	                    if (i >= quoted.length() - 5)
 	                        return new Error("Unfinished escape sequence");
 	                    Result<Integer, String> temp2 = StringExpansion.readHexCharacter(quoted.charAt(i + 2));
 	                    result.append((char)hex0 << 12 | hex1 << 8 | hex2 << 4 | hex3);
 	                    break;
 	                default:
-	                    
 	                    return new Error("Illegal escape sequence");
 	            }
 	        }
 	    for (char c : self.toCharArray()) {
 	        switch (c) {
 	            case '\\':
-	                
 	                output.append("\\\\");
 	                break;
 	            case '"':
-	                
 	                if (quote == '"')
 	                    output.append("\\\"");
 	                else
 	                    output.append('"');
 	                break;
 	            case '\'':
-	                
 	                if (quote == '\'')
 	                    output.append("\\'");
 	                else
 	                output.append("\\t");
 	                break;
 	            default:
-	                
 	                if (escapeUnicode && c > '') {
 	                    output.append("\\u").append(Strings.lpad(Integer.toHexString((int)c), 4, '0'));
 	                }
 	    if (entity.charAt(0) == '#') {
 	        if (entity.length() < 2)
 	            return new Error("Character entity number too short");
-	        if (str.charAt(1) == 'x') {// hex character entity
-	            
+	        if (str.charAt(1) == 'x') {
 	            if (entity.length() != 7)
 	                return new Error("Hexadecimal character entity must have 4 hex digits");
 	            int ivalue = Integer.parseInt(entity.substring(2, entity.length()), 16);
 	            return new Ok(new CharacterEntity(entity, (char)ivalue));
 	        }
-	        else {// decimal character entity
-	            
+	        else {
 	            int ivalue = Integer.parseInt(entity.substring(1, entity.length()));
 	            return new Ok(new CharacterEntity(entity, (char)ivalue));
 	        }

Shared/src/main/java/org/openzen/zencode/shared/Taggable.java

 import java.util.Map;
 
 public class Taggable {
-	private final Map<Class<?>, Object> tags = new HashMap<Class<?>, Object>();
-	
-	public <T> void setTag(Class<T> typeOfT, T tag) {
-	    tags.put(typeOfT, tag);
-	}
-	
-	public <T> T getTag(Class<T> typeOfT) {
-	    return (T)(tags.get(typeOfT));
-	}
-	
-	public <T> boolean hasTag(Class<T> typeOfT) {
-	    return tags.containsKey(typeOfT);
-	}
-	
-	public void addAllTagsFrom(Taggable other) {
-	    tags.putAll(other.tags);
-	}
+    private final Map<Class<?>, Object> tags = new HashMap<Class<?>, Object>();
+    
+    public <T> void setTag(Class<T> typeOfT, T tag) {
+        tags.put(typeOfT, tag);
+    }
+    
+    public <T> T getTag(Class<T> typeOfT) {
+        return (T)(tags.get(typeOfT));
+    }
+    
+    public <T> boolean hasTag(Class<T> typeOfT) {
+        return tags.containsKey(typeOfT);
+    }
+    
+    public void addAllTagsFrom(Taggable other) {
+        tags.putAll(other.tags);
+    }
 }

Shared/src/main/java/org/openzen/zencode/shared/VirtualSourceFile.java

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
 package org.openzen.zencode.shared;
 
 import java.io.IOException;
 import java.io.Reader;
 
-/**
- *
- * @author Hoofdgebruiker
- */
-public class VirtualSourceFile implements SourceFile {
-	private final String filename;
-	
-	public VirtualSourceFile(String filename) {
-		this.filename = filename;
-	}
-
-	@Override
-	public String getFilename() {
-		return filename;
-	}
-
-	@Override
-	public Reader open() throws IOException {
-		throw new UnsupportedOperationException("Cannot open virtual source files");
-	}
-
-	@Override
-	public void update(String content) throws IOException {
-		throw new UnsupportedOperationException("Cannot write to virtual source files");
-	}
+public final class VirtualSourceFile implements SourceFile {
+    public final String filename;
+    
+    public VirtualSourceFile(String filename) {
+        this.filename = filename;
+    }
+    
+    @Override
+    public Reader open() throws IOException {
+        throw new AssertionError("Cannot open virtual source files");
+    }
+    
+    @Override
+    public void update(String content) throws IOException {
+        throw new AssertionError("Cannot write to virtual source files");
+    }
+    
+    public String getFilename() {
+        return filename;
+    }
 }