- Annotations are now serializable

- Fixed various serialization bugs, continuing work on serializer

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

 public interface Annotation {
 	public static final Annotation[] NONE = new Annotation[0];
 	
+	public AnnotationDefinition getDefinition();
+	
 	public void apply();
 }

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 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.expression.CallArguments;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.serialization.CodeSerializationInput;
 import org.openzen.zenscript.codemodel.statement.Statement;
 
 /**
 	public StatementAnnotation createForStatement(CodePosition position, CallArguments arguments);
 	
 	public Annotation createForParameter(CodePosition position, CallArguments arguments);
+	
+	public MemberAnnotation deserializeForMember(CodeSerializationInput input, TypeContext context, IDefinitionMember member);
+	
+	public DefinitionAnnotation deserializeForDefinition(CodeSerializationInput input, TypeContext context);
+	
+	public StatementAnnotation deserializeForStatement(CodeSerializationInput input, StatementContext context);
+	
+	public Annotation deserializeForParameter(CodeSerializationInput input, TypeContext context);
 }

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

 package org.openzen.zenscript.codemodel.annotations;
 
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.TypeContext;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.serialization.CodeSerializationOutput;
 
 /**
  *
 public interface DefinitionAnnotation {
 	public static final DefinitionAnnotation[] NONE = new DefinitionAnnotation[0];
 	
+	public AnnotationDefinition getDefinition();
+	
 	public void apply(HighLevelDefinition definition, BaseScope scope);
 	
 	public void applyOnSubtype(HighLevelDefinition definition, BaseScope scope);
+	
+	public void serialize(CodeSerializationOutput output, HighLevelDefinition definition, TypeContext context);
 }

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

  */
 package org.openzen.zenscript.codemodel.annotations;
 
+import org.openzen.zenscript.codemodel.context.TypeContext;
 import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.serialization.CodeSerializationOutput;
 
 /**
  *
 public interface MemberAnnotation {
 	public static final MemberAnnotation[] NONE = new MemberAnnotation[0];
 	
+	public AnnotationDefinition getDefinition();
+	
 	public void apply(IDefinitionMember member, BaseScope scope);
 	
 	public void applyOnOverridingMethod(FunctionalMember member, BaseScope scope);
 	public void applyOnOverridingGetter(GetterMember member, BaseScope scope);
 	
 	public void applyOnOverridingSetter(SetterMember member, BaseScope scope);
+	
+	public void serialize(CodeSerializationOutput output, IDefinitionMember member, TypeContext context);
 }

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 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.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.serialization.CodeSerializationInput;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 	public Annotation createForParameter(CodePosition position, CallArguments arguments) {
 		throw new UnsupportedOperationException("Not supported");
 	}
+
+	@Override
+	public MemberAnnotation deserializeForMember(CodeSerializationInput input, TypeContext context, IDefinitionMember member) {
+		String name = input.readString();
+		return new NativeMemberAnnotation(name);
+	}
+
+	@Override
+	public DefinitionAnnotation deserializeForDefinition(CodeSerializationInput input, TypeContext context) {
+		String name = input.readString();
+		return new NativeDefinitionAnnotation(name);
+	}
+
+	@Override
+	public StatementAnnotation deserializeForStatement(CodeSerializationInput input, StatementContext context) {
+		throw new UnsupportedOperationException("Not supported");
+	}
+
+	@Override
+	public Annotation deserializeForParameter(CodeSerializationInput input, TypeContext context) {
+		throw new UnsupportedOperationException("Not supported");
+	}
 }

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

 package org.openzen.zenscript.codemodel.annotations;
 
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.TypeContext;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.serialization.CodeSerializationOutput;
 
 /**
  *
 	public NativeDefinitionAnnotation(String identifier) {
 		this.identifier = identifier;
 	}
+
+	@Override
+	public AnnotationDefinition getDefinition() {
+		return NativeAnnotationDefinition.INSTANCE;
+	}
 	
 	@Override
 	public void apply(HighLevelDefinition definition, BaseScope scope) {
 	public void applyOnSubtype(HighLevelDefinition definition, BaseScope scope) {
 		// this annotation is not inherited
 	}
+
+	@Override
+	public void serialize(CodeSerializationOutput output, HighLevelDefinition definition, TypeContext context) {
+		output.writeString(identifier);
+	}
 }

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

  */
 package org.openzen.zenscript.codemodel.annotations;
 
+import org.openzen.zenscript.codemodel.context.TypeContext;
 import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.serialization.CodeSerializationOutput;
 
 /**
  *
 	public NativeMemberAnnotation(String identifier) {
 		this.identifier = identifier;
 	}
+
+	@Override
+	public AnnotationDefinition getDefinition() {
+		return NativeAnnotationDefinition.INSTANCE;
+	}
 	
 	@Override
 	public void apply(IDefinitionMember member, BaseScope scope) {
 	public void applyOnOverridingSetter(SetterMember member, BaseScope scope) {
 		// not inherited
 	}
+
+	@Override
+	public void serialize(CodeSerializationOutput output, IDefinitionMember member, TypeContext context) {
+		output.writeString(identifier);
+	}
 }

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 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.FunctionDefinition;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.scope.FunctionScope;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.serialization.CodeSerializationInput;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
 	public Annotation createForParameter(CodePosition position, CallArguments arguments) {
 		throw new UnsupportedOperationException("Not supported");
 	}
+
+	@Override
+	public MemberAnnotation deserializeForMember(CodeSerializationInput input, TypeContext context, IDefinitionMember member) {
+		CodePosition position = input.deserializePosition();
+		String enforcement = input.readString();
+		StatementContext statementContext = new StatementContext(context, member.getHeader());
+		Expression condition = input.deserializeExpression(statementContext);
+		Expression message = input.deserializeExpression(statementContext);
+		return new PreconditionForMethod(position, enforcement, condition, message);
+	}
+
+	@Override
+	public DefinitionAnnotation deserializeForDefinition(CodeSerializationInput input, TypeContext context) {
+		throw new UnsupportedOperationException("Not supported");
+	}
+
+	@Override
+	public StatementAnnotation deserializeForStatement(CodeSerializationInput input, StatementContext context) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Annotation deserializeForParameter(CodeSerializationInput input, TypeContext context) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
 }

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

 import java.util.Arrays;
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.context.StatementContext;
+import org.openzen.zenscript.codemodel.context.TypeContext;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionBuilder;
 import org.openzen.zenscript.codemodel.expression.PanicExpression;
 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.serialization.CodeSerializationOutput;
 import org.openzen.zenscript.codemodel.statement.BlockStatement;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 import org.openzen.zenscript.codemodel.statement.IfStatement;
 		this.condition = condition;
 		this.message = message;
 	}
+	
+	@Override
+	public AnnotationDefinition getDefinition() {
+		return PreconditionAnnotationDefinition.INSTANCE;
+	}
 
 	@Override
 	public void apply(IDefinitionMember member, BaseScope scope) {
 		}
 		return new BlockStatement(position, statements.toArray(new Statement[statements.size()]));
 	}
+
+	@Override
+	public void serialize(CodeSerializationOutput output, IDefinitionMember member, TypeContext context) {
+		output.serialize(position);
+		output.writeString(enforcement);
+		StatementContext statementContext = new StatementContext(context, member.getHeader());
+		output.serialize(statementContext, condition);
+		output.serialize(statementContext, message);
+	}
 }

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

 public interface StatementAnnotation {
 	public static final StatementAnnotation[] NONE = new StatementAnnotation[0];
 	
+	public AnnotationDefinition getDefinition();
+	
 	public Statement apply(Statement statement, StatementScope scope);
 }

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

 package org.openzen.zenscript.codemodel.member;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
 	public DefinitionMemberRef ref(ITypeID type, GenericMapper mapper) {
 		return new ConstMemberRef(type, this, mapper);
 	}
+	
+	@Override
+	public FunctionHeader getHeader() {
+		return null;
+	}
 }

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

 package org.openzen.zenscript.codemodel.member;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
 	public DefinitionMemberRef ref(ITypeID type, GenericMapper mapper) {
 		return new FieldMemberRef(type, this, mapper);
 	}
+	
+	@Override
+	public FunctionHeader getHeader() {
+		return null;
+	}
 }

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

 	public boolean isAbstract() {
 		return body == null && builtin == null;
 	}
+	
+	@Override
+	public FunctionHeader getHeader() {
+		return header;
+	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.ConcatMap;
+import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 	public DefinitionMemberRef ref(ITypeID type, GenericMapper mapper) {
 		return new GetterMemberRef(type, this, mapper);
 	}
+	
+	@Override
+	public FunctionHeader getHeader() {
+		return new FunctionHeader(type);
+	}
 }

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

 package org.openzen.zenscript.codemodel.member;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	
 	public int getModifiers();
 	
+	public MemberAnnotation[] getAnnotations();
+	
 	public HighLevelDefinition getDefinition();
 	
 	public String describe();
 	boolean isAbstract();
 	
 	DefinitionMemberRef ref(ITypeID type, GenericMapper mapper);
+	
+	FunctionHeader getHeader();
 }

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

 import java.util.ArrayList;
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 	public DefinitionMemberRef ref(ITypeID type, GenericMapper mapper) {
 		throw new UnsupportedOperationException("Cannot create an implementation reference");
 	}
+
+	@Override
+	public FunctionHeader getHeader() {
+		return null;
+	}
 }

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

 package org.openzen.zenscript.codemodel.member;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
-import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 	public DefinitionMemberRef ref(ITypeID type, GenericMapper mapper) {
 		throw new UnsupportedOperationException("Cannot create an inner definition reference");
 	}
+	
+	@Override
+	public FunctionHeader getHeader() {
+		return null;
+	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.ConcatMap;
+import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 	public DefinitionMemberRef ref(ITypeID type, GenericMapper mapper) {
 		return new SetterMemberRef(type, this, mapper);
 	}
+	
+	@Override
+	public FunctionHeader getHeader() {
+		return new FunctionHeader(BasicTypeID.VOID, type);
+	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.ConcatMap;
+import org.openzen.zenscript.codemodel.FunctionHeader;
 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.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 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.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 	public DefinitionMemberRef ref(ITypeID type, GenericMapper mapper) {
 		throw new UnsupportedOperationException("Cannot reference a static initializer");
 	}
+	
+	@Override
+	public FunctionHeader getHeader() {
+		return new FunctionHeader(BasicTypeID.VOID);
+	}
 }

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.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 	
 	VariantOptionRef readVariantOption(TypeContext context, ITypeID type);
 	
+	AnnotationDefinition readAnnotationType();
+	
 	ITypeID deserializeType(TypeContext context);
 	
 	CodePosition deserializePosition();

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 	
 	void write(TypeContext context, DefinitionMemberRef member);
 	
+	void write(AnnotationDefinition annotationType);
+	
 	void serialize(TypeContext context, IDefinitionMember member);
 	
 	void serialize(TypeContext context, ITypeID type);

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

 public class Arguments {
 	public final File projectDirectory;
 	
-	public Arguments(String[] arguments) {
-		File projectDir = new File("../../ZenCode"); // TODO: remove this and open a project chooser/creator instead
+	public Arguments(String[] arguments, File defaultProjectDir) {
+		File projectDir = defaultProjectDir;
 		int positional = 0;
 		for (int i = 0; i < arguments.length; i++) {
 			switch (positional) {

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

      * @param args the command line arguments
      */
     public static void main(String[] args) throws IOException {
-		Arguments arguments = new Arguments(args);
+		Arguments arguments = new Arguments(args, new File("../../ZenCode")); // TODO: remove this and open a project chooser/creator instead
 		File directory = arguments.projectDirectory;
 		
 		Project project = new Project(directory);

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

      * @param args the command line arguments
      */
     public static void main(String[] args) throws IOException {
-		Arguments arguments = new Arguments(args);
+		Arguments arguments = new Arguments(args, new File("../../ZenCode")); // TODO: remove this and open a project chooser/creator instead
 		File directory = arguments.projectDirectory;
 		
 		Project project = new Project(directory);

ModuleDeserializer/src/main/java/org/openzen/zenscript/moduledeserializer/CodeReader.java

 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.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.context.StatementContext;
 import org.openzen.zenscript.codemodel.context.TypeContext;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 	
 	private final String[] strings;
 	private final SourceFile[] sourceFiles;
+	private final AnnotationDefinition[] annotations;
 	private final List<HighLevelDefinition> definitions = new ArrayList<>();
 	private final List<IDefinitionMember> memberList = new ArrayList<>();
 	private final List<EnumConstantMember> enumConstantMembers = new ArrayList<>();
 			CompactDataInput input,
 			String[] strings,
 			SourceFile[] sourceFiles,
+			AnnotationDefinition[] annotations,
 			GlobalTypeRegistry registry)
 	{
 		this.input = input;
 		
 		this.strings = strings;
 		this.sourceFiles = sourceFiles;
+		this.annotations = annotations;
 		this.registry = registry;
 	}
 	
 
 	@Override
 	public HighLevelDefinition readDefinition() {
-		return definitions.get(input.readVarUInt());
+		int id = input.readVarUInt();
+		if (id == 0)
+			return null;
+		
+		HighLevelDefinition definition = definitions.get(id - 1);
+		return definition;
 	}
 
 	@Override
 	public VariantOptionRef readVariantOption(TypeContext context, ITypeID type) {
 		return variantOptions.get(readUInt()).instance(type, context.getMapper());
 	}
+	
+	@Override
+	public AnnotationDefinition readAnnotationType() {
+		return annotations[readUInt()];
+	}
 
 	@Override
 	public ITypeID deserializeType(TypeContext context) {
 			fromLine = input.readVarUInt();
 		if ((flags & CodePositionEncoding.FLAG_FROM_OFFSET) > 0)
 			fromLineOffset = input.readVarUInt();
-		int toLine = lastPosition.toLine;
+		int toLine = fromLine;
 		if ((flags & CodePositionEncoding.FLAG_TO_LINE) > 0)
 			toLine = fromLine + input.readVarUInt();
 		int toLineOffset = lastPosition.toLineOffset;

ModuleDeserializer/src/main/java/org/openzen/zenscript/moduledeserializer/DefinitionMemberDeserializer.java

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
+import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.context.StatementContext;
 import org.openzen.zenscript.codemodel.context.TypeContext;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.ConstMember;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.DefinitionMember;
 import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 			modifiers = reader.readUInt();
 		}
 		
+		DefinitionMember member;
 		switch (kind) {
 			case MemberEncoding.TYPE_CONST: {
 				String name = readName(flags);
 				
 				ConstMember result = new ConstMember(position, definition, modifiers, name, type, null);
 				reader.enqueueCode(reader -> result.value = reader.deserializeExpression(new StatementContext(context)));
-				return result;
+				member = result;
+				break;
 			}
 			case MemberEncoding.TYPE_FIELD: {
 				String name = readName(flags);
 				
 				FieldMember result = new FieldMember(position, definition, flags, name, context.thisType, type, context.moduleContext.registry, autoGetterAccess, autoSetterAccess, null);
 				reader.enqueueCode(reader -> result.initializer = reader.deserializeExpression(new StatementContext(context)));
-				return result;
+				member = result;
+				break;
 			}
 			case MemberEncoding.TYPE_CONSTRUCTOR: {
 				FunctionHeader header = reader.deserializeHeader(context);
 				reader.enqueueCode(reader -> {
 					result.setBody(reader.deserializeStatement(new StatementContext(context, header)));
 				});
-				return result;
+				member = result;
+				break;
 			}
 			case MemberEncoding.TYPE_DESTRUCTOR: {
 				DestructorMember result = new DestructorMember(position, definition, modifiers);
 					result.overrides = (FunctionalMemberRef)reader.readMember(context, supertype);
 					result.setBody(reader.deserializeStatement(new StatementContext(context, result.header)));
 				});
-				return result;
+				member = result;
+				break;
 			}
 			case MemberEncoding.TYPE_METHOD: {
 				String name = readName(flags);
 					result.setOverrides(context.moduleContext.registry, (FunctionalMemberRef)reader.readMember(context, supertype));
 					result.setBody(reader.deserializeStatement(new StatementContext(context, header)));
 				});
-				return result;
+				member = result;
+				break;
 			}
 			case MemberEncoding.TYPE_GETTER: {
 				ITypeID type = reader.deserializeType(context);
 					FunctionHeader header = new FunctionHeader(type);
 					result.setBody(reader.deserializeStatement(new StatementContext(context, header)));
 				});
-				return result;
+				member = result;
+				break;
 			}
 			case MemberEncoding.TYPE_SETTER: {
 				ITypeID type = reader.deserializeType(context);
 					FunctionHeader header = new FunctionHeader(BasicTypeID.VOID, result.parameter);
 					result.setBody(reader.deserializeStatement(new StatementContext(context, header)));
 				});
-				return result;
+				member = result;
+				break;
 			}
 			case MemberEncoding.TYPE_OPERATOR: {
 				OperatorType operator = readOperator();
 					result.setOverrides(context.moduleContext.registry, (FunctionalMemberRef)reader.readMember(context, supertype));
 					result.setBody(reader.deserializeStatement(new StatementContext(context, header)));
 				});
-				return result;
+				member = result;
+				break;
 			}
 			case MemberEncoding.TYPE_CASTER: {
 				ITypeID toType = reader.deserializeType(context);
 					result.setOverrides(context.moduleContext.registry, (CasterMemberRef)reader.readMember(context, supertype));
 					result.setBody(reader.deserializeStatement(new StatementContext(context, new FunctionHeader(toType))));
 				});
-				return result;
+				member = result;
+				break;
 			}
 			case MemberEncoding.TYPE_ITERATOR: {
 				ITypeID[] types = new ITypeID[reader.readUInt()];
 					result.setOverrides((IteratorMemberRef)reader.readMember(context, supertype));
 					result.setBody(reader.deserializeStatement(new StatementContext(context, result.header)));
 				});
-				return result;
+				member = result;
+				break;
 			}
 			case MemberEncoding.TYPE_CALLER: {
 				FunctionHeader header = reader.deserializeHeader(context);
 					result.setOverrides(context.moduleContext.registry, (FunctionalMemberRef)reader.readMember(context, supertype));
 					result.setBody(reader.deserializeStatement(new StatementContext(context, header)));
 				});
-				return result;
+				member = result;
+				break;
 			}
 			case MemberEncoding.TYPE_IMPLEMENTATION: {
 				ITypeID type = reader.deserializeType(context);
 				
 				int members = reader.readUInt();
 				for (int i = 0; i < members; i++) {
-					IDefinitionMember member = deserializeMember(context, definition, type);
-					result.addMember(member);
-					reader.add(member);
+					IDefinitionMember imember = deserializeMember(context, definition, type);
+					result.addMember(imember);
+					reader.add(imember);
 				}
 				
-				return result;
+				member = result;
+				break;
 			}
 			case MemberEncoding.TYPE_INNER_DEFINITION:
 				return null;
 				reader.enqueueCode(reader -> {
 					result.body = reader.deserializeStatement(new StatementContext(context, new FunctionHeader(BasicTypeID.VOID)));
 				});
-				return result;
+				member = result;
+				break;
 			}
 			default:
 				throw new RuntimeException("Invalid member type: " + kind);
 		}
+		
+		if ((flags & MemberEncoding.FLAG_ANNOTATIONS) > 0) {
+			reader.enqueueCode(input -> {
+				MemberAnnotation[] annotations = new MemberAnnotation[input.readUInt()];
+				for (int i = 0; i < annotations.length; i++) {
+					AnnotationDefinition type = input.readAnnotationType();
+					annotations[i] = type.deserializeForMember(input, context, member);
+				}
+				member.annotations = annotations;
+			});
+			
+		}
+		return member;
 	}
 	
 	private OperatorType readOperator() {

ModuleDeserializer/src/main/java/org/openzen/zenscript/moduledeserializer/ModuleDeserializer.java

 		for (int i = 0; i < sourceFiles.length; i++)
 			sourceFiles[i] = new VirtualSourceFile(input.readString());
 		
+		AnnotationDefinition[] annotations = new AnnotationDefinition[input.readVarUInt()];
+		for (int i = 0; i < annotations.length; i++) {
+			String name = stringTable[input.readVarUInt()];
+			for (AnnotationDefinition annotation : this.annotations)
+				if (annotation.getAnnotationName().equals(name))
+					annotations[i] = annotation;
+			
+			if (annotations[i] == null)
+				throw new DeserializationException("Annotation type not found: " + name);
+		}
+		
 		CodeReader decoder = new CodeReader(
 				input,
 				stringTable,
 				sourceFiles,
+				annotations,
 				compilationUnit.globalTypeRegistry);
 		
 		DeserializingModule[] packagedModules = new DeserializingModule[decoder.readUInt()];
 		@Override
 		public void decode(CodeSerializationInput input) throws DeserializationException {
 			int numDefinitions = input.readUInt();
-			DefinitionMemberDeserializer memberDeserializer = new DefinitionMemberDeserializer(reader);
 			for (int i = 0; i < numDefinitions; i++) {
 				HighLevelDefinition definition = deserializeDefinition(reader, module.context, null);
 				reader.add(definition);
 				module.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, HighLevelDefinition outer) throws DeserializationException {
 		int type = reader.readUInt();
 		int flags = reader.readUInt();

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

 	public static final int FLAG_POSITION = 1;
 	public static final int FLAG_NAME = 2;
 	public static final int FLAG_TYPE_PARAMETERS = 4;
+	public static final int FLAG_ANNOTATIONS = 8;
 	
 	public static final int TYPE_CLASS = 1;
 	public static final int TYPE_STRUCT = 2;

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

 	public static final int FLAG_NAME = 2;
 	public static final int FLAG_AUTO_GETTER = 4;
 	public static final int FLAG_AUTO_SETTER = 8;
+	public static final int FLAG_ANNOTATIONS = 16;
 	
 	public static final int TYPE_BUILTIN = 1;
 	public static final int TYPE_CONST = 2;

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
 public class CodeWriter implements CodeSerializationOutput {
 	private final Map<String, Integer> stringMap = new HashMap<>();
 	private final Map<SourceFile, Integer> sourceFileMap = new HashMap<>();
-	
-	private final List<HighLevelDefinition> definitions = new ArrayList<>();
+	private final Map<AnnotationDefinition, Integer> annotationMap = new HashMap<>();
 	private final Map<HighLevelDefinition, Integer> definitionsMap = new HashMap<>();
 	
 	private final Map<IDefinitionMember, Integer> memberMap = new HashMap<>();
 			SerializationOptions options,
 			String[] strings,
 			SourceFile[] sourceFiles,
-			List<IDefinitionMember> members)
+			HighLevelDefinition[] definitions,
+			List<IDefinitionMember> members,
+			AnnotationDefinition[] annotations)
 	{
 		this.output = output;
 		this.options = options;
 			stringMap.put(string, stringMap.size());
 		for (SourceFile sourceFile : sourceFiles)
 			sourceFileMap.put(sourceFile, sourceFileMap.size());
+		for (HighLevelDefinition definition : definitions)
+			definitionsMap.put(definition, definitionsMap.size());
 		for (IDefinitionMember member : members)
 			memberMap.put(member, memberMap.size());
+		for (AnnotationDefinition annotation : annotations)
+			annotationMap.put(annotation, annotationMap.size());
 	}
 	
 	public void startClasses() {
 		currentStage = code;
 	}
 	
-	public void add(HighLevelDefinition definition) {
-		definitions.add(definition);
-		definitionsMap.put(definition, definitions.size());
-	}
-	
 	public void add(SourceFile file) {
 		sourceFileMap.put(file, sourceFileMap.size());
 	}
 		if (!definitionsMap.containsKey(definition))
 			throw new IllegalStateException("Definition not yet prepared: " + definition.name);
 		
-		output.writeVarUInt(definitionsMap.get(definition) + 1);
+		int id = definitionsMap.get(definition) + 1;
+		output.writeVarUInt(id);
 	}
 	
 	@Override
 		writeUInt(definition.getTag(EncodingDefinition.class).variantOptions.indexOf(option));
 	}
 	
+	@Override
+	public void write(AnnotationDefinition annotationType) {
+		writeUInt(annotationMap.get(annotationType));
+	}
+	
 	@Override
 	public void serialize(TypeContext context, ITypeID type) {
 		if (type == null) {
 	
 	private void serializeRemaining(int flags, TypeContext context, TypeParameter parameter) {
 		if (currentStage == code || currentStage == members) {
-			output.writeVarUInt(parameter.bounds.size());
-			for (TypeParameterBound bound : parameter.bounds)
-				bound.accept(context, typeParameterEncoder);
+			if ((flags & TypeParameterEncoding.FLAG_BOUNDS) > 0) {
+				writeUInt(parameter.bounds.size());
+				for (TypeParameterBound bound : parameter.bounds)
+					bound.accept(context, typeParameterEncoder);
+			}
 		} else {
 			members.enqueue(encoder -> {
 				if ((flags & TypeParameterEncoding.FLAG_BOUNDS) > 0) {

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.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.context.ModuleContext;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.compiler.SemanticModule;
 			}
 		}
 		
+		List<HighLevelDefinition> definitions = new ArrayList<>();
+		for (EncodingModule module : tableBuilder.modules) {
+			for (EncodingDefinition definition : module.definitions)
+				definitions.add(definition.definition);
+		}
+		
+		for (AnnotationDefinition annotation : tableBuilder.getAnnotations())
+			tableBuilder.writeString(annotation.getAnnotationName());
+		
 		SourceFile[] sourceFiles = tableBuilder.getSourceFileList();
 		String[] strings = tableBuilder.getStrings();
 		List<IDefinitionMember> members = tableBuilder.getMembers();
+		AnnotationDefinition[] annotations = tableBuilder.getAnnotations();
 		
 		CompactBytesDataOutput output = new CompactBytesDataOutput();
 		CodeWriter encoder = new CodeWriter(
 				options,
 				strings,
 				sourceFiles,
-				members);
+				definitions.toArray(new HighLevelDefinition[definitions.size()]),
+				members,
+				annotations);
 		
 		output.writeInt(0x5A43424D); // 'ZCBM' = ZenCode Binary Module
 		output.writeVarUInt(0); // version
 		output.writeVarUInt(sourceFiles.length);
 		for (SourceFile file : sourceFiles)
 			output.writeString(file.getFilename());
+		output.writeVarUInt(annotations.length);
+		for (AnnotationDefinition annotation : annotations)
+			encoder.writeString(annotation.getAnnotationName());
 		
 		encoder.writeUInt(encodingModules.size());
 		System.out.println("Encoding list of modules");
 			for (EncodingDefinition definition : module.definitions) {
 				System.out.println("Encoding definition " + definition.definition.name);
 				definition.definition.accept(module.context, definitionEncoder);
-				encoder.add(definition.definition);
 			}
 		}
 	}

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.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.context.ModuleContext;
 import org.openzen.zenscript.codemodel.context.StatementContext;
 import org.openzen.zenscript.codemodel.context.TypeContext;
 	private final Set<SourceFile> sourceFiles = new HashSet<>();
 	public final List<EncodingModule> modules = new ArrayList<>();
 	private final List<IDefinitionMember> members = new ArrayList<>();
+	private final Set<AnnotationDefinition> annotations = new HashSet<>();
 	
 	private final SerializationOptions options;
 	
 		return members;
 	}
 	
+	public AnnotationDefinition[] getAnnotations() {
+		return annotations.toArray(new AnnotationDefinition[annotations.size()]);
+	}
+	
 	private EncodingDefinition prepare(HighLevelDefinition definition) {
 		register(definition.module, null);
 		
 				members.add(member.getTarget());
 		}
 	}
+	
+	@Override
+	public void write(AnnotationDefinition annotationType) {
+		annotations.add(annotationType);
+	}
 
 	@Override
 	public void serialize(TypeContext context, IDefinitionMember member) {

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

 	private EncodingDefinition visit(TypeContext context, HighLevelDefinition definition) {
 		EncodingDefinition encoding = definition.getTag(EncodingDefinition.class);
 		
-		for (DefinitionAnnotation annotation : definition.annotations) {
-			// TODO: how to serialize annotations?
-		}
-		
 		output.serialize(context, definition.getSuperType());
 		
 		output.writeUInt(encoding.members.size());

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

 import org.openzen.zenscript.codemodel.context.TypeContext;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.annotations.DefinitionAnnotation;
 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.InterfaceDefinition;
 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;
 			flags |= DefinitionEncoding.FLAG_NAME;
 		if (definition.typeParameters.length > 0)
 			flags |= DefinitionEncoding.FLAG_TYPE_PARAMETERS;
+		if (definition.annotations.length > 0)
+			flags |= DefinitionEncoding.FLAG_ANNOTATIONS;
 		
 		output.writeUInt(flags);
 		output.writeUInt(definition.modifiers);
 		output.writeString(definition.pkg.fullName);
 		if (definition.name != null)
 			output.writeString(definition.name);
-		if (definition.typeParameters.length > 0) {
-			TypeContext typeContext = new TypeContext(context, TypeParameter.NONE, null);
+		
+		TypeContext typeContext = new TypeContext(context, definition.typeParameters, null);
+		if (definition.typeParameters.length > 0)
 			output.serialize(typeContext, definition.typeParameters);
+		
+		if (definition.annotations.length > 0) {
+			output.enqueueCode(output -> {
+				output.writeUInt(definition.annotations.length);
+				for (DefinitionAnnotation annotation : definition.annotations) {
+					output.write(annotation.getDefinition());
+					annotation.serialize(output, definition, typeContext);
+				}
+			});
 		}
 	}
 	

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.ConstMember;
 import org.openzen.zenscript.codemodel.serialization.CodeSerializationOutput;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.IteratorTypeID;
 import org.openzen.zenscript.moduleserialization.MemberEncoding;
 import org.openzen.zenscript.moduleserializer.SerializationOptions;
 
 		int flags = 0;
 		if (member.getPosition() != CodePosition.UNKNOWN && options.positions)
 			flags |= MemberEncoding.FLAG_POSITION;
+		if (member.getAnnotations().length > 0)
+			flags |= MemberEncoding.FLAG_ANNOTATIONS;
 		
 		return flags;
 	}
 	
-	private void serialize(int flags, IDefinitionMember member) {
+	private void serialize(int flags, TypeContext context, IDefinitionMember member) {
 		output.writeUInt(flags);
 		if ((flags & MemberEncoding.FLAG_POSITION) > 0)
 			output.serialize(member.getPosition());
 		
 		output.writeUInt(member.getModifiers());
+		
+		if (member.getAnnotations().length > 0) {
+			output.enqueueCode(output -> {
+				output.writeUInt(member.getAnnotations().length);
+				for (MemberAnnotation annotation : member.getAnnotations()) {
+					output.write(annotation.getDefinition());
+					annotation.serialize(output, member, context);
+				}
+			});
+		}
 	}
 	
 	private void writeName(int flags, String name) {
 		if (member.name != null)
 			flags |= MemberEncoding.FLAG_NAME;
 		
-		serialize(flags, member);
+		serialize(flags, context, member);
 		if ((flags & MemberEncoding.FLAG_NAME) > 0)
 			output.writeString(member.name);
 		
 		if (member.autoSetterAccess != 0)
 			flags |= MemberEncoding.FLAG_AUTO_SETTER;
 		
-		serialize(flags, member);
+		serialize(flags, context, member);
 		writeName(flags, member.name);
 		if ((flags & MemberEncoding.FLAG_AUTO_GETTER) > 0)
 			output.writeUInt(member.autoGetterAccess);
 		output.writeUInt(MemberEncoding.TYPE_CONSTRUCTOR);
 		
 		int flags = getFlags(member);
-		serialize(flags, member);
+		serialize(flags, context, member);
 		
 		StatementContext inner = new StatementContext(context, member.header);
 		output.serialize(inner, member.header);
 	public Void visitDestructor(TypeContext context, DestructorMember member) {
 		output.writeUInt(MemberEncoding.TYPE_DESTRUCTOR);
 		int flags = getFlags(member);
-		serialize(flags, member);
+		serialize(flags, context, member);
 		
 		output.enqueueCode(encoder -> {
 			encoder.write(context, member.overrides);
 		int flags = getFlags(member);
 		if (member.name != null)
 			flags |= MemberEncoding.FLAG_NAME;
-		serialize(flags, member);
+		serialize(flags, context, member);
 		writeName(flags, member.name);
 		
 		StatementContext inner = new StatementContext(context, member.header);
 		int flags = getFlags(member);
 		if (member.name != null)
 			flags |= MemberEncoding.FLAG_NAME;
-		serialize(flags, member);
+		serialize(flags, context, member);
 		output.serialize(context, member.type);
 		writeName(flags, member.name);
 		
 	public Void visitSetter(TypeContext context, SetterMember member) {
 		output.writeUInt(MemberEncoding.TYPE_SETTER);
 		int flags = getFlags(member);
-		serialize(flags, member);
+		serialize(flags, context, member);
 		output.serialize(context, member.type);
 		writeName(flags, member.name);
 		
 	public Void visitOperator(TypeContext context, OperatorMember member) {
 		output.writeUInt(MemberEncoding.TYPE_OPERATOR);
 		int flags = getFlags(member);
-		serialize(flags, member);
+		serialize(flags, context, member);
 		output.writeUInt(getId(member.operator));
 		
 		StatementContext inner = new StatementContext(context, member.header);
 	public Void visitCaster(TypeContext context, CasterMember member) {
 		output.writeUInt(MemberEncoding.TYPE_CASTER);
 		int flags = getFlags(member);
-		serialize(flags, member);
+		serialize(flags, context, member);
 		output.serialize(context, member.toType);
 		
 		output.enqueueCode(encoder -> {
 	public Void visitIterator(TypeContext context, IteratorMember member) {
 		output.writeUInt(MemberEncoding.TYPE_ITERATOR);
 		int flags = getFlags(member);
-		serialize(flags, member);
+		serialize(flags, context, member);
 		output.writeUInt(member.getLoopVariableCount());
 		for (ITypeID type : member.getLoopVariableTypes())
 			output.serialize(context, type);
 	public Void visitCaller(TypeContext context, CallerMember member) {
 		output.writeUInt(MemberEncoding.TYPE_CALLER);
 		int flags = getFlags(member);
-		serialize(flags, member);
+		serialize(flags, context, member);
 		
 		StatementContext inner = new StatementContext(context, member.header);
 		output.serialize(inner, member.header);
 	public Void visitImplementation(TypeContext context, ImplementationMember member) {
 		output.writeUInt(MemberEncoding.TYPE_IMPLEMENTATION);
 		int flags = getFlags(member);
-		serialize(flags, member);
+		serialize(flags, context, member);
 		output.serialize(context, member.type);
 		
 		output.writeUInt(member.members.size());
 	public Void visitStaticInitializer(TypeContext context, StaticInitializerMember member) {
 		output.writeUInt(MemberEncoding.TYPE_STATIC_INITIALIZER);
 		int flags = getFlags(member);
-		serialize(flags, member);
+		serialize(flags, context, member);
 		
 		output.enqueueCode(encoder -> {
 			encoder.serialize(new StatementContext(context, new FunctionHeader(BasicTypeID.VOID)), member.body);