- Improve work on the serializer and fixed some code issues that came up with them.

- Start work on the deserializer

CodeFormatterShared/src/main/java/org/openzen/zenscript/formattershared/StatementFormattingSubBlock.java

 public class StatementFormattingSubBlock {
 	public final String header;
 	public final List<String> literalStatements;
-	public final List<Statement> statements;
+	public final Statement[] statements;
 	
-	public StatementFormattingSubBlock(String header, List<String> literalStatements, List<Statement> statements) {
+	public StatementFormattingSubBlock(String header, List<String> literalStatements, Statement[] statements) {
 		this.header = header;
 		this.literalStatements = literalStatements;
 		this.statements = statements;

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

 		return true;
 	}
 	
+	public FunctionHeader instanceForCall(GlobalTypeRegistry registry, CallArguments arguments) {
+		if (arguments.getNumberOfTypeArguments() > 0) {
+			Map<TypeParameter, ITypeID> typeParameters = new HashMap<>();
+			for (int i = 0; i < this.typeParameters.length; i++) {
+				typeParameters.put(this.typeParameters[i], arguments.typeArguments[i]);
+			}
+			return withGenericArguments(
+					registry,
+					new GenericMapper(registry, typeParameters));
+		} else {
+			return this;
+		}
+	}
+	
 	public FunctionHeader withGenericArguments(GlobalTypeRegistry registry, GenericMapper mapper) {
 		if (typeParameters.length > 0) {
 			Map<TypeParameter, ITypeID> innerMap = new HashMap<>();

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

 package org.openzen.zenscript.codemodel.annotations;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.expression.Expression;
 		statements.add(new IfStatement(position, inverseCondition, throwStatement, null));
 		
 		if (body instanceof BlockStatement) {
-			statements.addAll(((BlockStatement)body).statements);
+			statements.addAll(Arrays.asList(((BlockStatement)body).statements));
 		} else {
 			statements.add(body);
 		}
-		return new BlockStatement(position, statements);
+		return new BlockStatement(position, statements.toArray(new Statement[statements.size()]));
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/ModuleContext.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.context;
+
+import java.util.List;
+import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ModuleContext {
+	public final GlobalTypeRegistry registry;
+	public final Module module;
+	public final List<ExpansionDefinition> expansions;
+	public final ZSPackage root;
+	
+	public ModuleContext(
+			GlobalTypeRegistry registry,
+			Module module,
+			List<ExpansionDefinition> expansions,
+			ZSPackage root)
+	{
+		this.registry = registry;
+		this.module = module;
+		this.expansions = expansions;
+		this.root = root;
+	}
+}

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

 import java.util.List;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.expression.LambdaClosure;
+import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
  *
 	private final List<VarStatement> variables = new ArrayList<>();
 	private final LoopStatement[] loops;
 	private final FunctionHeader header;
+	private final LambdaClosure closure;
+	private final StatementContext lambdaOuter;
 	
-	public StatementContext() {
-		super(TypeParameter.NONE);
+	public VariantOptionSwitchValue variantOptionSwitchValue;
+	
+	public StatementContext(ModuleContext module, ITypeID thisType) {
+		super(module, TypeParameter.NONE, thisType);
+		
 		loops = LoopStatement.NONE;
 		header = null;
+		closure = null;
+		lambdaOuter = null;
 	}
 	
-	public StatementContext(FunctionHeader header) {
-		super(header.typeParameters);
+	public StatementContext(ModuleContext module, ITypeID thisType, FunctionHeader header) {
+		super(module, header.typeParameters, thisType);
+		
 		loops = LoopStatement.NONE;
 		this.header = header;
+		this.closure = null;
+		lambdaOuter = null;
 	}
 	
 	public StatementContext(TypeContext outer) {
-		super(outer.parameters);
+		super(outer.moduleContext, outer.typeParameters, outer.thisType);
 		loops = LoopStatement.NONE;
 		header = null;
+		closure = null;
+		lambdaOuter = null;
 	}
 	
 	public StatementContext(TypeContext outer, FunctionHeader header) {
-		super(outer, header.typeParameters);
+		super(outer, outer.thisType, header == null ? TypeParameter.NONE : header.typeParameters);
 		loops = LoopStatement.NONE;
 		this.header = header;
+		closure = null;
+		lambdaOuter = null;
 	}
 	
 	public StatementContext(StatementContext outer) {
-		super(outer.parameters);
+		super(outer.moduleContext, outer.typeParameters, outer.thisType);
 		
 		variables.addAll(outer.variables);
 		loops = outer.loops;
 		header = outer.header;
+		closure = outer.closure;
+		lambdaOuter = outer.lambdaOuter;
 	}
 	
 	public StatementContext(StatementContext outer, LoopStatement loop) {
-		super(outer.parameters);
+		super(outer.moduleContext, outer.typeParameters, outer.thisType);
 		
 		variables.addAll(outer.variables);
 		loops = Arrays.copyOf(outer.loops, outer.loops.length + 1);
 		loops[loops.length - 1] = loop;
 		header = outer.header;
+		closure = outer.closure;
+		lambdaOuter = outer.lambdaOuter;
+	}
+	
+	public StatementContext(StatementContext outer, FunctionHeader lambdaHeader, LambdaClosure lambdaClosure) {
+		super(outer, outer.thisType, lambdaHeader.typeParameters);
+		
+		loops = LoopStatement.NONE;
+		header = lambdaHeader;
+		this.closure = lambdaClosure;
+		lambdaOuter = outer;
 	}
 	
 	public void add(VarStatement variable) {
 	}
 	
 	public int getVariableId(VarStatement variable) {
-		return variables.indexOf(variable);
+		int id = variables.indexOf(variable);
+		if (id < 0)
+			throw new IllegalArgumentException("Variable not in scope: " + variable.name);
+		return id;
 	}
 	
 	public int getLoopId(LoopStatement loop) {
 			if (loops[i] == loop)
 				return i;
 		
-		return -1;
+		throw new IllegalArgumentException("Loop@" + loop.position + " not in scope");
 	}
 	
 	public int getParameterIndex(FunctionParameter parameter) {
 		if (header == null)
-			return -1;
+			throw new IllegalStateException("No parameters available");
 		
 		for (int i = 0; i < header.parameters.length; i++)
 			if (header.parameters[i] == parameter)
 				return i;
 		
-		return -1;
+		throw new IllegalArgumentException("Parameter" + parameter.name + " not in scope");
+	}
+	
+	public VarStatement getVariable(int id) {
+		return variables.get(id);
+	}
+
+	public LoopStatement getLoop(int id) {
+		return loops[id];
+	}
+	
+	public FunctionParameter getParameter(int id) {
+		return header.parameters[id];
+	}
+	
+	public LambdaClosure getLambdaClosure() {
+		return closure;
+	}
+	
+	public StatementContext getLambdaOuter() {
+		return lambdaOuter;
 	}
 }

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

 package org.openzen.zenscript.codemodel.context;
 
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class TypeContext {
-	protected final TypeParameter[] parameters;
+	protected final TypeParameter[] typeParameters;
+	public final ITypeID thisType;
+	private final LocalMemberCache memberCache;
+	public final ModuleContext moduleContext;
 	
-	public TypeContext(TypeParameter[] parameters) {
-		this.parameters = parameters;
+	public TypeContext(ModuleContext context, TypeParameter[] parameters, ITypeID thisType) {
+		this.typeParameters = parameters;
+		this.thisType = thisType;
+		memberCache = new LocalMemberCache(context.registry, context.expansions);
+		moduleContext = context;
 	}
 	
-	public TypeContext(TypeContext outer, TypeParameter[] inner) {
-		parameters = concat(outer.parameters, inner);
+	public TypeContext(TypeContext outer, ITypeID thisType, TypeParameter... inner) {
+		typeParameters = concat(outer.typeParameters, inner);
+		this.thisType = thisType;
+		moduleContext = outer.moduleContext;
+		memberCache = new LocalMemberCache(moduleContext.registry, moduleContext.expansions);
 	}
 	
-	public TypeContext(TypeContext outer, List<TypeParameter> inner) {
-		this(outer, inner.toArray(new TypeParameter[inner.size()]));
+	public TypeContext(TypeContext outer, ITypeID thisType, List<TypeParameter> inner) {
+		this(outer, thisType, inner.toArray(new TypeParameter[inner.size()]));
 	}
 	
 	public int getId(TypeParameter parameter) {
-		for (int i = 0; i < parameters.length; i++)
-			if (parameters[i] == parameter)
+		for (int i = 0; i < typeParameters.length; i++)
+			if (typeParameters[i] == parameter)
 				return i;
 		
 		return -1;
 	}
 	
+	public TypeParameter getTypeParameter(int index) {
+		return typeParameters[index];
+	}
+	
+	public TypeMembers getTypeMembers(ITypeID type) {
+		return memberCache.get(type);
+	}
+	
+	public GenericMapper getMapper() {
+		Map<TypeParameter, ITypeID> mapper = new HashMap<>();
+		for (TypeParameter parameter : typeParameters)
+			mapper.put(parameter, moduleContext.registry.getGeneric(parameter));
+		return new GenericMapper(moduleContext.registry, mapper);
+	}
+	
 	public static <T> T[] concat(T[] first, T[] second) {
 		T[] result = Arrays.copyOf(first, first.length + second.length);
 		System.arraycopy(second, 0, result, first.length, second.length);

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

  * @author Hoofdgebruiker
  */
 public class ZSPackage {
+	public static ZSPackage createRoot() {
+		return new ZSPackage(null, "");
+	}
+	
 	public final String name;
 	public final String fullName;
 	public final ZSPackage parent;
 		return null;
 	}
 	
+	public ZSPackage getRecursive(String name) {
+		int dot = name.indexOf('.');
+		if (dot < 0)
+			return getOrCreatePackage(name);
+		else
+			return getOrCreatePackage(name.substring(0, dot)).getRecursive(name.substring(dot + 1));
+	}
+	
 	public ZSPackage getOrCreatePackage(String name) {
 		if (subPackages.containsKey(name))
 			return subPackages.get(name);

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

 	public final FunctionalMemberRef operator;
 	public final CompareType comparison;
 	
-	public CompareExpression(CodePosition position, Expression left, Expression right, FunctionalMemberRef operator, CompareType comparison, TypeScope scope) {
+	public CompareExpression(CodePosition position, Expression left, Expression right, FunctionalMemberRef operator, CompareType comparison) {
 		super(position, BasicTypeID.BOOL, binaryThrow(position, left.thrownType, right.thrownType));
 		
 		this.left = left;
-		this.right = scope == null ? right : right.castImplicit(position, scope, operator.getHeader().parameters[0].type);
+		this.right = right;
 		this.operator = operator;
 		this.comparison = comparison;
 	}
 	public Expression transform(ExpressionTransformer transformer) {
 		Expression tLeft = left.transform(transformer);
 		Expression tRight = right.transform(transformer);
-		return left == tLeft && right == tRight ? this : new CompareExpression(position, tLeft, tRight, operator, comparison, null);
+		return left == tLeft && right == tRight ? this : new CompareExpression(position, tLeft, tRight, operator, comparison);
 	}
 
 	@Override
 	public Expression normalize(TypeScope scope) {
-		return new CompareExpression(position, left.normalize(scope), right.normalize(scope), operator, comparison, scope);
+		return new CompareExpression(
+				position,
+				left.normalize(scope),
+				right.normalize(scope).castImplicit(position, scope, operator.getHeader().parameters[0].type),
+				operator,
+				comparison);
 	}
 }

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

 /**
  *
  * @author Hoofdgebruiker
+ * 
  */
 public class ConstantLongExpression extends Expression {
 	public final long value;

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

 package org.openzen.zenscript.codemodel.expression;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
 			statements.add(new ExpressionStatement(matchCase.value.position, caseExpression));
 			if (reachable)
 				statements.add(new BreakStatement(matchCase.value.position, switchStatement));
-			SwitchCase switchCase = new SwitchCase(matchCase.key, statements);
+			SwitchCase switchCase = new SwitchCase(matchCase.key, statements.toArray(new Statement[statements.size()]));
 			switchStatement.cases.add(switchCase);
 			
 			if (matchCase.key == null)
 				hasDefault = true;
 		}
 		if (!hasDefault) {
-			switchStatement.cases.add(new SwitchCase(null, Collections.singletonList(new ExpressionStatement(position, new PanicExpression(position, BasicTypeID.VOID, new ConstantStringExpression(position, "Missing case"))))));
+			Statement defaultCase = new ExpressionStatement(position, new PanicExpression(position, BasicTypeID.VOID, new ConstantStringExpression(position, "Missing case")));
+			switchStatement.cases.add(new SwitchCase(null, new Statement[] { defaultCase }));
 		}
 		return new SwitchedMatch(result, switchStatement);
 	}

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

 public class ConstMember extends PropertyMember {
 	public final String name;
 	public Expression value;
-	public final BuiltinID builtin;
 	
 	public ConstMember(CodePosition position, HighLevelDefinition definition, int modifiers, String name, ITypeID type, BuiltinID builtin) {
-		super(position, definition, modifiers, type, null);
+		super(position, definition, modifiers, type, builtin);
 		
 		this.name = name;
-		this.builtin = builtin;
 	}
 
 	@Override
 		return "const " + name;
 	}
 
-	@Override
-	public BuiltinID getBuiltin() {
-		return builtin;
-	}
-
 	@Override
 	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
-		members.addConst(new ConstMemberRef(this, mapper));
+		members.addConst(new ConstMemberRef(members.type, this, mapper));
 	}
 
 	@Override
 	public boolean isAbstract() {
 		return false;
 	}
+
+	@Override
+	public DefinitionMemberRef ref(ITypeID type, GenericMapper mapper) {
+		return new ConstMemberRef(type, this, mapper);
+	}
 }

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

 			firstExpression = (ExpressionStatement) body;
 		} else if (body instanceof BlockStatement) {
 			BlockStatement blockBody = (BlockStatement) body;
-			if (blockBody.statements.size() > 0 && blockBody.statements.get(0) instanceof ExpressionStatement)
-				firstExpression = (ExpressionStatement) blockBody.statements.get(0);
+			if (blockBody.statements.length > 0 && blockBody.statements[0] instanceof ExpressionStatement)
+				firstExpression = (ExpressionStatement) blockBody.statements[0];
 		}
 		
 		return firstExpression != null && (

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

 			this.autoGetter.setBody(new ReturnStatement(position, new GetFieldExpression(
 					position,
 					new ThisExpression(position, thisType),
-					new FieldMemberRef(this, null))));
+					new FieldMemberRef(thisType, this, null))));
 		} else {
 			this.autoGetter = null;
 		}
 			this.autoSetter.setBody(new ExpressionStatement(position, new SetFieldExpression(
 					position,
 					new ThisExpression(position, thisType),
-					new FieldMemberRef(this, null),
+					new FieldMemberRef(thisType, this, null),
 					new GetFunctionParameterExpression(position, this.autoSetter.parameter))));
 		} else {
 			this.autoSetter = null;
 
 	@Override
 	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
-		members.addField(new FieldMemberRef(this, mapper), priority);
+		members.addField(new FieldMemberRef(members.type, this, mapper), priority);
 	}
 	
 	@Override
 	public boolean isAbstract() {
 		return false;
 	}
+
+	@Override
+	public DefinitionMemberRef ref(ITypeID type, GenericMapper mapper) {
+		return new FieldMemberRef(type, this, mapper);
+	}
 }

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

 import org.openzen.zencode.shared.ConcatMap;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 	
 	@Override
 	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
-		members.addGetter(new GetterMemberRef(this, mapper), priority);
+		members.addGetter(new GetterMemberRef(members.type, this, mapper), priority);
 	}
 
 	@Override
 		if (type == BasicTypeID.UNDETERMINED)
 			type = override.getType();
 	}
+
+	@Override
+	public DefinitionMemberRef ref(ITypeID type, GenericMapper mapper) {
+		return new GetterMemberRef(type, this, mapper);
+	}
 }

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 	public void normalize(TypeScope scope);
 	
 	boolean isAbstract();
+	
+	DefinitionMemberRef ref(ITypeID type, GenericMapper mapper);
 }

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

 	public boolean isAbstract() {
 		return false;
 	}
+
+	@Override
+	public DefinitionMemberRef ref(ITypeID type, GenericMapper mapper) {
+		throw new UnsupportedOperationException("Cannot create an implementation reference");
+	}
 }

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

 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 	public boolean isAbstract() {
 		return false;
 	}
+
+	@Override
+	public DefinitionMemberRef ref(ITypeID type, GenericMapper mapper) {
+		throw new UnsupportedOperationException("Cannot create an inner definition reference");
+	}
 }

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

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 
 	@Override
 	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
-		members.addSetter(new SetterMemberRef(this, mapper), priority);
+		members.addSetter(new SetterMemberRef(members.type, this, mapper), priority);
 	}
 
 	@Override
 		if (type == BasicTypeID.UNDETERMINED)
 			type = overrides.getType();
 	}
+
+	@Override
+	public DefinitionMemberRef ref(ITypeID type, GenericMapper mapper) {
+		return new SetterMemberRef(type, this, mapper);
+	}
 }

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

 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 	public boolean isAbstract() {
 		return false;
 	}
+
+	@Override
+	public DefinitionMemberRef ref(ITypeID type, GenericMapper mapper) {
+		throw new UnsupportedOperationException("Cannot reference a static initializer");
+	}
 }

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

 	}
 	
 	@Override
-	public ITypeID getType() {
+	public ITypeID getOwnerType() {
 		return type;
 	}
 

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

 
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.member.ConstMember;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
  *
 public class ConstMemberRef extends PropertyRef {
 	public final ConstMember member;
 	
-	public ConstMemberRef(ConstMember member, GenericMapper mapper) {
-		super(member, mapper);
+	public ConstMemberRef(ITypeID owner, ConstMember member, GenericMapper mapper) {
+		super(owner, member, mapper);
 		this.member = member;
 	}
 

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

 	
 	<T> T getTag(Class<T> type);
 	
-	ITypeID getType();
+	ITypeID getOwnerType();
 	
 	DefinitionMemberRef getOverrides();
 	

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

 
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
  *
 public class FieldMemberRef extends PropertyRef {
 	public final FieldMember member;
 	
-	public FieldMemberRef(FieldMember member, GenericMapper mapper) {
-		super(member, mapper);
+	public FieldMemberRef(ITypeID owner, FieldMember member, GenericMapper mapper) {
+		super(owner, member, mapper);
 		this.member = member;
 	}
 

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

 	}
 	
 	@Override
-	public ITypeID getType() {
+	public ITypeID getOwnerType() {
 		return type;
 	}
 	
 	}
 	
 	public Expression callWithComparator(CodePosition position, CompareType comparison, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
-		return new CompareExpression(position, target, arguments.arguments[0], this, comparison, scope);
+		return new CompareExpression(position, target, arguments.arguments[0], this, comparison);
 	}
 	
 	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {

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

 import org.openzen.zenscript.codemodel.expression.GetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
 import org.openzen.zenscript.codemodel.member.GetterMember;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
  *
 public class GetterMemberRef extends PropertyRef {
 	public final GetterMember member;
 	
-	public GetterMemberRef(GetterMember member, GenericMapper mapper) {
-		super(member, mapper);
+	public GetterMemberRef(ITypeID owner, GetterMember member, GenericMapper mapper) {
+		super(owner, member, mapper);
 		
 		this.member = member;
 	}

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

 	private final ITypeID type;
 	public final ITypeID implementsType;
 	
-	public ImplementationMemberRef(ImplementationMember member, ITypeID type, ITypeID implementsType) {
+	public ImplementationMemberRef(ImplementationMember member, ITypeID owner, ITypeID implementsType) {
 		this.member = member;
-		this.type = type;
+		this.type = owner;
 		this.implementsType = implementsType;
 	}
 
 	}
 	
 	@Override
-	public ITypeID getType() {
+	public ITypeID getOwnerType() {
 		return type;
 	}
 

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

 	}
 	
 	@Override
-	public ITypeID getType() {
+	public ITypeID getOwnerType() {
 		return type;
 	}
 

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

 public abstract class PropertyRef implements DefinitionMemberRef {
 	private final PropertyMember member;
 	
+	private final ITypeID owner;
 	private ITypeID type;
 	private GenericMapper mapper;
 	
-	public PropertyRef(PropertyMember member, GenericMapper mapper) {
+	public PropertyRef(ITypeID owner, PropertyMember member, GenericMapper mapper) {
+		this.owner = owner;
 		this.member = member;
 		
 		if (member.getType() == BasicTypeID.UNDETERMINED) {
 		}
 	}
 	
+	@Override
+	public final ITypeID getOwnerType() {
+		return owner;
+	}
+	
 	public final ITypeID getType() {
 		if (type == null) {
 			if (member.getType() == BasicTypeID.UNDETERMINED)

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

 
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.member.SetterMember;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
  *
 public class SetterMemberRef extends PropertyRef {
 	public final SetterMember member;
 	
-	public SetterMemberRef(SetterMember member, GenericMapper mapper) {
-		super(member, mapper);
+	public SetterMemberRef(ITypeID owner, SetterMember member, GenericMapper mapper) {
+		super(owner, member, mapper);
 		
 		this.member = member;
 	}

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

  */
 package org.openzen.zenscript.codemodel.scope;
 
-import java.util.List;
 import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**

CodeModel/src/main/java/org/openzen/zenscript/codemodel/serialization/CodeSerializationInput.java

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.ModuleContext;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.context.StatementContext;
 import org.openzen.zenscript.codemodel.context.TypeContext;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
 
 /**
  *
 	
 	long readULong();
 	
+	float readFloat();
+	
+	double readDouble();
+	
 	char readChar();
 	
 	String readString();
 	
 	DefinitionMemberRef readMember(TypeContext context, ITypeID type);
 	
+	EnumConstantMember readEnumConstant(TypeContext context);
+	
+	VariantOptionRef readVariantOption(TypeContext context, ITypeID type);
+	
 	ITypeID deserializeType(TypeContext context);
 	
 	CodePosition deserializePosition();
 	Statement deserializeStatement(StatementContext context);
 	
 	Expression deserializeExpression(StatementContext context);
+	
+	TypeParameter deserializeTypeParameter(TypeContext context);
+	
+	TypeParameter[] deserializeTypeParameters(TypeContext context);
+	
+	void enqueueMembers(DecodingOperation operation);
+	
+	public void enqueueCode(DecodingOperation operation);
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/serialization/CodeSerializationOutput.java

 	
 	void serialize(TypeContext context, TypeParameter parameter);
 	
+	void serialize(TypeContext context, TypeParameter[] parameters);
+	
 	void serialize(CodePosition position);
 	
 	void serialize(TypeContext context, FunctionHeader header);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/serialization/DecodingOperation.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.serialization;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DecodingOperation {
+	void decode(CodeSerializationInput input);
+}

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

  */
 package org.openzen.zenscript.codemodel.statement;
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.function.Consumer;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.ConcatMap;
  * @author Hoofdgebruiker
  */
 public class BlockStatement extends Statement {
-	public final List<Statement> statements;
+	public final Statement[] statements;
 	
-	public BlockStatement(CodePosition position, List<Statement> statements) {
+	public BlockStatement(CodePosition position, Statement[] statements) {
 		super(position, getThrownType(statements));
 		
 		this.statements = statements;
 	
 	@Override
 	public Statement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
-		List<Statement> tStatements = new ArrayList<>();
+		Statement[] tStatements = new Statement[statements.length];
 		boolean unchanged = true;
-		for (Statement statement : statements) {
+		for (int i = 0; i < statements.length; i++) {
+			Statement statement = statements[i];
 			Statement tStatement = statement.transform(transformer, modified);
 			unchanged &= statement == tStatement;
-			tStatements.add(statement);
+			tStatements[i] = statement;
 		}
 		return unchanged ? this : new BlockStatement(position, tStatements);
 	}
 
 	@Override
 	public Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
-		List<Statement> tStatements = new ArrayList<>();
+		Statement[] tStatements = new Statement[statements.length];
 		boolean unchanged = true;
-		for (Statement statement : statements) {
-			Statement tStatement = statement.transform(transformer, modified);
-			unchanged &= statement == tStatement;
-			tStatements.add(statement);
+		for (int i = 0; i < tStatements.length; i++) {
+			Statement tStatement = statements[i].transform(transformer, modified);
+			unchanged &= statements[i] == tStatement;
+			tStatements[i] = tStatement;
 		}
 		return unchanged ? this : new BlockStatement(position, tStatements);
 	}
 	
-	private static ITypeID getThrownType(List<Statement> statements) {
+	private static ITypeID getThrownType(Statement[] statements) {
 		ITypeID result = null;
 		for (Statement statement : statements)
 			result = Expression.binaryThrow(statement.position, result, statement.thrownType);
 
 	@Override
 	public Statement normalize(TypeScope scope, ConcatMap<LoopStatement, LoopStatement> modified) {
-		List<Statement> normalized = new ArrayList<>();
+		Statement[] normalized = new Statement[statements.length];
+		int i = 0;
 		for (Statement statement : statements)
-			normalized.add(statement.normalize(scope, modified));
+			normalized[i++] = statement.normalize(scope, modified);
 		return new BlockStatement(position, normalized);
 	}
 }

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

  */
 package org.openzen.zenscript.codemodel.statement;
 
-import java.util.ArrayList;
-import java.util.List;
 import org.openzen.zencode.shared.ConcatMap;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
  */
 public class SwitchCase {
 	public final SwitchValue value;
-	public final List<Statement> statements;
+	public final Statement[] statements;
 	
-	public SwitchCase(SwitchValue value, List<Statement> statements) {
+	public SwitchCase(SwitchValue value, Statement[] statements) {
 		this.value = value;
 		this.statements = statements;
 	}
 	
 	public SwitchCase transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
-		List<Statement> tStatements = new ArrayList<>();
+		Statement[] tStatements = new Statement[statements.length];
+		int i = 0;
 		for (Statement statement : statements) {
-			tStatements.add(statement.transform(transformer, modified));
+			tStatements[i++] = statement.transform(transformer, modified);
 		}
 		return new SwitchCase(value, tStatements);
 	}
 	
 	public SwitchCase transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
-		List<Statement> tStatements = new ArrayList<>();
+		Statement[] tStatements = new Statement[statements.length];
+		int i = 0;
 		for (Statement statement : statements) {
-			tStatements.add(statement.transform(transformer, modified));
+			tStatements[i++] = statement.transform(transformer, modified);
 		}
 		return new SwitchCase(value, tStatements);
 	}
 	
 	public SwitchCase normalize(TypeScope scope, ConcatMap<LoopStatement, LoopStatement> modified) {
-		List<Statement> tStatements = new ArrayList<>();
+		Statement[] tStatements = new Statement[statements.length];
+		int i = 0;
 		for (Statement statement : statements)
-			tStatements.add(statement.normalize(scope, modified));
+			tStatements[i++] = statement.normalize(scope, modified);
 		return new SwitchCase(value, tStatements);
 	}
 }

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

 	ITERATOR_ARRAY_KEY_VALUES,
 	ITERATOR_ASSOC_KEYS,
 	ITERATOR_ASSOC_KEY_VALUES,
-	ITERATOR_STRING_CHARS
+	ITERATOR_STRING_CHARS;
+	
+	private static final BuiltinID[] VALUES = values();
+	public static BuiltinID get(int ordinal) {
+		return VALUES[ordinal];
+	}
 }

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

 		return this.methods;
 	}
 	
+	public ConstMemberRef getConstant() {
+		return constant.member;
+	}
+	
 	public void setConst(ConstMemberRef constant, TypeMemberPriority priority) {
 		if (this.constant != null) {
 			this.constant = this.constant.resolve(new TypeMember<>(priority, constant));

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

 import org.openzen.zenscript.codemodel.member.InnerDefinition;
 import org.openzen.zenscript.codemodel.member.ref.CasterMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
 			other.getOrCreateGroup(entry.getKey()).merge(position, entry.getValue(), priority);
 	}
 	
+	public DefinitionMemberRef getBuiltin(BuiltinID builtin) {
+		for (DefinitionMemberGroup group : members.values()) {
+			if (group.getConstant() != null && group.getConstant().member.builtin == builtin)
+				return group.getConstant();
+			if (group.getField() != null && group.getField().member.builtin == builtin)
+				return group.getField();
+			
+			for (TypeMember<FunctionalMemberRef> member : group.getMethodMembers()) {
+				if (member.member.getBuiltin() == builtin)
+					return member.member;
+			}
+		}
+		
+		for (DefinitionMemberGroup group : operators.values()) {
+			if (group.getConstant() != null && group.getConstant().member.builtin == builtin)
+				return group.getConstant();
+			if (group.getField() != null && group.getField().member.builtin == builtin)
+				return group.getField();
+			
+			for (TypeMember<FunctionalMemberRef> member : group.getMethodMembers()) {
+				if (member.member.getBuiltin() == builtin)
+					return member.member;
+			}
+		}
+		
+		return null;
+	}
+	
 	public ITypeID union(ITypeID other) {
 		other = other.getNormalized();
 		if (type == other)

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

 import org.openzen.zenscript.codemodel.PackageDefinitions;
 import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.annotations.AnnotationProcessor;
+import org.openzen.zenscript.codemodel.context.ModuleContext;
 import org.openzen.zenscript.codemodel.context.ModuleTypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 		}
 	}
 	
+	public ModuleContext getContext() {
+		return new ModuleContext(compilationUnit.globalTypeRegistry, module, expansions, rootPackage);
+	}
+	
 	public enum State {
 		INVALID,
 		ASSEMBLED,

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

 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.function.Consumer;
 import org.json.JSONArray;
 import org.json.JSONObject;
-import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.constructor.module.DirectoryModuleReference;
 import org.openzen.zenscript.constructor.module.ModuleReference;
 import org.openzen.zenscript.compiler.Target;
 		if (!directory.isDirectory())
 			throw new ConstructorException("Project directory isn't a directory");
 		
-		File projectFile = new File(directory, "project.json");
+		File projectFile = new File(directory, "project.zcp");
 		if (!projectFile.exists())
-			throw new ConstructorException("Missing project.json file in project directory");
+			throw new ConstructorException("Missing project.zcp file in project directory");
 		
 		JSONObject json = JSONUtils.load(projectFile);
 		

IDE/build.gradle

 	compile project(':DrawableGui')
 	compile project(':Constructor')
 }
+
+task fatJar(type: Jar) {
+	manifest {
+        attributes 'Implementation-Title': 'ZenCode IDE',
+			'Class-Path': '.',
+        	'Main-Class': 'org.openzen.zenscript.ide.Main'
+    }
+    baseName = project.name + '-all'
+    from {
+		configurations.compile.collect {
+			it.isDirectory() ? it : zipTree(it)
+		}
+	} {
+		exclude "META-INF/INDEX.LIST"
+		exclude "META-INF/*.SF"
+        exclude "META-INF/*.DSA"
+        exclude "META-INF/*.RSA"
+	}
+    with jar
+}

IDE/src/main/java/org/openzen/zenscript/ide/Arguments.java

 			positional++;
 		}
 		
+		if (projectDir.isFile()) // means we're opening a project file instead of a directory
+			projectDir = projectDir.getParentFile();
+		
 		this.projectDirectory = projectDir;
 	}
 }

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

  */
 package org.openzen.zenscript.javasource;
 
-import java.util.Collections;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 			output.append(";\n");
 		} else {
 			if (!(body instanceof BlockStatement))
-				body = new BlockStatement(body.position, Collections.singletonList(body));
+				body = new BlockStatement(body.position, new Statement[] { body });
 			
 			JavaSourceStatementScope scope = new JavaSourceStatementScope(this.scope, settings, header, indent + settings.indent, null, null, expansionTarget != null);
 			body.accept(new JavaSourceStatementCompiler(scope, output, true, false));

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

 package org.openzen.zenscript.javasource;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.statement.BlockStatement;
+import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 			
 			if (definition.isDestructible() && !memberCompiler.hasDestructor) {
 				DestructorMember emptyDestructor = new DestructorMember(CodePosition.BUILTIN, definition, 0);
-				emptyDestructor.body = new BlockStatement(CodePosition.BUILTIN, Collections.emptyList());
+				emptyDestructor.body = new BlockStatement(CodePosition.BUILTIN, new Statement[0]);
 				memberCompiler.visitDestructor(emptyDestructor);
 			}
 			

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

 		
 		Statement body = member.body;
 		if ((body == null || body instanceof EmptyStatement) && !(definition instanceof InterfaceDefinition))
-			body = new BlockStatement(member.position, Collections.emptyList());
+			body = new BlockStatement(member.position, new Statement[0]);
 		
 		compileBody(body, member.header);
 		return null;

ModuleDeserializer/build.gradle

+// Note: "common.gradle" in the root project contains additional initialization
+//   for this project. This initialization is applied in the "build.gradle"
+//   of the root project.
+
+// NetBeans will automatically add "run" and "debug" tasks relying on the
+// "mainClass" property. You may however define the property prior executing
+// tasks by passing a "-PmainClass=<QUALIFIED_CLASS_NAME>" argument.
+//
+// Note however, that you may define your own "run" and "debug" task if you
+// prefer. In this case NetBeans will not add these tasks but you may rely on
+// your own implementation.
+if (!hasProperty('mainClass')) {
+    ext.mainClass = ''
+}
+
+dependencies {
+    compile project(':CompilerShared')
+	compile project(':Constructor')
+	compile project(':ModuleSerializationShared')
+}

ModuleDeserializer/src/main/java/org/openzen/zenscript/moduledeserializer/CodeReader.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.moduledeserializer;
+
+import org.openzen.zenscript.codemodel.serialization.DecodingOperation;
+import compactio.CompactDataInput;
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zenscript.codemodel.CompareType;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.StatementContext;
+import org.openzen.zenscript.codemodel.context.TypeContext;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+import org.openzen.zenscript.codemodel.expression.*;
+import org.openzen.zenscript.codemodel.expression.switchvalue.CharSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.EnumConstantSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.IntSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.StringSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
+import org.openzen.zenscript.codemodel.generic.ParameterSuperBound;
+import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
+import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.ref.CasterMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
+import org.openzen.zenscript.codemodel.serialization.CodeSerializationInput;
+import org.openzen.zenscript.codemodel.statement.BlockStatement;
+import org.openzen.zenscript.codemodel.statement.BreakStatement;
+import org.openzen.zenscript.codemodel.statement.ContinueStatement;
+import org.openzen.zenscript.codemodel.statement.DoWhileStatement;
+import org.openzen.zenscript.codemodel.statement.EmptyStatement;
+import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
+import org.openzen.zenscript.codemodel.statement.ForeachStatement;
+import org.openzen.zenscript.codemodel.statement.IfStatement;
+import org.openzen.zenscript.codemodel.statement.LockStatement;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
+import org.openzen.zenscript.codemodel.statement.ReturnStatement;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.SwitchCase;
+import org.openzen.zenscript.codemodel.statement.SwitchStatement;
+import org.openzen.zenscript.codemodel.statement.ThrowStatement;
+import org.openzen.zenscript.codemodel.statement.VarStatement;
+import org.openzen.zenscript.codemodel.statement.WhileStatement;
+import org.openzen.zenscript.codemodel.type.ArrayTypeID;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
+import org.openzen.zenscript.codemodel.type.member.BuiltinID;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+import org.openzen.zenscript.moduleserialization.CodePositionEncoding;
+import org.openzen.zenscript.moduleserialization.ExpressionEncoding;
+import org.openzen.zenscript.moduleserialization.FunctionHeaderEncoding;
+import org.openzen.zenscript.moduleserialization.StatementEncoding;
+import org.openzen.zenscript.moduleserialization.SwitchValueEncoding;
+import org.openzen.zenscript.moduleserialization.TypeEncoding;
+import org.openzen.zenscript.moduleserialization.TypeParameterEncoding;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class CodeReader implements CodeSerializationInput {
+	private final CompactDataInput input;
+	
+	public final DecodingStage classes = new DecodingStage();
+	public final DecodingStage members = new DecodingStage();
+	public final DecodingStage code = new DecodingStage();
+	
+	private DecodingStage currentStage = null;
+	private CodePosition lastPosition = CodePosition.UNKNOWN;
+	
+	private final String[] strings;
+	private final SourceFile[] sourceFiles;
+	private final List<HighLevelDefinition> definitions = new ArrayList<>();
+	private final List<IDefinitionMember> memberList = new ArrayList<>();
+	private final List<EnumConstantMember> enumConstantMembers = new ArrayList<>();
+	private final List<VariantDefinition.Option> variantOptions = new ArrayList<>();
+	
+	private final GlobalTypeRegistry registry;
+	
+	public CodeReader(
+			CompactDataInput input,
+			String[] strings,
+			SourceFile[] sourceFiles,
+			GlobalTypeRegistry registry)
+	{
+		this.input = input;
+		
+		this.strings = strings;
+		this.sourceFiles = sourceFiles;
+		this.registry = registry;
+	}
+	
+	public void add(HighLevelDefinition definition) {
+		definitions.add(definition);
+	}
+	
+	public void add(IDefinitionMember member) {
+		memberList.add(member);
+	}
+	
+	public void startClasses() {
+		currentStage = classes;
+	}
+	
+	public void startMembers() {
+		currentStage = members;
+	}
+	
+	public void startCode() {
+		currentStage = code;
+	}
+
+	@Override
+	public boolean readBool() {
+		return input.readBool();
+	}
+
+	@Override
+	public int readByte() {
+		return input.readByte();
+	}
+
+	@Override
+	public byte readSByte() {
+		return input.readSByte();
+	}
+
+	@Override
+	public short readShort() {
+		return input.readShort();
+	}
+
+	@Override
+	public int readUShort() {
+		return input.readUShort();
+	}
+
+	@Override
+	public int readInt() {
+		return input.readInt();
+	}
+
+	@Override
+	public int readUInt() {
+		return input.readUInt();
+	}
+
+	@Override
+	public long readLong() {
+		return input.readLong();
+	}
+
+	@Override
+	public long readULong() {
+		return input.readULong();
+	}
+	
+	@Override
+	public float readFloat() {
+		return input.readFloat();
+	}
+	
+	@Override
+	public double readDouble() {
+		return input.readDouble();
+	}
+
+	@Override
+	public char readChar() {
+		return input.readChar();
+	}
+
+	@Override
+	public String readString() {
+		return strings[input.readUInt()];
+	}
+
+	@Override
+	public HighLevelDefinition readDefinition() {
+		return definitions.get(input.readUInt());
+	}
+
+	@Override
+	public DefinitionMemberRef readMember(TypeContext context, ITypeID type) {
+		int memberId = input.readVarUInt();
+		if (memberId == 0) {
+			return null;
+		} else if (memberId == 1) {
+			BuiltinID builtin = BuiltinID.get(input.readVarUInt());
+			TypeMembers members = context.getTypeMembers(type);
+			DefinitionMemberRef result = members.getBuiltin(builtin);
+			if (result == null)
+				throw new IllegalArgumentException("Could not find builtin member for " + builtin);
+			
+			return result;
+		} else {
+			return memberList.get(memberId - 2).ref(type, context.getMapper());
+		}
+	}
+	
+	@Override
+	public EnumConstantMember readEnumConstant(TypeContext context) {
+		return enumConstantMembers.get(readUInt());
+	}
+	
+	@Override
+	public VariantOptionRef readVariantOption(TypeContext context, ITypeID type) {
+		return variantOptions.get(readUInt()).instance(type, context.getMapper());
+	}
+
+	@Override
+	public ITypeID deserializeType(TypeContext context) {
+		int type = input.readVarUInt();
+		switch (type) {
+			case TypeEncoding.TYPE_NONE:
+				return null;
+			case TypeEncoding.TYPE_VOID:
+				return BasicTypeID.VOID;
+			case TypeEncoding.TYPE_BOOL:
+				return BasicTypeID.BOOL;
+			case TypeEncoding.TYPE_BYTE:
+				return BasicTypeID.BYTE;
+			case TypeEncoding.TYPE_SBYTE:
+				return BasicTypeID.SBYTE;
+			case TypeEncoding.TYPE_SHORT:
+				return BasicTypeID.SHORT;
+			case TypeEncoding.TYPE_USHORT:
+				return BasicTypeID.USHORT;
+			case TypeEncoding.TYPE_INT:
+				return BasicTypeID.INT;
+			case TypeEncoding.TYPE_UINT:
+				return BasicTypeID.UINT;
+			case TypeEncoding.TYPE_LONG:
+				return BasicTypeID.LONG;
+			case TypeEncoding.TYPE_ULONG:
+				return BasicTypeID.ULONG;
+			case TypeEncoding.TYPE_USIZE:
+				return BasicTypeID.USIZE;
+			case TypeEncoding.TYPE_FLOAT:
+				return BasicTypeID.FLOAT;
+			case TypeEncoding.TYPE_DOUBLE:
+				return BasicTypeID.DOUBLE;
+			case TypeEncoding.TYPE_CHAR:
+				return BasicTypeID.CHAR;
+			case TypeEncoding.TYPE_STRING:
+				return BasicTypeID.STRING;
+			case TypeEncoding.TYPE_UNDETERMINED:
+				return BasicTypeID.UNDETERMINED;
+			case TypeEncoding.TYPE_DEFINITION: {
+				HighLevelDefinition definition = readDefinition();
+				ITypeID[] arguments = new ITypeID[definition.typeParameters.length];
+				for (int i = 0; i < arguments.length; i++)
+					arguments[i] = deserializeType(context);
+				return registry.getForDefinition(definition, arguments);
+			}
+			case TypeEncoding.TYPE_DEFINITION_INNER: {
+				DefinitionTypeID outer = (DefinitionTypeID)deserializeType(context);
+				HighLevelDefinition definition = readDefinition();
+				ITypeID[] arguments = new ITypeID[definition.typeParameters.length];
+				for (int i = 0; i < arguments.length; i++)
+					arguments[i] = deserializeType(context);
+				return registry.getForDefinition(definition, arguments, outer);
+			}
+			case TypeEncoding.TYPE_GENERIC:
+				return registry.getGeneric(context.getTypeParameter(input.readVarUInt()));
+			case TypeEncoding.TYPE_FUNCTION:
+				return registry.getFunction(deserializeHeader(context));
+			case TypeEncoding.TYPE_ARRAY:
+				return registry.getArray(deserializeType(context), 1);
+			case TypeEncoding.TYPE_ARRAY_MULTIDIMENSIONAL: {
+				ITypeID baseType = deserializeType(context);
+				int dimension = input.readVarUInt();
+				return registry.getArray(baseType, dimension);
+			}
+			case TypeEncoding.TYPE_ASSOC: {
+				ITypeID key = deserializeType(context);
+				ITypeID value = deserializeType(context);
+				return registry.getAssociative(key, value);
+			}
+			case TypeEncoding.TYPE_GENERIC_MAP: {
+				TypeParameter parameter = deserializeTypeParameter(context);
+				TypeContext inner = new TypeContext(context, context.thisType, parameter);
+				ITypeID value = deserializeType(inner);
+				return registry.getGenericMap(value, parameter);
+			}
+			case TypeEncoding.TYPE_RANGE:
+				return registry.getRange(deserializeType(context));
+			case TypeEncoding.TYPE_ITERATOR: {
+				ITypeID[] values = new ITypeID[input.readVarUInt()];
+				for (int i = 0; i < values.length; i++)
+					values[i] = deserializeType(context);
+				return registry.getIterator(values);
+			}
+			case TypeEncoding.TYPE_OPTIONAL:
+				return registry.getOptional(deserializeType(context));
+			case TypeEncoding.TYPE_CONST:
+				return registry.getModified(ModifiedTypeID.MODIFIER_CONST, deserializeType(context));
+			case TypeEncoding.TYPE_IMMUTABLE:
+				return registry.getModified(ModifiedTypeID.MODIFIER_IMMUTABLE, deserializeType(context));
+			default:
+				throw new IllegalArgumentException("Unknown type: " + type);
+		}
+	}
+
+	@Override
+	public CodePosition deserializePosition() {
+		int flags = input.readVarUInt();
+		SourceFile file = lastPosition.file;
+		int fromLine = lastPosition.fromLine;
+		int fromLineOffset = lastPosition.fromLineOffset;
+		if ((flags & CodePositionEncoding.FLAG_FILE) > 0)
+			file = sourceFiles[input.readVarUInt()];
+		if ((flags & CodePositionEncoding.FLAG_FROM_LINE) > 0)
+			fromLine = input.readVarUInt();
+		if ((flags & CodePositionEncoding.FLAG_FROM_OFFSET) > 0)
+			fromLineOffset = input.readVarUInt();
+		int toLine = (flags & CodePositionEncoding.FLAG_TO_LINE) == 0 ? lastPosition.toLine : fromLine + input.readVarUInt();
+		int toLineOffset = (flags & CodePositionEncoding.FLAG_TO_OFFSET) == 0 ? lastPosition.toLineOffset : input.readVarUInt();
+		return lastPosition = new CodePosition(file, fromLine, fromLineOffset, toLine, toLineOffset);
+	}
+
+	@Override
+	public FunctionHeader deserializeHeader(TypeContext context) {
+		TypeParameter[] typeParameters = TypeParameter.NONE;
+		
+		int flags = input.readVarUInt();
+		TypeContext inner;
+		if ((flags & FunctionHeaderEncoding.FLAG_TYPE_PARAMETERS) > 0) {
+			typeParameters = deserializeTypeParameters(context);
+			inner = new TypeContext(context, context.thisType, typeParameters);
+		} else {
+			inner = context;
+		}
+		
+		ITypeID returnType = BasicTypeID.VOID;
+		if ((flags & FunctionHeaderEncoding.FLAG_RETURN_TYPE) > 0)
+			returnType = deserializeType(inner);
+		
+		ITypeID thrownType = null;
+		if ((flags & FunctionHeaderEncoding.FLAG_THROWS) > 0)
+			thrownType = deserializeType(inner);
+		
+		FunctionParameter[] parameters = FunctionParameter.NONE;
+		if ((flags & FunctionHeaderEncoding.FLAG_PARAMETERS) > 0) {
+			parameters = new FunctionParameter[readUInt()];
+			StatementContext statementContext = new StatementContext(context);
+			for (int i = 0; i < parameters.length; i++) {
+				ITypeID type = deserializeType(inner);
+				String name = readString();
+				FunctionParameter parameter = new FunctionParameter(type, name, null, (i == parameters.length - 1) && ((flags & FunctionHeaderEncoding.FLAG_VARIADIC) > 0));
+				parameters[i] = parameter;
+				
+				if ((flags & FunctionHeaderEncoding.FLAG_DEFAULT_VALUES) > 0) {
+					if (currentStage == code) {
+						parameters[i].defaultValue = deserializeExpression(statementContext);
+					} else {
+						enqueueCode(decoder -> parameter.defaultValue = deserializeExpression(statementContext));
+					}
+				}
+			}
+		}
+		return new FunctionHeader(typeParameters, returnType, thrownType, parameters);
+	}
+	
+	@Override
+	public TypeParameter deserializeTypeParameter(TypeContext context) {
+		int flags = readUInt();
+		CodePosition position = CodePosition.UNKNOWN;
+		String name = null;
+		if ((flags & TypeParameterEncoding.FLAG_POSITION) > 0)
+			position = deserializePosition();
+		if ((flags & TypeParameterEncoding.FLAG_NAME) > 0)
+			name = readString();
+		
+		TypeParameter result = new TypeParameter(position, name);
+		TypeContext inner = new TypeContext(context, context.thisType, result);
+		if ((flags & TypeParameterEncoding.FLAG_BOUNDS) > 0) {
+			int bounds = readUInt();
+			for (int i = 0; i < bounds; i++)
+				result.bounds.add(deserializeTypeParameterBound(inner));
+		}
+		
+		return result;
+	}
+	
+	@Override
+	public TypeParameter[] deserializeTypeParameters(TypeContext context) {
+		TypeParameter[] result = new TypeParameter[readUInt()];
+		int[] allflags = new int[result.length];
+		for (int i = 0; i < result.length; i++) {
+			int flags = readUInt();
+			allflags[i] = flags;
+			
+			CodePosition position = CodePosition.UNKNOWN;
+			String name = null;
+			if ((flags & TypeParameterEncoding.FLAG_POSITION) > 0)
+				position = deserializePosition();
+			if ((flags & TypeParameterEncoding.FLAG_NAME) > 0)
+				name = readString();
+
+			result[i] = new TypeParameter(position, name);
+		}
+		
+		TypeContext inner = new TypeContext(context, context.thisType, result);
+		for (int i = 0; i < result.length; i++) {
+			int flags = allflags[i];
+			if ((flags & TypeParameterEncoding.FLAG_BOUNDS) > 0) {
+				int bounds = readUInt();
+				for (int j = 0; j < bounds; j++)
+					result[i].bounds.add(deserializeTypeParameterBound(inner));
+			}
+		}
+		
+		return result;
+	}
+
+	@Override
+	public CallArguments deserializeArguments(StatementContext context) {
+		ITypeID[] typeArguments = new ITypeID[readUInt()];
+		for (int i = 0; i < typeArguments.length; i++)
+			typeArguments[i] = deserializeType(context);
+		
+		Expression[] arguments = new Expression[readUInt()];
+		for (int i = 0; i < arguments.length; i++)
+			arguments[i] = deserializeExpression(context);
+		
+		return new CallArguments(typeArguments, arguments);
+	}
+
+	@Override
+	public Statement deserializeStatement(StatementContext context) {
+		int type = readUInt();
+		int flags = type == StatementEncoding.TYPE_NULL ? 0 :  readUInt();
+		CodePosition position = (flags & StatementEncoding.FLAG_POSITION) > 0 ? deserializePosition() : CodePosition.UNKNOWN;
+		switch (type) {
+			case StatementEncoding.TYPE_NULL:
+				return null;
+			case StatementEncoding.TYPE_BLOCK: {
+				Statement[] statements = new Statement[readUInt()];
+				StatementContext inner = new StatementContext(context);
+				for (int i = 0; i < statements.length; i++)
+					statements[i] = deserializeStatement(inner);
+				return new BlockStatement(position, statements);
+			}
+			case StatementEncoding.TYPE_BREAK: {
+				LoopStatement loop = context.getLoop(readUInt());
+				return new BreakStatement(position, loop);
+			}
+			case StatementEncoding.TYPE_CONTINUE: {
+				LoopStatement loop = context.getLoop(readUInt());
+				return new ContinueStatement(position, loop);
+			}
+			case StatementEncoding.TYPE_DO_WHILE: {
+				Expression condition = deserializeExpression(context);
+				String label = null;
+				if ((flags & StatementEncoding.FLAG_LABEL) > 0)
+					label = readString();
+				DoWhileStatement loop = new DoWhileStatement(position, label, condition);
+				StatementContext inner = new StatementContext(context, loop);
+				loop.content = deserializeStatement(inner);
+				return loop;
+			}
+			case StatementEncoding.TYPE_EMPTY:
+				return new EmptyStatement(position);
+			case StatementEncoding.TYPE_EXPRESSION: {
+				Expression expression = deserializeExpression(context);
+				return new ExpressionStatement(position, expression);
+			}
+			case StatementEncoding.TYPE_FOREACH: {
+				Expression list = deserializeExpression(context);
+				IteratorMemberRef iterator = (IteratorMemberRef)readMember(context, list.type);
+				VarStatement[] loopVariables = new VarStatement[iterator.getLoopVariableCount()];
+				for (int i = 0; i < loopVariables.length; i++) {
+					String name = ((flags & StatementEncoding.FLAG_NAME) > 0) ? readString() : null;
+					loopVariables[i] = new VarStatement(position, name, iterator.types[i], null, true);
+				}
+				ForeachStatement loop = new ForeachStatement(position, loopVariables, iterator, list);
+				StatementContext inner = new StatementContext(context, loop);
+				for (VarStatement variable : loopVariables)
+					inner.add(variable);
+				
+				loop.content = deserializeStatement(inner);
+				return loop;
+			}
+			case StatementEncoding.TYPE_IF: {
+				Expression condition = deserializeExpression(context);
+				Statement onThen = deserializeStatement(context);
+				Statement onElse = deserializeStatement(context);
+				return new IfStatement(position, condition, onThen, onElse);
+			}
+			case StatementEncoding.TYPE_LOCK: {
+				Expression object = deserializeExpression(context);
+				Statement content = deserializeStatement(context);
+				return new LockStatement(position, object, content);
+			}
+			case StatementEncoding.TYPE_RETURN: {
+				Expression value = deserializeExpression(context);
+				return new ReturnStatement(position, value);
+			}
+			case StatementEncoding.TYPE_SWITCH: {
+				Expression value = deserializeExpression(context);
+				String label = ((flags & StatementEncoding.FLAG_LABEL) > 0) ? readString() : null;
+				SwitchStatement statement = new SwitchStatement(position, label, value);
+				StatementContext inner = new StatementContext(context, statement);
+				
+				int numberOfCases = readUInt();
+				for (int i = 0; i < numberOfCases; i++) {
+					SwitchValue switchValue = deserializeSwitchValue(inner, (flags & StatementEncoding.FLAG_NAME) > 0);
+					if (switchValue instanceof VariantOptionSwitchValue)
+						context.variantOptionSwitchValue = (VariantOptionSwitchValue)switchValue;
+					
+					Statement[] statements = new Statement[readUInt()];
+					for (int j = 0; j < statements.length; j++)
+						statements[j] = deserializeStatement(inner);
+					statement.cases.add(new SwitchCase(switchValue, statements));
+				}
+				
+				return statement;
+			}
+			case StatementEncoding.TYPE_THROW: {
+				Expression value = deserializeExpression(context);
+				return new ThrowStatement(position, value);
+			}
+			case StatementEncoding.TYPE_TRY_CATCH:
+				throw new UnsupportedOperationException("Not supported yet");
+			case StatementEncoding.TYPE_VAR: {
+				ITypeID varType = deserializeType(context);
+				String name = (flags & StatementEncoding.FLAG_NAME) > 0 ? readString() : null;
+				Expression initializer = deserializeExpression(context);
+				VarStatement result = new VarStatement(position, name, varType, initializer, (flags & StatementEncoding.FLAG_FINAL) > 0);
+				context.add(result);
+				return result;
+			}
+			case StatementEncoding.TYPE_WHILE: {
+				Expression condition = deserializeExpression(context);
+				String label = (flags & StatementEncoding.FLAG_LABEL) > 0 ? readString() : null;
+				WhileStatement loop = new WhileStatement(position, label, condition);
+				StatementContext inner = new StatementContext(context, loop);
+				loop.content = deserializeStatement(inner);
+				return loop;
+			}
+			default:
+				throw new IllegalArgumentException("Unknown statement type: " + type);
+		}
+	}
+
+	@Override
+	public Expression deserializeExpression(StatementContext context) {
+		int kind = readUInt();
+		int flags = kind == ExpressionEncoding.TYPE_NONE ? 0 : readUInt();
+		CodePosition position = (flags & ExpressionEncoding.FLAG_POSITION) > 0 ? deserializePosition() : CodePosition.UNKNOWN;
+		switch (kind) {
+			case ExpressionEncoding.TYPE_NONE:
+				return null;
+			case ExpressionEncoding.TYPE_AND_AND: {
+				Expression left = deserializeExpression(context);
+				Expression right = deserializeExpression(context);
+				return new AndAndExpression(position, left, right);
+			}
+			case ExpressionEncoding.TYPE_ARRAY: {
+				ITypeID type = deserializeType(context);
+				Expression[] expressions = new Expression[readUInt()];
+				return new ArrayExpression(position, expressions, (ArrayTypeID)type);
+			}
+			case ExpressionEncoding.TYPE_COMPARE: {
+				CompareType comparison = readComparator();
+				Expression left = deserializeExpression(context);
+				Expression right = deserializeExpression(context);
+				FunctionalMemberRef operator = (FunctionalMemberRef)readMember(context, left.type);
+				return new CompareExpression(position, left, right, operator, comparison);
+			}
+			case ExpressionEncoding.TYPE_CALL: {
+				Expression target = deserializeExpression(context);
+				FunctionalMemberRef member = (FunctionalMemberRef)readMember(context, target.type);
+				CallArguments arguments = deserializeArguments(context);
+				FunctionHeader instancedHeader = member.getHeader().instanceForCall(registry, arguments);
+				return new CallExpression(position, target, member, instancedHeader, arguments);
+			}
+			case ExpressionEncoding.TYPE_CALL_STATIC: {
+				ITypeID type = deserializeType(context);
+				FunctionalMemberRef member = (FunctionalMemberRef)readMember(context, type);
+				CallArguments arguments = deserializeArguments(context);
+				FunctionHeader instancedHeader = member.getHeader().instanceForCall(registry, arguments);
+				return new CallStaticExpression(position, type, member, instancedHeader, arguments);
+			}
+			case ExpressionEncoding.TYPE_CAPTURED_CLOSURE: {
+				Expression value = deserializeExpression(context.getLambdaOuter());
+				return new CapturedClosureExpression(position, (CapturedExpression)value, context.getLambdaClosure());
+			}
+			case ExpressionEncoding.TYPE_CAPTURED_DIRECT: {
+				Expression value = deserializeExpression(context.getLambdaOuter());
+				return new CapturedDirectExpression(position, context.getLambdaClosure(), value);
+			}
+			case ExpressionEncoding.TYPE_CAPTURED_LOCAL_VARIABLE: {
+				VarStatement var = context.getLambdaOuter().getVariable(readUInt());
+				return new CapturedLocalVariableExpression(position, var, context.getLambdaClosure());
+			}
+			case ExpressionEncoding.TYPE_CAPTURED_PARAMETER: {
+				FunctionParameter parameter = context.getLambdaOuter().getParameter(readUInt());
+				return new CapturedParameterExpression(position, parameter, context.getLambdaClosure());
+			}
+			case ExpressionEncoding.TYPE_CAPTURED_THIS: {
+				return new CapturedThisExpression(position, context.thisType, context.getLambdaClosure());
+			}
+			case ExpressionEncoding.TYPE_CAST: {
+				ITypeID toType = deserializeType(context);
+				Expression value = deserializeExpression(context);
+				CasterMemberRef member = (CasterMemberRef)readMember(context, toType);
+				return new CastExpression(position, value, member, (flags & ExpressionEncoding.FLAG_IMPLICIT) > 0);
+			}
+			case ExpressionEncoding.TYPE_CHECKNULL: {
+				Expression value = deserializeExpression(context);
+				return new CheckNullExpression(position, value);
+			}
+			case ExpressionEncoding.TYPE_COALESCE: {
+				Expression left = deserializeExpression(context);
+				Expression right = deserializeExpression(context);
+				return new CoalesceExpression(position, left, right);
+			}
+			case ExpressionEncoding.TYPE_CONDITIONAL: {
+				Expression condition = deserializeExpression(context);
+				ITypeID type = deserializeType(context);
+				Expression onThen = deserializeExpression(context);
+				Expression onElse = deserializeExpression(context);
+				return new ConditionalExpression(position, condition, onThen, onElse, type);
+			}
+			case ExpressionEncoding.TYPE_CONST: {
+				ITypeID type = deserializeType(context);
+				ConstMemberRef member = (ConstMemberRef)readMember(context, type);
+				return new ConstExpression(position, member);
+			}
+			case ExpressionEncoding.TYPE_CONSTANT_BOOL_TRUE:
+				return new ConstantBoolExpression(position, true);
+			case ExpressionEncoding.TYPE_CONSTANT_BOOL_FALSE:
+				return new ConstantBoolExpression(position, false);
+			case ExpressionEncoding.TYPE_CONSTANT_BYTE:
+				return new ConstantByteExpression(position, readByte());
+			case ExpressionEncoding.TYPE_CONSTANT_CHAR:
+				return new ConstantCharExpression(position, readChar());
+			case ExpressionEncoding.TYPE_CONSTANT_DOUBLE:
+				return new ConstantDoubleExpression(position, readDouble());
+			case ExpressionEncoding.TYPE_CONSTANT_FLOAT:
+				return new ConstantFloatExpression(position, readFloat());
+			case ExpressionEncoding.TYPE_CONSTANT_INT:
+				return new ConstantIntExpression(position, readInt());
+			case ExpressionEncoding.TYPE_CONSTANT_LONG:
+				return new ConstantLongExpression(position, readLong());
+			case ExpressionEncoding.TYPE_CONSTANT_SBYTE:
+				return new ConstantSByteExpression(position, readSByte());
+			case ExpressionEncoding.TYPE_CONSTANT_SHORT:
+				return new ConstantShortExpression(position, readShort());
+			case ExpressionEncoding.TYPE_CONSTANT_STRING:
+				return new ConstantStringExpression(position, readString());
+			case ExpressionEncoding.TYPE_CONSTANT_UINT:
+				return new ConstantUIntExpression(position, readUInt());
+			case ExpressionEncoding.TYPE_CONSTANT_ULONG:
+				return new ConstantULongExpression(position, readULong());
+			case ExpressionEncoding.TYPE_CONSTANT_USHORT:
+				return new ConstantUShortExpression(position, readUShort());
+			case ExpressionEncoding.TYPE_CONSTANT_USIZE:
+				return new ConstantUSizeExpression(position, readULong());
+			case ExpressionEncoding.TYPE_CONSTRUCTOR_THIS_CALL: {
+				FunctionalMemberRef constructor = (FunctionalMemberRef)readMember(context, context.thisType);
+				CallArguments arguments = deserializeArguments(context);
+				return new ConstructorThisCallExpression(position, context.thisType, constructor, arguments);
+			}
+			case ExpressionEncoding.TYPE_CONSTRUCTOR_SUPER_CALL: {
+				ITypeID superType = context.thisType.getSuperType(registry);
+				FunctionalMemberRef constructor = (FunctionalMemberRef)readMember(context, superType);
+				CallArguments arguments = deserializeArguments(context);
+				return new ConstructorSuperCallExpression(position, superType, constructor, arguments);
+			}
+			case ExpressionEncoding.TYPE_ENUM_CONSTANT: {
+				EnumConstantMember constant = readEnumConstant(context);
+				return new EnumConstantExpression(position, registry.getForDefinition(constant.definition), constant);
+			}
+			case ExpressionEncoding.TYPE_FUNCTION: {
+				FunctionHeader header = deserializeHeader(context);
+				LambdaClosure closure = new LambdaClosure();
+				StatementContext inner = new StatementContext(context, header, closure);
+				Statement body = deserializeStatement(inner);
+				return new FunctionExpression(position, registry.getFunction(header), closure, header, body);
+			}
+			case ExpressionEncoding.TYPE_GET_FIELD: {
+				Expression target = deserializeExpression(context);
+				FieldMemberRef field = (FieldMemberRef)readMember(context, target.type);
+				return new GetFieldExpression(position, target, field);
+			}
+			case ExpressionEncoding.TYPE_GET_FUNCTION_PARAMETER: {
+				FunctionParameter parameter = context.getParameter(readUInt());
+				return new GetFunctionParameterExpression(position, parameter);
+			}
+			case ExpressionEncoding.TYPE_GET_LOCAL_VARIABLE: {
+				VarStatement variable = context.getVariable(readUInt());
+				return new GetLocalVariableExpression(position, variable);
+			}
+			case ExpressionEncoding.TYPE_GET_MATCHING_VARIANT_FIELD: {
+				return new GetMatchingVariantField(position, context.variantOptionSwitchValue, kind);
+			}
+			case ExpressionEncoding.TYPE_GET_STATIC_FIELD: {
+				ITypeID type = deserializeType(context);
+				FieldMemberRef field = (FieldMemberRef)readMember(context, type);
+				return new GetStaticFieldExpression(position, field);
+			}
+			case ExpressionEncoding.TYPE_GETTER: {
+				Expression target = deserializeExpression(context);
+				GetterMemberRef getter = (GetterMemberRef)readMember(context, target.type);
+				return new GetterExpression(position, target, getter);
+			}
+			case ExpressionEncoding.TYPE_GLOBAL: {
+				String name = readString();
+				Expression resolution = deserializeExpression(context);
+				return new GlobalExpression(position, name, resolution);
+			}
+			case ExpressionEncoding.TYPE_GLOBAL_CALL: {
+				String name = readString();
+				CallArguments arguments = deserializeArguments(context);
+				Expression resolution = deserializeExpression(context);
+				return new GlobalCallExpression(position, name, arguments, resolution);
+			}
+			case ExpressionEncoding.TYPE_INTERFACE_CAST: {
+				Expression value = deserializeExpression(context);
+				ITypeID toType = deserializeType(context);
+				return new InterfaceCastExpression(position, value, toType);
+			}
+			case ExpressionEncoding.TYPE_IS: {
+				Expression value = deserializeExpression(context);
+				ITypeID type = deserializeType(context);
+				return new IsExpression(position, value, type);
+			}
+			case ExpressionEncoding.TYPE_MAKE_CONST: {
+				Expression value = deserializeExpression(context);
+				ITypeID constType = registry.getModified(ModifiedTypeID.MODIFIER_CONST, value.type);
+				return new MakeConstExpression(position, value, constType);
+			}
+			case ExpressionEncoding.TYPE_MAP: {
+				ITypeID type = deserializeType(context);
+				Expression[] keys = new Expression[readUInt()];
+				Expression[] values = new Expression[keys.length];
+				for (int i = 0; i < keys.length; i++) {
+					keys[i] = deserializeExpression(context);
+					values[i] = deserializeExpression(context);
+				}
+				return new MapExpression(position, keys, values, type);
+			}
+			case ExpressionEncoding.TYPE_MATCH: {
+				boolean localVariableNames = (flags & ExpressionEncoding.FLAG_NAMES) > 0;
+				
+				Expression value = deserializeExpression(context);
+				ITypeID type = deserializeType(context);
+				MatchExpression.Case[] cases = new MatchExpression.Case[readUInt()];
+				for (int i = 0; i < cases.length; i++) {
+					SwitchValue key = deserializeSwitchValue(context, localVariableNames);
+					Expression caseValue = deserializeExpression(context);
+					cases[i] = new MatchExpression.Case(key, caseValue);
+				}
+				return new MatchExpression(position, value, type, cases);
+			}
+			case ExpressionEncoding.TYPE_NEW: {
+				ITypeID type = deserializeType(context);
+				FunctionalMemberRef member = (FunctionalMemberRef)readMember(context, type);
+				CallArguments arguments = deserializeArguments(context);
+				return new NewExpression(position, type, member, arguments);
+			}
+			case ExpressionEncoding.TYPE_NULL: {
+				ITypeID type = deserializeType(context);
+				return new NullExpression(position, type);
+			}
+			case ExpressionEncoding.TYPE_OR_OR: {
+				Expression left = deserializeExpression(context);
+				Expression right = deserializeExpression(context);
+				return new OrOrExpression(position, left, right);
+			}
+			case ExpressionEncoding.TYPE_PANIC: {
+				Expression value = deserializeExpression(context);
+				ITypeID type = deserializeType(context);
+				return new PanicExpression(position, type, value);
+			}
+			case ExpressionEncoding.TYPE_POST_CALL: {
+				Expression target = deserializeExpression(context);
+				FunctionalMemberRef member = (FunctionalMemberRef)readMember(context, target.type);
+				return new PostCallExpression(position, target, member, member.getHeader());
+			}
+			case ExpressionEncoding.TYPE_RANGE: {
+				Expression from = deserializeExpression(context);
+				Expression to = deserializeExpression(context);
+				return new RangeExpression(position, registry.getRange(from.type), from, to);
+			}
+			case ExpressionEncoding.TYPE_SAME_OBJECT: {
+				Expression left = deserializeExpression(context);
+				Expression right = deserializeExpression(context);
+				boolean inverted = (flags & ExpressionEncoding.FLAG_INVERTED) > 0;
+				return new SameObjectExpression(position, left, right, inverted);
+			}
+			case ExpressionEncoding.TYPE_SET_FIELD: {
+				Expression target = deserializeExpression(context);
+				FieldMemberRef field = (FieldMemberRef)readMember(context, target.type);
+				Expression value = deserializeExpression(context);
+				return new SetFieldExpression(position, target, field, value);
+			}
+			case ExpressionEncoding.TYPE_SET_FUNCTION_PARAMETER: {
+				FunctionParameter parameter = context.getParameter(readUInt());
+				Expression value = deserializeExpression(context);
+				return new SetFunctionParameterExpression(position, parameter, value);
+			}
+			case ExpressionEncoding.TYPE_SET_LOCAL_VARIABLE: {
+				VarStatement variable = context.getVariable(readUInt());
+				Expression value = deserializeExpression(context);
+				return new SetLocalVariableExpression(position, variable, value);
+			}
+			case ExpressionEncoding.TYPE_SET_STATIC_FIELD: {
+				ITypeID type = deserializeType(context);
+				FieldMemberRef member = (FieldMemberRef)readMember(context, type);
+				Expression value = deserializeExpression(context);
+				return new SetStaticFieldExpression(position, member, value);
+			}
+			case ExpressionEncoding.TYPE_SETTER: {
+				Expression target = deserializeExpression(context);
+				SetterMemberRef setter = (SetterMemberRef)readMember(context, target.type);
+				Expression value = deserializeExpression(context);
+				return new SetterExpression(position, target, setter, value);
+			}
+			case ExpressionEncoding.TYPE_STATIC_GETTER: {
+				ITypeID target = deserializeType(context);
+				GetterMemberRef getter = (GetterMemberRef)readMember(context, target);
+				return new StaticGetterExpression(position, getter);
+			}
+			case ExpressionEncoding.TYPE_STATIC_SETTER: {
+				ITypeID target = deserializeType(context);
+				SetterMemberRef setter = (SetterMemberRef)readMember(context, target);
+				Expression value = deserializeExpression(context);
+				return new StaticSetterExpression(position, setter, value);
+			}
+			case ExpressionEncoding.TYPE_SUPERTYPE_CAST: {
+				ITypeID type = deserializeType(context);
+				Expression value = deserializeExpression(context);
+				return new SupertypeCastExpression(position, value, type);
+			}
+			case ExpressionEncoding.TYPE_THIS:
+				return new ThisExpression(position, context.thisType);
+			case ExpressionEncoding.TYPE_THROW: {
+				ITypeID type = deserializeType(context);
+				Expression value = deserializeExpression(context);
+				return new ThrowExpression(position, type, value);
+			}
+			case ExpressionEncoding.TYPE_TRY_CONVERT: {
+				ITypeID type = deserializeType(context);
+				Expression value = deserializeExpression(context);
+				return new TryConvertExpression(position, type, value);
+			}
+			case ExpressionEncoding.TYPE_TRY_RETHROW_AS_EXCEPTION: {
+				ITypeID type = deserializeType(context);
+				ITypeID thrownType = deserializeType(context);
+				Expression value = deserializeExpression(context);
+				return new TryRethrowAsExceptionExpression(position, type, value, thrownType);
+			}
+			case ExpressionEncoding.TYPE_TRY_RETHROW_AS_RESULT: {
+				ITypeID type = deserializeType(context);
+				Expression value = deserializeExpression(context);
+				return new TryRethrowAsResultExpression(position, type, value);
+			}
+			case ExpressionEncoding.TYPE_VARIANT_VALUE: {
+				ITypeID type = deserializeType(context);
+				VariantOptionRef option = readVariantOption(context, type);
+				Expression[] arguments = new Expression[option.types.length];
+				for (int i = 0; i < arguments.length; i++)
+					arguments[i] = deserializeExpression(context);
+				return new VariantValueExpression(position, type, option, arguments);
+			}
+			case ExpressionEncoding.TYPE_WRAP_OPTIONAL: {
+				Expression value = deserializeExpression(context);
+				ITypeID optionalType = registry.getOptional(value.type);
+				return new WrapOptionalExpression(position, value, optionalType);
+			}
+			default:
+				throw new IllegalArgumentException("Not a valid expression type: " + kind);
+		}
+	}
+	
+	private CompareType readComparator() {
+		int type = readUInt();
+		switch (type) {
+			case ExpressionEncoding.COMPARATOR_LT:
+				return CompareType.LT;
+			case ExpressionEncoding.COMPARATOR_GT:
+				return CompareType.GT;
+			case ExpressionEncoding.COMPARATOR_EQ:
+				return CompareType.EQ;
+			case ExpressionEncoding.COMPARATOR_NE:
+				return CompareType.NE;
+			case ExpressionEncoding.COMPARATOR_LE:
+				return CompareType.LE;
+			case ExpressionEncoding.COMPARATOR_GE:
+				return CompareType.GE;
+			default:
+				throw new IllegalArgumentException("Invalid comparator: " + type);
+		}
+	}
+	
+	private SwitchValue deserializeSwitchValue(StatementContext context, boolean localVariableNames) {
+		int type = readUInt();
+		switch (type) {
+			case SwitchValueEncoding.TYPE_NULL:
+				return null;
+			case SwitchValueEncoding.TYPE_INT:
+				return new IntSwitchValue(readInt());
+			case SwitchValueEncoding.TYPE_CHAR:
+				return new CharSwitchValue(readChar());
+			case SwitchValueEncoding.TYPE_STRING:
+				return new StringSwitchValue(readString());
+			case SwitchValueEncoding.TYPE_ENUM:
+				return new EnumConstantSwitchValue(readEnumConstant(context));
+			case SwitchValueEncoding.TYPE_VARIANT_OPTION: {
+				ITypeID t = deserializeType(context);
+				VariantOptionRef option = readVariantOption(context, t);
+				String[] names = new String[option.types.length];
+				if (localVariableNames)
+					for (int i = 0; i < names.length; i++)
+						names[i] = readString();
+				return new VariantOptionSwitchValue(option, names);
+			}
+			default:
+				throw new IllegalArgumentException("Unknown switch value type: " + type);
+		}
+	}
+	
+	@Override
+	public void enqueueMembers(DecodingOperation operation) {
+		members.enqueue(operation);
+	}
+	
+	@Override
+	public void enqueueCode(DecodingOperation operation) {
+		code.enqueue(operation);
+	}
+	
+	private TypeParameterBound deserializeTypeParameterBound(TypeContext context) {
+		int type = readUInt();
+		switch (type) {
+			case TypeParameterEncoding.TYPE_SUPER_BOUND:
+				return new ParameterSuperBound(deserializeType(context));
+			case TypeParameterEncoding.TYPE_TYPE_BOUND:
+				return new ParameterTypeBound(CodePosition.UNKNOWN, deserializeType(context));
+			default:
+				throw new IllegalArgumentException("Not a valid parameter bound type: " + type);
+		}
+	}
+}

ModuleDeserializer/src/main/java/org/openzen/zenscript/moduledeserializer/DecodingStage.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.moduledeserializer;
+
+import org.openzen.zenscript.codemodel.serialization.DecodingOperation;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DecodingStage {
+	private final List<DecodingOperation> operations = new ArrayList<>();
+	private boolean locked = false;
+	
+	public void decode(CodeReader encoder) {
+		locked = true;
+		for (DecodingOperation operation : operations) {
+			operation.decode(encoder);
+		}
+	}
+	
+	public void enqueue(DecodingOperation operation) {
+		if (locked)
+			throw new IllegalStateException("Encoding stage is locked!");
+		
+		operations.add(operation);
+	}
+}

ModuleDeserializer/src/main/java/org/openzen/zenscript/moduledeserializer/DefinitionMemberDeserializer.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.moduledeserializer;
+
+import org.openzen.zenscript.codemodel.context.TypeContext;
+import org.openzen.zenscript.codemodel.definition.AliasDefinition;
+import org.openzen.zenscript.codemodel.definition.ClassDefinition;
+import org.openzen.zenscript.codemodel.definition.DefinitionVisitorWithContext;
+import org.openzen.zenscript.codemodel.definition.EnumDefinition;
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
+import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
+import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
+import org.openzen.zenscript.codemodel.definition.StructDefinition;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DefinitionMemberDeserializer implements DefinitionVisitorWithContext<TypeContext, Void> {
+	private final CodeReader reader;
+	
+	public DefinitionMemberDeserializer(CodeReader reader) {
+		this.reader = reader;
+	}
+
+	@Override
+	public Void visitClass(TypeContext context, ClassDefinition definition) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Void visitInterface(TypeContext context, InterfaceDefinition definition) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Void visitEnum(TypeContext context, EnumDefinition definition) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Void visitStruct(TypeContext context, StructDefinition definition) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Void visitFunction(TypeContext context, FunctionDefinition definition) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Void visitExpansion(TypeContext context, ExpansionDefinition definition) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Void visitAlias(TypeContext context, AliasDefinition definition) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Void visitVariant(TypeContext context, VariantDefinition variant) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+}

ModuleDeserializer/src/main/java/org/openzen/zenscript/moduledeserializer/DeserializationException.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.moduledeserializer;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DeserializationException extends Exception {
+	public DeserializationException(String reason) {
+		super(reason);
+	}
+}

ModuleDeserializer/src/main/java/org/openzen/zenscript/moduledeserializer/DeserializingModule.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.moduledeserializer;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.PackageDefinitions;
+import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
+import org.openzen.zenscript.codemodel.context.ModuleContext;
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.compiler.CompilationUnit;
+import org.openzen.zenscript.compiler.SemanticModule;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DeserializingModule {
+	public final String name;
+	public final Module module;
+	
+	private final SemanticModule loaded;
+	private final DeserializingModule[] dependencies;
+	private final ZSPackage rootPackage;
+	private final ZSPackage modulePackage;
+	
+	private final PackageDefinitions definitions = new PackageDefinitions();
+	private final List<ScriptBlock> scripts = new ArrayList<>();
+	private final AnnotationDefinition[] annotations;
+	
+	private final List<ExpansionDefinition> expansions;
+	public final ModuleContext context;
+	
+	public DeserializingModule(
+			String name,
+			GlobalTypeRegistry registry,
+			DeserializingModule[] dependencies,
+			ZSPackage rootPackage,
+			ZSPackage modulePackage,
+			AnnotationDefinition[] annotations)
+	{
+		this.name = name;
+		this.module = new Module(name);
+		this.loaded = null;
+		this.dependencies = dependencies;
+		this.rootPackage = rootPackage;
+		this.modulePackage = modulePackage;
+		this.annotations = annotations;
+		
+		expansions = new ArrayList<>();
+		context = new ModuleContext(registry, expansions, rootPackage);
+	}
+	
+	public DeserializingModule(SemanticModule module) 
+	{
+		this.name = module.name;
+		this.module = module.module;
+		this.loaded = module;
+		this.dependencies = null;
+		this.rootPackage = module.rootPackage;
+		this.modulePackage = module.modulePackage;
+		this.annotations = module.annotations;
+		
+		expansions = module.expansions;
+		context = module.getContext();
+	}
+	
+	public boolean hasCode() {
+		return module == null;
+	}
+	
+	public SemanticModule load(CompilationUnit compilationUnit) {
+		if (loaded != null)
+			return loaded;
+		
+		SemanticModule[] dependencies = new SemanticModule[this.dependencies.length];
+		List<ExpansionDefinition> expansions = new ArrayList<>();
+		
+		return new SemanticModule(
+				name,
+				module,
+				dependencies,
+				SemanticModule.State.ASSEMBLED,
+				rootPackage,
+				modulePackage,
+				definitions,
+				scripts,
+				compilationUnit,
+				expansions,
+				annotations);
+	}
+}

ModuleDeserializer/src/main/java/org/openzen/zenscript/moduledeserializer/Main.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.moduledeserializer;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
+import org.openzen.zenscript.codemodel.annotations.NativeAnnotationDefinition;
+import org.openzen.zenscript.codemodel.annotations.PreconditionAnnotationDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.compiler.CompilationUnit;
+import org.openzen.zenscript.compiler.ModuleRegistry;
+import org.openzen.zenscript.compiler.SemanticModule;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class Main {
+	public static void main(String[] args) throws IOException, DeserializationException {
+		byte[] data = Files.readAllBytes(new File("../ModuleSerializer/stdlib.bzm").toPath());
+		
+		ZSPackage rootPackage = ZSPackage.createRoot();
+		AnnotationDefinition[] annotations = new AnnotationDefinition[] {
+			NativeAnnotationDefinition.INSTANCE,
+			PreconditionAnnotationDefinition.INSTANCE
+		};
+		CompilationUnit compilationUnit = new CompilationUnit();
+		ModuleRegistry modules = new ModuleRegistry();
+		ModuleDeserializer deserializer = new ModuleDeserializer(modules, compilationUnit, annotations, rootPackage);
+		SemanticModule[] libs = deserializer.deserialize(data);
+		
+	}
+}

ModuleDeserializer/src/main/java/org/openzen/zenscript/moduledeserializer/ModuleDeserializer.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.moduledeserializer;
+
+import compactio.CompactBytesDataInput;
+import compactio.CompactDataInput;
+import java.util.Arrays;
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zencode.shared.VirtualSourceFile;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
+import org.openzen.zenscript.codemodel.context.ModuleContext;
+import org.openzen.zenscript.codemodel.context.TypeContext;
+import org.openzen.zenscript.codemodel.definition.ClassDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.serialization.CodeSerializationInput;
+import org.openzen.zenscript.codemodel.serialization.DecodingOperation;
+import org.openzen.zenscript.compiler.CompilationUnit;
+import org.openzen.zenscript.compiler.ModuleRegistry;
+import org.openzen.zenscript.compiler.SemanticModule;
+import org.openzen.zenscript.moduleserialization.DefinitionEncoding;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ModuleDeserializer {
+	private final ModuleRegistry modules;
+	private final CompilationUnit compilationUnit;
+	private final AnnotationDefinition[] annotations;
+	private final ZSPackage rootPackage;
+	
+	public ModuleDeserializer(
+			ModuleRegistry modules,
+			CompilationUnit compilationUnit,
+			AnnotationDefinition[] annotations,
+			ZSPackage rootPackage)
+	{
+		this.modules = modules;
+		this.compilationUnit = compilationUnit;
+		this.annotations = annotations;
+		this.rootPackage = rootPackage;
+	}
+	
+	public SemanticModule[] deserialize(byte[] data) throws DeserializationException {
+		CompactDataInput input = new CompactBytesDataInput(data);
+		if (input.readInt() != 0x5A43424D)
+			throw new DeserializationException("Invalid marker; not a binary module");
+		
+		int version = input.readVarUInt();
+		if (version != 0)
+			throw new DeserializationException("Unsupported version: " + version);
+		
+		String[] stringTable = input.readStringArray();
+		SourceFile[] sourceFiles = new SourceFile[input.readVarUInt()];
+		for (int i = 0; i < sourceFiles.length; i++)
+			sourceFiles[i] = new VirtualSourceFile(input.readString());
+		
+		CodeReader decoder = new CodeReader(
+				input,
+				stringTable,
+				sourceFiles,
+				compilationUnit.globalTypeRegistry);
+		
+		DeserializingModule[] packagedModules = new DeserializingModule[input.readVarUInt()];
+		String[][] dependencyNames = new String[packagedModules.length][];
+		for (int i = 0; i < packagedModules.length; i++) {
+			int flags = input.readVarUInt();
+			String name = input.readString();
+			
+			ZSPackage modulePackage = rootPackage;
+			int packageNameParts = input.readVarUInt();
+			for (int j = 0; j < packageNameParts; j++)
+				modulePackage = modulePackage.getOrCreatePackage(input.readString());
+
+			DeserializingModule[] dependencies = new DeserializingModule[input.readVarUInt()];
+			String[] dependencyNames2 = new String[dependencies.length];
+			dependencyNames[i] = dependencyNames2;
+			for (int j = 0; j < dependencyNames2.length; j++)
+				dependencyNames2[j] = input.readString();
+			
+			packagedModules[i] = new DeserializingModule(
+					name,
+					compilationUnit.globalTypeRegistry,
+					dependencies,
+					rootPackage,
+					modulePackage,
+					annotations);
+			decoder.code.enqueue(new ModuleDecodeScriptsOperation(packagedModules[i]));
+			decoder.classes.enqueue(new ModuleDecodeClassesOperation(packagedModules[i], decoder));
+		}
+		
+		DeserializingModule[] allModules = Arrays.copyOf(packagedModules, input.readVarUInt());
+		for (int i = packagedModules.length; i < allModules.length; i++) {
+			int flags = input.readVarUInt();
+			String name = input.readString();
+			allModules[i] = new DeserializingModule(modules.load(name));
+			decoder.classes.enqueue(new ModuleDecodeClassesOperation(allModules[i], decoder));
+		}
+		
+		System.out.println("Decoding classes");
+		decoder.startClasses();
+		decoder.classes.decode(decoder);
+		System.out.println("Decoding members");
+		decoder.startMembers();
+		decoder.members.decode(decoder);
+		System.out.println("Decoding code");
+		decoder.startCode();
+		decoder.code.decode(decoder);
+		
+		SemanticModule[] results = new SemanticModule[packagedModules.length];
+		for (int i = 0; i < results.length; i++) {
+			DeserializingModule module = packagedModules[i];
+			results[i] = module.load(compilationUnit);
+		}
+		return results;
+	}
+	
+	private class ModuleDecodeClassesOperation implements DecodingOperation {
+		private final DeserializingModule module;
+		private final CodeReader reader;
+		
+		public ModuleDecodeClassesOperation(DeserializingModule module, CodeReader reader) {
+			this.module = module;
+			this.reader = reader;
+		}
+
+		@Override
+		public void decode(CodeSerializationInput input) {
+			int numDefinitions = input.readUInt();
+			DefinitionMemberDeserializer memberDeserializer = new DefinitionMemberDeserializer(reader);
+			for (int i = 0; i < numDefinitions; i++) {
+				HighLevelDefinition definition = deserializeDefinition(reader, module.context);
+				reader.add(definition);
+				
+				TypeContext typeContext = new TypeContext(module.context, definition.typeParameters, module.context.registry.getForMyDefinition(definition));
+				reader.members.enqueue(in -> definition.accept(typeContext, memberDeserializer));
+			}
+		}
+		
+		private HighLevelDefinition deserializeDefinition(CodeReader reader, ModuleContext context) {
+			int type = reader.readUInt();
+			int flags = reader.readUInt();
+			CodePosition position = CodePosition.UNKNOWN;
+			String name = null;
+			TypeParameter[] typeParameters = TypeParameter.NONE;
+			if ((flags & DefinitionEncoding.FLAG_POSITION) > 0)
+				position = reader.deserializePosition();
+			ZSPackage pkg = context.root.getRecursive(reader.readString());
+			if ((flags & DefinitionEncoding.FLAG_NAME) > 0)
+				name = reader.readString();
+			if ((flags & DefinitionEncoding.FLAG_TYPE_PARAMETERS) > 0)
+				typeParameters = reader.deserializeTypeParameters(new TypeContext(context, TypeParameter.NONE, null));
+			
+			switch (type) { 
+				case DefinitionEncoding.TYPE_CLASS: {
+					ClassDefinition result = new ClassDefinition(position, context.module, pkg, name, flags);
+					decodeMembers(reader, context, result);
+					return result;
+				}
+				case DefinitionEncoding.TYPE_STRUCT:
+				case DefinitionEncoding.TYPE_INTERFACE:
+				case DefinitionEncoding.TYPE_ENUM:
+				case DefinitionEncoding.TYPE_VARIANT:
+				case DefinitionEncoding.TYPE_FUNCTION:
+				case DefinitionEncoding.TYPE_ALIAS:
+				case DefinitionEncoding.TYPE_EXPANSION:
+			}
+		}
+	}
+	
+	private void decodeMembers(
+			CodeReader reader,
+			ModuleContext moduleContext,
+			HighLevelDefinition definition)
+	{
+		reader.enqueueMembers(input -> {
+			TypeContext context = new TypeContext(moduleContext, definition.typeParameters, moduleContext.registry.getForMyDefinition(definition));
+			definition.addMember(reader.deserializeMember(context));
+		});
+		
+		int innerMembers = reader.readUInt();
+		
+	}
+	
+	private class ModuleDecodeScriptsOperation implements DecodingOperation {
+		private final DeserializingModule module;
+		
+		public ModuleDecodeScriptsOperation(DeserializingModule module) {
+			this.module = module;
+		}
+
+		@Override
+		public void decode(CodeSerializationInput input) {
+			
+		}
+	}
+}

ModuleSerializationShared/src/main/java/org/openzen/zenscript/moduleserialization/ExpressionEncoding.java

 	
 	public static final int FLAG_POSITION = 1;
 	public static final int FLAG_IMPLICIT = 2; // for cast expressions
+	public static final int FLAG_NAMES = 4;
+	public static final int FLAG_INVERTED = 8;
 	
 	public static final int TYPE_NONE = 0;
 	public static final int TYPE_AND_AND = 1;

ModuleSerializationShared/src/main/java/org/openzen/zenscript/moduleserialization/FunctionHeaderEncoding.java

 	
 	public static final int FLAG_TYPE_PARAMETERS = 1;
 	public static final int FLAG_RETURN_TYPE = 2;
-	public static final int FLAG_PARAMETERS = 4;
-	public static final int FLAG_VARIADIC = 8;
-	public static final int FLAG_DEFAULT_VALUES = 16;
+	public static final int FLAG_THROWS = 4;
+	public static final int FLAG_PARAMETERS = 8;
+	public static final int FLAG_VARIADIC = 16;
+	public static final int FLAG_DEFAULT_VALUES = 32;
 }

ModuleSerializationShared/src/main/java/org/openzen/zenscript/moduleserialization/StatementEncoding.java

 	public static final int FLAG_POSITION = 1;
 	public static final int FLAG_ANNOTATIONS = 2;
 	public static final int FLAG_FINAL = 4;
+	public static final int FLAG_NAME = 8;
+	public static final int FLAG_LABEL = 16;
 	
 	public static final int TYPE_NULL = 0;
 	public static final int TYPE_BLOCK = 1;

ModuleSerializationShared/src/main/java/org/openzen/zenscript/moduleserialization/TypeEncoding.java

 	public static final int TYPE_STRING = 16;
 	public static final int TYPE_UNDETERMINED = 17;
 	public static final int TYPE_DEFINITION = 18;
-	public static final int TYPE_GENERIC = 19;
-	public static final int TYPE_FUNCTION = 20;
-	public static final int TYPE_ARRAY = 21;
-	public static final int TYPE_ARRAY_MULTIDIMENSIONAL = 22;
-	public static final int TYPE_ASSOC = 23;
-	public static final int TYPE_GENERIC_MAP = 24;
-	public static final int TYPE_RANGE = 25;
-	public static final int TYPE_ITERATOR = 26;
-	public static final int TYPE_OPTIONAL = 27;
-	public static final int TYPE_CONST = 28;
-	public static final int TYPE_IMMUTABLE = 29;
+	public static final int TYPE_DEFINITION_INNER = 19;
+	public static final int TYPE_GENERIC = 20;
+	public static final int TYPE_FUNCTION = 21;
+	public static final int TYPE_ARRAY = 22;
+	public static final int TYPE_ARRAY_MULTIDIMENSIONAL = 23;
+	public static final int TYPE_ASSOC = 24;
+	public static final int TYPE_GENERIC_MAP = 25;
+	public static final int TYPE_RANGE = 26;
+	public static final int TYPE_ITERATOR = 27;
+	public static final int TYPE_OPTIONAL = 28;
+	public static final int TYPE_CONST = 29;
+	public static final int TYPE_IMMUTABLE = 30;
 }

ModuleSerializationShared/src/main/java/org/openzen/zenscript/moduleserialization/TypeParameterEncoding.java

 	
 	public static final int FLAG_POSITION = 1;
 	public static final int FLAG_NAME = 2;
+	public static final int FLAG_BOUNDS = 4;
 	
 	public static final int TYPE_TYPE_BOUND = 1;
 	public static final int TYPE_SUPER_BOUND = 2;

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/ModuleEncoder.java → ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/CodeWriter.java

  *
  * @author Hoofdgebruiker
  */
-public class ModuleEncoder implements CodeSerializationOutput {
+public class CodeWriter implements CodeSerializationOutput {
 	private final Map<String, Integer> stringMap = new HashMap<>();
 	private final Map<SourceFile, Integer> sourceFileMap = new HashMap<>();
 	
 	
 	private CodePosition lastPosition = CodePosition.UNKNOWN;
 	
-	public ModuleEncoder(
+	public CodeWriter(
 			CompactDataOutput output,
 			SerializationOptions options,
 			String[] strings,
 		typeParameterEncoder = new TypeParameterBoundSerializer(this);
 		memberSerializer = new MemberSerializer(this, options);
 		typeSerializer = new TypeSerializer(this);
-		statementSerializer = new StatementSerializer(this, options.positions);
-		expressionSerializer = new ExpressionSerializer(this, options.expressionPositions);
-		switchValueSerializer = new SwitchValueSerializer(this);
+		statementSerializer = new StatementSerializer(this, options.positions, options.localVariableNames);
+		expressionSerializer = new ExpressionSerializer(this, options.expressionPositions, options.localVariableNames);
+		switchValueSerializer = new SwitchValueSerializer(this, options.localVariableNames);
 		
 		for (String string : strings)
 			stringMap.put(string, stringMap.size());
 			return;
 		} else if (member.getTarget().getBuiltin() != null) {
 			writeUInt(1);
-			serialize(context, member.getType());
 			writeUInt(member.getTarget().getBuiltin().ordinal()); // TODO: use something else?
 			return;
 		}
 		
 		IDefinitionMember member_ = member.getTarget();
-		write(member_.getDefinition());
 		EncodingDefinition definition = member_.getDefinition().getTag(EncodingDefinition.class);
 		
 		int index = definition.members.indexOf(member_);
 	
 	@Override
 	public void serialize(TypeContext context, TypeParameter parameter) {
-		int typeParameterFlags = 0;
+		int flags = serializeInitial(parameter);
+		serializeRemaining(flags, context, parameter);
+	}
+	
+	@Override
+	public void serialize(TypeContext context, TypeParameter[] parameters) {
+		output.writeVarUInt(parameters.length);
+		int[] flags = new int[parameters.length];
+		for (int i = 0; i < parameters.length; i++)
+			flags[i] = serializeInitial(parameters[i]);
+		for (int i = 0; i < parameters.length; i++)
+			serializeRemaining(flags[i], context, parameters[i]);
+	}
+	
+	private int serializeInitial(TypeParameter parameter) {
+		int flags = 0;
 		if (parameter.position != CodePosition.UNKNOWN && options.positions)
-			typeParameterFlags |= TypeParameterEncoding.FLAG_POSITION;
+			flags |= TypeParameterEncoding.FLAG_POSITION;
 		if (parameter.name != null && options.typeParameterNames)
-			typeParameterFlags |= TypeParameterEncoding.FLAG_NAME;
+			flags |= TypeParameterEncoding.FLAG_NAME;
 
-		output.writeVarUInt(typeParameterFlags);
-		if ((typeParameterFlags & TypeParameterEncoding.FLAG_POSITION) > 0)
+		output.writeVarUInt(flags);
+		if ((flags & TypeParameterEncoding.FLAG_POSITION) > 0)
 			serialize(parameter.position);
-		if ((typeParameterFlags & TypeParameterEncoding.FLAG_NAME) > 0)
+		if ((flags & TypeParameterEncoding.FLAG_NAME) > 0)
 			output.writeString(parameter.name);
 		
+		return flags;
+	}
+	
+	private void serializeRemaining(int flags, TypeContext context, TypeParameter parameter) {
 		if (currentStage == code || currentStage == members) {
 			output.writeVarUInt(parameter.bounds.size());
 			for (TypeParameterBound bound : parameter.bounds)
 		if (header.getReturnType() != BasicTypeID.VOID)
 			flags |= FunctionHeaderEncoding.FLAG_RETURN_TYPE;
 		if (header.parameters.length > 0)
+			flags |= FunctionHeaderEncoding.FLAG_THROWS;
+		if (header.hasAnyDefaultValues())
 			flags |= FunctionHeaderEncoding.FLAG_PARAMETERS;
 		if (header.parameters.length > 0 && header.parameters[header.parameters.length - 1].variadic)
 			flags |= FunctionHeaderEncoding.FLAG_VARIADIC;
-		if (header.hasAnyDefaultValues())
+		if (header.thrownType != null)
 			flags |= FunctionHeaderEncoding.FLAG_DEFAULT_VALUES;
 		
 		writeUInt(flags);
-		if ((flags & FunctionHeaderEncoding.FLAG_TYPE_PARAMETERS) > 0) {
-			writeUInt(header.typeParameters.length);
-			for (TypeParameter parameter : header.typeParameters) {
-				serialize(context, parameter);
-			}
-		}
+		if ((flags & FunctionHeaderEncoding.FLAG_TYPE_PARAMETERS) > 0)
+			serialize(context, header.typeParameters);
 		if ((flags & FunctionHeaderEncoding.FLAG_RETURN_TYPE) > 0)
 			serialize(context, header.getReturnType());
+		if ((flags & FunctionHeaderEncoding.FLAG_THROWS) > 0)
+			serialize(context, header.thrownType);
 		
 		if ((flags & FunctionHeaderEncoding.FLAG_PARAMETERS) > 0) {
-			StatementContext statementContext = new StatementContext(header);
+			StatementContext statementContext = new StatementContext(context);
+			writeUInt(header.parameters.length);
 			for (FunctionParameter parameter : header.parameters) {
 				// TODO: annotations
 				serialize(context, parameter.type);

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/EncodingModule.java

 import java.util.ArrayList;
 import java.util.List;
 import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.context.ModuleContext;
 
 /**
  *
  */
 public class EncodingModule {
 	private final Module module;
+	public final ModuleContext context;
 	public final List<EncodingDefinition> definitions = new ArrayList<>();
 	public final boolean withCode;
 	
-	public EncodingModule(Module module, boolean withCode) {
+	public EncodingModule(Module module, ModuleContext context, boolean withCode) {
 		this.module = module;
+		this.context = context;
 		this.withCode = withCode;
 	}
 	

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/EncodingStage.java

 	private final List<EncodingOperation> operations = new ArrayList<>();
 	private boolean locked = false;
 	
-	public void encode(ModuleEncoder encoder) {
+	public void encode(CodeWriter encoder) {
 		locked = true;
 		for (EncodingOperation operation : operations) {
 			operation.encode(encoder);

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/Main.java

 				true,
 				false,
 				false,
-				true));
+				true,
+				false));
 		byte[] encoded = serializer.serialize(Collections.singletonList(module));
 		System.out.println("stdlib encoded as " + encoded.length + " bytes");
 		Files.write(new File("stdlib.bzm").toPath(), encoded);

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/ModuleSerializer.java

 import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.context.ModuleContext;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.moduleserialization.ModuleEncoding;
 		
 		List<EncodingModule> encodingModules = new ArrayList<>();
 		for (SemanticModule module : modules) {
-			encodingModules.add(tableBuilder.register(module.module));
+			encodingModules.add(tableBuilder.register(module.module, module.getContext()));
 			
 			tableBuilder.writeString(module.name);
 			for (String part : getPackageName(module.modulePackage))
 		}
 		
 		for (SemanticModule module : modules) {
-			EncodingModule encodedModule = tableBuilder.register(module.module);
+			EncodingModule encodedModule = tableBuilder.register(module.module, module.getContext());
+			ModuleContext moduleContext = new ModuleContext(module.compilationUnit.globalTypeRegistry, module.expansions, module.rootPackage);
 			for (HighLevelDefinition definition : module.definitions.getAll()) {
 				encodedModule.add(EncodingDefinition.complete(definition));
-				tableBuilder.serialize(definition);
+				tableBuilder.serialize(moduleContext, definition);
 			}
 			
 			for (ScriptBlock script : module.scripts) {
-				StatementContext context = new StatementContext();
+				StatementContext context = new StatementContext(moduleContext, null);
 				for (Statement statement : script.statements) {
 					tableBuilder.serialize(context, statement);
 				}
 		String[] strings = tableBuilder.getStrings();
 		
 		CompactBytesDataOutput output = new CompactBytesDataOutput();
-		ModuleEncoder encoder = new ModuleEncoder(
+		CodeWriter encoder = new CodeWriter(
 				output,
 				options,
 				strings,
 			for (SemanticModule dependency : module.dependencies)
 				output.writeString(dependency.name);
 			
-			encoder.code.enqueue(new ModuleEncodeScriptsOperation(module.scripts));
+			ModuleContext moduleContext = new ModuleContext(
+					module.compilationUnit.globalTypeRegistry,
+					module.expansions,
+					module.rootPackage);
+			encoder.code.enqueue(new ModuleEncodeScriptsOperation(moduleContext, module.scripts));
 			encoder.classes.enqueue(new ModuleEncodeClassesOperation(options, encodingModule, encoder));
 		}
 		
 	private static class ModuleEncodeClassesOperation implements EncodingOperation {
 		private final SerializationOptions options;
 		private final EncodingModule module;
-		private final ModuleEncoder encoder;
+		private final CodeWriter encoder;
 		
 		public ModuleEncodeClassesOperation(
 				SerializationOptions options,
 				EncodingModule module,
-				ModuleEncoder encoder)
+				CodeWriter encoder)
 		{
 			this.options = options;
 			this.module = module;
 			DefinitionSerializer definitionEncoder = new DefinitionSerializer(options, output);
 			for (EncodingDefinition definition : module.definitions) {
 				System.out.println("Encoding definition " + definition.definition.name);
-				definition.definition.accept(definitionEncoder);
+				definition.definition.accept(module.context, definitionEncoder);
 				encoder.add(definition.definition);
 			}
 		}
 	}
 	
 	private static class ModuleEncodeScriptsOperation implements EncodingOperation {
+		private final ModuleContext module;
 		private final List<ScriptBlock> scripts;
 		
-		public ModuleEncodeScriptsOperation(List<ScriptBlock> scripts) {
+		public ModuleEncodeScriptsOperation(ModuleContext module, List<ScriptBlock> scripts) {
+			this.module = module;
 			this.scripts = scripts;
 		}
 
 			output.writeUInt(scripts.size());
 			for (ScriptBlock script : scripts) {
 				output.writeUInt(script.statements.size());
-				StatementContext context = new StatementContext();
+				StatementContext context = new StatementContext(module, null);
 				for (Statement statement : script.statements) {
 					output.serialize(context, statement);
 				}

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/SerializationOptions.java

 	public final boolean expressionPositions;
 	public final boolean positionOffsets;
 	public final boolean typeParameterNames;
+	public final boolean localVariableNames;
 	
 	public SerializationOptions(
 			boolean positions,
 			boolean expressionPositions,
 			boolean positionOffsets,
-			boolean typeParameterNames) {
+			boolean typeParameterNames,
+			boolean localVariableNames) {
 		this.positions = positions;
 		this.expressionPositions = expressionPositions;
 		this.positionOffsets = positionOffsets;
 		this.typeParameterNames = typeParameterNames;
+		this.localVariableNames = localVariableNames;
 	}
 }

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/TableBuilder.java

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.context.ModuleContext;
 import org.openzen.zenscript.codemodel.context.StatementContext;
 import org.openzen.zenscript.codemodel.context.TypeContext;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.serialization.CodeSerializationOutput;
 import org.openzen.zenscript.codemodel.serialization.EncodingOperation;
 import org.openzen.zenscript.codemodel.statement.Statement;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.moduleserialization.FunctionHeaderEncoding;
 import org.openzen.zenscript.moduleserialization.TypeParameterEncoding;
 import org.openzen.zenscript.moduleserializer.encoder.DefinitionMemberSerializer;
 import org.openzen.zenscript.moduleserializer.encoder.DefinitionSerializer;
 		definitionSerializer = new DefinitionSerializer(options, this);
 		definitionMemberSerializer = new DefinitionMemberSerializer(options, this);
 		memberSerializer = new MemberSerializer(this, options);
-		switchValues = new SwitchValueSerializer(this);
-		statements = new StatementSerializer(this, true);
-		expressions = new ExpressionSerializer(this, true);
+		switchValues = new SwitchValueSerializer(this, options.localVariableNames);
+		statements = new StatementSerializer(this, options.positions, options.localVariableNames);
+		expressions = new ExpressionSerializer(this, options.positions, options.localVariableNames);
 		typeSerializer = new TypeSerializer(this);
 		typeParameterBoundSerializer = new TypeParameterBoundSerializer(this);
 	}
 	
-	public EncodingModule register(Module module) {
+	public EncodingModule register(Module module, ModuleContext context) {
 		if (moduleSet.add(module)) {
-			EncodingModule encodedModule = new EncodingModule(module, true);
+			EncodingModule encodedModule = new EncodingModule(module, context, true);
 			module.setTag(EncodingModule.class, encodedModule);
 			modules.add(encodedModule);
 			return encodedModule;
 	}
 	
 	private EncodingDefinition prepare(HighLevelDefinition definition) {
-		register(definition.module);
+		register(definition.module, null);
 		
 		if (definitions.add(definition)) {
 			EncodingDefinition result = new EncodingDefinition(definition);
 		}
 	}
 	
-	public void serialize(HighLevelDefinition definition) {
-		definition.accept(definitionSerializer);
-		definition.accept(new TypeContext(definition.typeParameters), definitionMemberSerializer);
+	public void serialize(ModuleContext context, HighLevelDefinition definition) {
+		definition.accept(context, definitionSerializer);
+		ITypeID thisType = context.registry.getForMyDefinition(definition);
+		definition.accept(new TypeContext(context, definition.typeParameters, thisType), definitionMemberSerializer);
 	}
 
 	@Override
 			typeParameterFlags |= TypeParameterEncoding.FLAG_POSITION;
 		if (parameter.name != null && options.typeParameterNames)
 			typeParameterFlags |= TypeParameterEncoding.FLAG_NAME;
+		if (!parameter.bounds.isEmpty())
+			typeParameterFlags |= TypeParameterEncoding.FLAG_BOUNDS;
 
 		if ((typeParameterFlags & TypeParameterEncoding.FLAG_POSITION) > 0)
 			serialize(parameter.position);
 		if ((typeParameterFlags & TypeParameterEncoding.FLAG_NAME) > 0)
 			writeString(parameter.name);
-		
-		for (TypeParameterBound bound : parameter.bounds)
-			bound.accept(context, typeParameterBoundSerializer);
+		if ((typeParameterFlags & TypeParameterEncoding.FLAG_BOUNDS) > 0) {
+			for (TypeParameterBound bound : parameter.bounds)
+				bound.accept(context, typeParameterBoundSerializer);
+		}
+	}
+	
+	@Override
+	public void serialize(TypeContext context, TypeParameter[] parameters) {
+		for (TypeParameter parameter : parameters)
+			serialize(context, parameter);
 	}
 
 	@Override
 
 	@Override
 	public void serialize(TypeContext context, FunctionHeader header) {
-		for (TypeParameter parameter : header.typeParameters)
-			serialize(context, parameter);
-			
+		serialize(context, header.typeParameters);
 		serialize(context, header.getReturnType());
 		
-		StatementContext statementContext = new StatementContext(header);
+		StatementContext statementContext = new StatementContext(context, header);
 		for (FunctionParameter parameter : header.parameters) {
 			// TODO: annotations
 			serialize(context, parameter.type);

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/encoder/DefinitionMemberSerializer.java

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.moduleserialization.DefinitionEncoding;
 import org.openzen.zenscript.moduleserializer.EncodingDefinition;
-import org.openzen.zenscript.moduleserializer.EncodingModule;
-import org.openzen.zenscript.moduleserializer.ModuleEncoder;
 import org.openzen.zenscript.moduleserializer.SerializationOptions;
 
 /**

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/encoder/DefinitionSerializer.java

  */
 package org.openzen.zenscript.moduleserializer.encoder;
 
+import java.util.ArrayList;
+import java.util.List;
 import org.openzen.zenscript.codemodel.context.TypeContext;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.ModuleContext;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
-import org.openzen.zenscript.codemodel.definition.DefinitionVisitor;
+import org.openzen.zenscript.codemodel.definition.DefinitionVisitorWithContext;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
 import org.openzen.zenscript.codemodel.definition.StructDefinition;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.InnerDefinitionMember;
 import org.openzen.zenscript.codemodel.serialization.CodeSerializationOutput;
 import org.openzen.zenscript.moduleserialization.DefinitionEncoding;
-import org.openzen.zenscript.moduleserialization.TypeParameterEncoding;
 import org.openzen.zenscript.moduleserializer.SerializationOptions;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class DefinitionSerializer implements DefinitionVisitor<Void> {
+public class DefinitionSerializer implements DefinitionVisitorWithContext<ModuleContext, Void> {
 	private final SerializationOptions options;
 	private final CodeSerializationOutput output;
 	
 		this.output = output;
 	}
 	
-	private void visit(HighLevelDefinition definition) {
+	private void visit(ModuleContext context, HighLevelDefinition definition) {
 		int flags = 0;
 		if (definition.position != null && options.positions)
 			flags |= DefinitionEncoding.FLAG_POSITION;
 			output.writeString(definition.name);
 		if (definition.typeParameters.length > 0) {
 			output.writeUInt(definition.typeParameters.length);
-			for (TypeParameter parameter : definition.typeParameters) {
-				int typeParameterFlags = 0;
-				if (parameter.position != CodePosition.UNKNOWN && options.positions)
-					typeParameterFlags |= TypeParameterEncoding.FLAG_POSITION;
-				if (parameter.name != null && options.typeParameterNames)
-					typeParameterFlags |= TypeParameterEncoding.FLAG_NAME;
-				
-				output.writeUInt(typeParameterFlags);
-				if ((typeParameterFlags & TypeParameterEncoding.FLAG_POSITION) > 0)
-					output.serialize(parameter.position);
-				if ((typeParameterFlags & TypeParameterEncoding.FLAG_NAME) > 0)
-					output.writeString(parameter.name);
-			}
+			TypeContext typeContext = new TypeContext(context, TypeParameter.NONE, null);
+			output.serialize(typeContext, definition.typeParameters);
 		}
 	}
 	
-	private void queueEncodeMembers(HighLevelDefinition definition) {
+	private void encodeMembers(ModuleContext moduleContext, HighLevelDefinition definition) {
+		List<InnerDefinitionMember> innerDefinitions = new ArrayList<>();
+		for (IDefinitionMember member : definition.members)
+			if ((member instanceof InnerDefinitionMember))
+				innerDefinitions.add((InnerDefinitionMember)member);
+		
 		output.enqueueMembers(output -> {
 			DefinitionMemberSerializer memberEncoder = new DefinitionMemberSerializer(options, output);
-			TypeContext context = new TypeContext(definition.typeParameters);
+			TypeContext context = new TypeContext(moduleContext, definition.typeParameters, moduleContext.registry.getForMyDefinition(definition));
 			definition.accept(context, memberEncoder);
 		});
+		
+		output.writeUInt(innerDefinitions.size());
+		for (InnerDefinitionMember innerDefinition : innerDefinitions)
+			innerDefinition.innerDefinition.accept(moduleContext, this);
 	}
 	
 	@Override
-	public Void visitClass(ClassDefinition definition) {
+	public Void visitClass(ModuleContext context, ClassDefinition definition) {
 		output.writeUInt(DefinitionEncoding.TYPE_CLASS);
-		visit(definition);
-		queueEncodeMembers(definition);
+		visit(context, definition);
+		encodeMembers(context, definition);
 		return null;
 	}
 
 	@Override
-	public Void visitInterface(InterfaceDefinition definition) {
+	public Void visitInterface(ModuleContext context, InterfaceDefinition definition) {
 		output.writeUInt(DefinitionEncoding.TYPE_INTERFACE);
-		visit(definition);
-		queueEncodeMembers(definition);
+		visit(context, definition);
+		encodeMembers(context, definition);
 		return null;
 	}
 
 	@Override
-	public Void visitEnum(EnumDefinition definition) {
+	public Void visitEnum(ModuleContext context, EnumDefinition definition) {
 		output.writeUInt(DefinitionEncoding.TYPE_ENUM);
-		visit(definition);
-		queueEncodeMembers(definition);
+		visit(context, definition);
+		encodeMembers(context, definition);
 		return null;
 	}
 
 	@Override
-	public Void visitStruct(StructDefinition definition) {
+	public Void visitStruct(ModuleContext context, StructDefinition definition) {
 		output.writeUInt(DefinitionEncoding.TYPE_STRUCT);
-		visit(definition);
-		queueEncodeMembers(definition);
+		visit(context, definition);
+		encodeMembers(context, definition);
 		return null;
 	}
 
 	@Override
-	public Void visitFunction(FunctionDefinition definition) {
+	public Void visitFunction(ModuleContext context, FunctionDefinition definition) {
 		output.writeUInt(DefinitionEncoding.TYPE_FUNCTION);
-		visit(definition);
-		queueEncodeMembers(definition);
+		visit(context, definition);
+		encodeMembers(context, definition);
 		return null;
 	}
 
 	@Override
-	public Void visitExpansion(ExpansionDefinition definition) {
+	public Void visitExpansion(ModuleContext context, ExpansionDefinition definition) {
 		output.writeUInt(DefinitionEncoding.TYPE_EXPANSION);
-		visit(definition);
-		queueEncodeMembers(definition);
+		visit(context, definition);
+		encodeMembers(context, definition);
 		return null;
 	}
 
 	@Override
-	public Void visitAlias(AliasDefinition definition) {
+	public Void visitAlias(ModuleContext context, AliasDefinition definition) {
 		output.writeUInt(DefinitionEncoding.TYPE_ALIAS);
-		visit(definition);
+		visit(context, definition);
 		return null;
 	}
 
 	@Override
-	public Void visitVariant(VariantDefinition variant) {
+	public Void visitVariant(ModuleContext context, VariantDefinition variant) {
 		output.writeUInt(DefinitionEncoding.TYPE_VARIANT);
-		visit(variant);
-		queueEncodeMembers(variant);
+		visit(context, variant);
+		encodeMembers(context, variant);
 		return null;
 	}
 }

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/encoder/ExpressionSerializer.java

 public class ExpressionSerializer implements ExpressionVisitorWithContext<StatementContext, Void> {
 	private final CodeSerializationOutput output;
 	private final boolean positions;
+	private final boolean localVariableNames;
 	
-	public ExpressionSerializer(CodeSerializationOutput output, boolean positions) {
+	public ExpressionSerializer(
+			CodeSerializationOutput output,
+			boolean positions,
+			boolean localVariableNames)
+	{
 		this.output = output;
 		this.positions = positions;
+		this.localVariableNames = localVariableNames;
 	}
 	
 	private int getFlags(Expression expression) {
 		output.writeUInt(getCompareType(expression.comparison));
 		output.serialize(context, expression.left);
 		output.serialize(context, expression.right);
+		output.write(context, expression.operator);
 		return null;
 	}
 
 		int flags = getFlags(expression);
 		serialize(flags, expression);
 		
-		output.write(context, expression.member);
 		output.serialize(context, expression.target);
+		output.write(context, expression.member);
 		output.serialize(context, expression.arguments);
 		return null;
 	}
 		int flags = getFlags(expression);
 		serialize(flags, expression);
 		
-		output.write(context, expression.member);
 		output.serialize(context, expression.target);
+		output.write(context, expression.member);
 		output.serialize(context, expression.arguments);
 		return null;
 	}
 
 	@Override
 	public Void visitCapturedClosure(StatementContext context, CapturedClosureExpression expression) {
+		if (expression.closure != context.getLambdaClosure())
+			throw new AssertionError("Closure invalid");
+		
 		output.writeUInt(ExpressionEncoding.TYPE_CAPTURED_CLOSURE);
 		int flags = getFlags(expression);
 		serialize(flags, expression);
 		
-		output.serialize(context, expression.value);
+		output.serialize(context.getLambdaOuter(), expression.value);
 		return null;
 	}
 
 	@Override
 	public Void visitCapturedDirect(StatementContext context, CapturedDirectExpression expression) {
+		if (expression.closure != context.getLambdaClosure())
+			throw new AssertionError("Closure invalid");
+		
 		output.writeUInt(ExpressionEncoding.TYPE_CAPTURED_DIRECT);
 		int flags = getFlags(expression);
 		serialize(flags, expression);
 
 	@Override
 	public Void visitCapturedLocalVariable(StatementContext context, CapturedLocalVariableExpression expression) {
+		if (expression.closure != context.getLambdaClosure())
+			throw new AssertionError("Closure invalid");
+		
 		output.writeUInt(ExpressionEncoding.TYPE_CAPTURED_LOCAL_VARIABLE);
 		int flags = getFlags(expression);
 		serialize(flags, expression);
 		
-		output.writeUInt(context.getVariableId(expression.variable));
+		output.writeUInt(context.getLambdaOuter().getVariableId(expression.variable));
 		return null;
 	}
 
 	@Override
 	public Void visitCapturedParameter(StatementContext context, CapturedParameterExpression expression) {
+		if (expression.closure != context.getLambdaClosure())
+			throw new AssertionError("Closure invalid");
+		
 		output.writeUInt(ExpressionEncoding.TYPE_CAPTURED_PARAMETER);
 		int flags = getFlags(expression);
 		serialize(flags, expression);
 
 	@Override
 	public Void visitCapturedThis(StatementContext context, CapturedThisExpression expression) {
+		if (expression.closure != context.getLambdaClosure())
+			throw new AssertionError("Closure invalid");
+		
 		output.writeUInt(ExpressionEncoding.TYPE_CAPTURED_THIS);
 		int flags = getFlags(expression);
 		serialize(flags, expression);
 		serialize(flags, expression);
 		
 		output.serialize(context, expression.condition);
+		output.serialize(context, expression.type);
 		output.serialize(context, expression.ifThen);
 		output.serialize(context, expression.ifElse);
 		return null;
 		int flags = getFlags(expression);
 		serialize(flags, expression);
 		
+		output.serialize(context, expression.constant.getType());
 		output.write(context, expression.constant);
 		return null;
 	}
 		int flags = getFlags(expression);
 		serialize(flags, expression);
 		
+		output.serialize(context, expression.field.getType());
 		output.write(context, expression.field);
 		return null;
 	}
 		serialize(flags, expression);
 		
 		output.writeString(expression.name);
+		output.serialize(context, expression.resolution);
 		return null;
 	}
 
 		
 		output.writeString(expression.name);
 		output.serialize(context, expression.arguments);
+		output.serialize(context, expression.resolution);
 		return null;
 	}
 
 	public Void visitMatch(StatementContext context, MatchExpression expression) {
 		output.writeUInt(ExpressionEncoding.TYPE_MATCH);
 		int flags = getFlags(expression);
+		if (localVariableNames)
+			flags |= ExpressionEncoding.FLAG_NAMES;
 		serialize(flags, expression);
 		
 		output.serialize(context, expression.value);
+		output.serialize(context, expression.type);
 		output.writeUInt(expression.cases.length);
 		for (MatchExpression.Case case_ : expression.cases) {
 			output.serialize(context, case_.key);
 		int flags = getFlags(expression);
 		serialize(flags, expression);
 		
+		output.serialize(context, expression.constructor.getOwnerType());
 		output.write(context, expression.constructor);
 		output.serialize(context, expression.arguments);
 		return null;
 		output.writeUInt(ExpressionEncoding.TYPE_NULL);
 		int flags = getFlags(expression);
 		serialize(flags, expression);
+		output.serialize(context, expression.type);
 		return null;
 	}
 
 		serialize(flags, expression);
 		
 		output.serialize(context, expression.value);
+		output.serialize(context, expression.type);
 		return null;
 	}
 
 	public Void visitSameObject(StatementContext context, SameObjectExpression expression) {
 		output.writeUInt(ExpressionEncoding.TYPE_SAME_OBJECT);
 		int flags = getFlags(expression);
+		if (expression.inverted)
+			flags |= ExpressionEncoding.FLAG_INVERTED;
 		serialize(flags, expression);
 		
 		output.serialize(context, expression.left);
 		int flags = getFlags(expression);
 		serialize(flags, expression);
 		
-		output.serialize(context, expression.value);
 		output.serialize(context, expression.type);
+		output.serialize(context, expression.value);
 		return null;
 	}
 
 		int flags = getFlags(expression);
 		serialize(flags, expression);
 		
+		output.serialize(context, expression.type);
 		output.serialize(context, expression.value);
 		return null;
 	}
 		int flags = getFlags(expression);
 		serialize(flags, expression);
 		
+		output.serialize(context, expression.type);
 		output.serialize(context, expression.value);
 		return null;
 	}
 		int flags = getFlags(expression);
 		serialize(flags, expression);
 		
+		output.serialize(context, expression.type);
+		output.serialize(context, expression.thrownType);
 		output.serialize(context, expression.value);
 		return null;
 	}
 		int flags = getFlags(expression);
 		serialize(flags, expression);
 		
+		output.serialize(context, expression.type);
 		output.serialize(context, expression.value);
 		return null;
 	}
 		int flags = getFlags(expression);
 		serialize(flags, expression);
 		
+		output.serialize(context, expression.option.variant);
 		output.write(expression.option);
-		output.writeUInt(expression.arguments.length);
 		for (Expression argument : expression.arguments)
 			output.serialize(context, argument);
 		return null;

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/encoder/MemberSerializer.java

 		
 		int flags = getFlags(member);
 		serialize(flags, member);
-		output.serialize(context, member.header);
+		
+		StatementContext inner = new StatementContext(context, member.header);
+		output.serialize(inner, member.header);
 		
 		output.enqueueCode(encoder -> {
-			encoder.serialize(new StatementContext(context, member.header), member.body);
+			encoder.serialize(inner, member.body);
 		});
 		return null;
 	}
 		output.writeUInt(MemberEncoding.TYPE_METHOD);
 		int flags = getFlags(member);
 		serialize(flags, member);
-		output.serialize(context, member.header);
+		
+		StatementContext inner = new StatementContext(context, member.header);
+		output.serialize(inner, member.header);
 		
 		output.enqueueCode(encoder -> {
-			encoder.write(context, member.getOverrides());
-			encoder.serialize(new StatementContext(context, member.header), member.body);
+			encoder.write(inner, member.getOverrides());
+			encoder.serialize(inner, member.body);
 		});
 		return null;
 	}
 		int flags = getFlags(member);
 		serialize(flags, member);
 		output.writeUInt(getId(member.operator));
-		output.serialize(context, member.header);
+		
+		StatementContext inner = new StatementContext(context, member.header);
+		output.serialize(inner, member.header);
 		
 		output.enqueueCode(encoder -> {
-			encoder.write(context, member.getOverrides());
-			encoder.serialize(new StatementContext(context, member.header), member.body);
+			encoder.write(inner, member.getOverrides());
+			encoder.serialize(inner, member.body);
 		});
 		return null;
 	}
 		output.writeUInt(MemberEncoding.TYPE_CALLER);
 		int flags = getFlags(member);
 		serialize(flags, member);
-		output.serialize(context, member.header);
+		
+		StatementContext inner = new StatementContext(context, member.header);
+		output.serialize(inner, member.header);
 		
 		output.enqueueCode(encoder -> {
-			encoder.write(context, member.getOverrides());
-			encoder.serialize(new StatementContext(context, member.header), member.body);
+			encoder.write(inner, member.getOverrides());
+			encoder.serialize(inner, member.body);
 		});
 		return null;
 	}
 
 	@Override
 	public Void visitInnerDefinition(TypeContext context, InnerDefinitionMember member) {
-		output.writeUInt(MemberEncoding.TYPE_INNER_DEFINITION);
-		int flags = getFlags(member);
-		serialize(flags, member);
-		
-		output.writeUInt(member.innerDefinition.members.size());
-		for (IDefinitionMember innerMember : member.innerDefinition.members) {
-			innerMember.accept(context, this);
-		}
+		// already serialized
 		return null;
 	}
 

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/encoder/StatementSerializer.java

 public class StatementSerializer implements StatementVisitorWithContext<StatementContext, Void> {
 	private final CodeSerializationOutput output;
 	private final boolean positions;
+	private final boolean localVariableNames;
 	
-	public StatementSerializer(CodeSerializationOutput output, boolean positions) {
+	public StatementSerializer(
+			CodeSerializationOutput output,
+			boolean positions,
+			boolean localVariableNames)
+	{
 		this.output = output;
 		this.positions = positions;
+		this.localVariableNames = localVariableNames;
 	}
 	
 	private int getFlags(Statement statement) {
 		int flags = getFlags(statement);
 		encode(flags, statement);
 		
-		output.writeUInt(statement.statements.size());
+		output.writeUInt(statement.statements.length);
 		StatementContext inner = new StatementContext(context);
 		for (Statement s : statement.statements)
 			output.serialize(inner, s);
 	public Void visitDoWhile(StatementContext context, DoWhileStatement statement) {
 		output.writeUInt(StatementEncoding.TYPE_DO_WHILE);
 		int flags = getFlags(statement);
+		if (statement.label != null)
+			flags |= StatementEncoding.FLAG_LABEL;
 		encode(flags, statement);
 		
 		output.serialize(context, statement.condition);
+		if ((flags & StatementEncoding.FLAG_LABEL) > 0)
+			output.writeString(statement.label);
 		StatementContext inner = new StatementContext(context, statement);
 		output.serialize(inner, statement.content);
 		return null;
 	public Void visitForeach(StatementContext context, ForeachStatement statement) {
 		output.writeUInt(StatementEncoding.TYPE_FOREACH);
 		int flags = getFlags(statement);
+		if (localVariableNames)
+			flags |= StatementEncoding.FLAG_NAME;
 		encode(flags, statement);
 		output.serialize(context, statement.list);
 		output.write(context, statement.iterator);
-		output.writeUInt(statement.loopVariables.length);
-		for (VarStatement loopVariable : statement.loopVariables)
-			output.writeString(loopVariable.name);
+		if ((flags & StatementEncoding.FLAG_NAME) > 0) {
+			for (VarStatement loopVariable : statement.loopVariables)
+				output.writeString(loopVariable.name);
+		}
 		StatementContext inner = new StatementContext(context, statement);
+		for (VarStatement variable : statement.loopVariables)
+			inner.add(variable);
+		
 		output.serialize(inner, statement.content);
 		return null;
 	}
 	public Void visitSwitch(StatementContext context, SwitchStatement statement) {
 		output.writeUInt(StatementEncoding.TYPE_RETURN);
 		int flags = getFlags(statement);
+		if (statement.label != null)
+			flags |= StatementEncoding.FLAG_LABEL;
+		if (localVariableNames)
+			flags |= StatementEncoding.FLAG_NAME;
 		encode(flags, statement);
+		
 		output.serialize(context, statement.value);
+		if ((flags & StatementEncoding.FLAG_LABEL) > 0)
+			output.writeString(statement.label);
 		output.writeUInt(statement.cases.size());
 		
 		StatementContext inner = new StatementContext(context, statement);
 		for (SwitchCase case_ : statement.cases) {
 			output.serialize(context, case_.value);
-			output.writeUInt(case_.statements.size());
+			output.writeUInt(case_.statements.length);
 			for (Statement s : case_.statements) {
 				output.serialize(inner, s);
 			}
 		int flags = getFlags(statement);
 		if (statement.isFinal)
 			flags |= StatementEncoding.FLAG_FINAL;
+		if (statement.name != null && localVariableNames)
+			flags |= StatementEncoding.FLAG_NAME;
 		encode(flags, statement);
 		
 		output.serialize(context, statement.type);
-		output.writeString(statement.name);
+		if ((flags & StatementEncoding.FLAG_NAME) > 0)
+			output.writeString(statement.name);
 		output.serialize(context, statement.initializer);
 		
 		context.add(statement);
 	public Void visitWhile(StatementContext context, WhileStatement statement) {
 		output.writeUInt(StatementEncoding.TYPE_WHILE);
 		int flags = getFlags(statement);
+		if (statement.label != null)
+			flags |= StatementEncoding.FLAG_LABEL;
 		encode(flags, statement);
 		
 		output.serialize(context, statement.condition);
+		if ((flags & StatementEncoding.FLAG_LABEL) > 0)
+			output.writeString(statement.label);
 		output.serialize(new StatementContext(context, statement), statement.content);
 		return null;
 	}

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/encoder/SwitchValueSerializer.java

  */
 public class SwitchValueSerializer implements SwitchValueVisitorWithContext<TypeContext, Void> {
 	private final CodeSerializationOutput output;
+	private final boolean localVariableNames;
 	
-	public SwitchValueSerializer(CodeSerializationOutput output) {
+	public SwitchValueSerializer(CodeSerializationOutput output, boolean localVariableNames) {
 		this.output = output;
+		this.localVariableNames = localVariableNames;
 	}
 
 	@Override
 	public Void acceptVariantOption(TypeContext context, VariantOptionSwitchValue value) {
 		output.writeUInt(SwitchValueEncoding.TYPE_VARIANT_OPTION);
 		output.write(value.option);
-		output.writeUInt(value.parameters.length);
-		for (String parameter : value.parameters)
-			output.writeString(parameter);
+		if (localVariableNames) {
+			for (String parameter : value.parameters)
+				output.writeString(parameter);
+		}
 		return null;
 	}
 }

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/encoder/TypeSerializer.java

 			case CHAR: output.writeUInt(TypeEncoding.TYPE_CHAR); break;
 			case STRING: output.writeUInt(TypeEncoding.TYPE_STRING); break;
 			case UNDETERMINED: output.writeUInt(TypeEncoding.TYPE_UNDETERMINED); break;
+			case NULL: output.writeUInt(TypeEncoding.TYPE_NULL); break;
 			default: throw new IllegalArgumentException("Unknown basic type: " + basic);
 		}
 		return null;
 	public Void visitGenericMap(TypeContext context, GenericMapTypeID map) {
 		output.writeUInt(TypeEncoding.TYPE_GENERIC_MAP);
 		output.serialize(context, map.key);
-		map.value.accept(new TypeContext(context, new TypeParameter[] { map.key }), this);
+		map.value.accept(new TypeContext(context, context.thisType, new TypeParameter[] { map.key }), this);
 		return null;
 	}
 
 	@Override
 	public Void visitGeneric(TypeContext context, GenericTypeID generic) {
 		output.writeUInt(TypeEncoding.TYPE_GENERIC);
-		output.writeUInt(context.getId(generic.parameter));
+		int id = context.getId(generic.parameter);
+		if (id < 0)
+			throw new IllegalStateException("Type parameter not in scope: " + generic.parameter);
+		output.writeUInt(id);
 		return null;
 	}
 

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

 package org.openzen.zenscript.parser.statements;
 
-import java.util.ArrayList;
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.scope.BlockScope;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
 import org.openzen.zenscript.parser.ParsedAnnotation;
-import org.openzen.zenscript.parser.PrecompilationState;
 
 public class ParsedStatementBlock extends ParsedStatement {
 	private final List<ParsedStatement> statements;
 	@Override
 	public Statement compile(StatementScope scope) {
 		StatementScope blockScope = new BlockScope(scope);
-		List<Statement> compiled = new ArrayList<>();
+		Statement[] compiled = new Statement[statements.size()];
+		int i = 0;
 		for (ParsedStatement statement : statements) {
-			compiled.add(statement.compile(blockScope));
+			compiled[i++] = statement.compile(blockScope);
 		}
 		BlockStatement block = new BlockStatement(position, compiled);
 		result(block, scope);

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
-import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.expression.ParsedExpression;
 
 /**
 	
 	public SwitchCase compile(ITypeID type, StatementScope scope) {
 		SwitchValue cValue = value == null ? null : value.compileToSwitchValue(type, new ExpressionScope(scope));
-		List<Statement> cStatements = new ArrayList<>();
+		Statement[] cStatements = new Statement[statements.size()];
+		int i = 0;
 		for (ParsedStatement statement : statements) {
-			cStatements.add(statement.compile(scope));
+			cStatements[i++] = statement.compile(scope);
 		}
 		return new SwitchCase(cValue, cStatements);
 	}

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

 			return new PartialMemberGroupExpression(
 					position,
 					scope,
-					new GetStaticFieldExpression(position, new FieldMemberRef(SYSTEM_OUT, GenericMapper.EMPTY)),
+					new GetStaticFieldExpression(position, new FieldMemberRef(scope.getTypeRegistry().getForMyDefinition(SYSTEM), SYSTEM_OUT, GenericMapper.EMPTY)),
 					"println",
-					PRINTSTREAM_PRINTLN.ref(GenericMapper.EMPTY),
+					PRINTSTREAM_PRINTLN.ref(scope.getTypeRegistry().getForDefinition(PRINTSTREAM), GenericMapper.EMPTY),
 					null,
 					false);
 		}

Shared/src/main/java/compactio/CompactBytesDataInput.java

     }
     
     @Override
-    public byte readByte() {
-        return (byte)(data[offset++]);
+    public int readByte() {
+        return (data[offset++]) & 0xFF;
     }
     
     @Override
-    public int readSByte() {
+    public byte readSByte() {
         return data[offset++];
     }
     
         boolean[] result = new boolean[size];
         int limitForI = (size + 7) / 8;
         for (int i = 0; i < limitForI; i++) {
-            byte bvalue = this.readByte();
+            int bvalue = this.readByte();
             int remainingBits = result.length - 8 * i;
             if (remainingBits > 0)
                 result[i * 8 + 0] = (bvalue & (byte)1) > (byte)0;

Shared/src/main/java/compactio/CompactDataInput.java

 public interface CompactDataInput extends AutoCloseable {
     boolean readBool();
     
-    byte readByte();
+    int readByte();
     
-    int readSByte();
+    byte readSByte();
     
     short readShort();