Continue work on the deserializer and fix serialization and deserialization bugs

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

  * @author Hoofdgebruiker
  */
 public interface DecodingOperation {
-	void decode(CodeSerializationInput input);
+	void decode(CodeSerializationInput input) throws DeserializationException;
 }

ModuleDeserializer/src/main/java/org/openzen/zenscript/moduledeserializer/DeserializationException.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/serialization/DeserializationException.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.moduledeserializer;
+package org.openzen.zenscript.codemodel.serialization;
 
 /**
  *

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

 
 import java.io.File;
 import java.io.IOException;
-import java.util.Arrays;
 import javax.swing.JFrame;
 import org.openzen.drawablegui.DUIWindow;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
 import org.openzen.zenscript.ide.host.local.LocalProjectDevelopmentHost;
 import org.openzen.drawablegui.swing.SwingWindow;
-import org.openzen.zenscript.compiler.CompilationUnit;
-import org.openzen.zenscript.constructor.ModuleLoader;
 import org.openzen.zenscript.constructor.Project;
 import org.openzen.zenscript.ide.host.IDEPropertyDirectory;
 import org.openzen.zenscript.ide.host.IDEPropertyStore;

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

 
 	@Override
 	public int readInt() {
-		return input.readInt();
+		return input.readVarInt();
 	}
 
 	@Override
 	public int readUInt() {
-		return input.readUInt();
+		return input.readVarUInt();
 	}
 
 	@Override
 	public long readLong() {
-		return input.readLong();
+		return input.readVarLong();
 	}
 
 	@Override
 	public long readULong() {
-		return input.readULong();
+		return input.readVarULong();
 	}
 	
 	@Override
 
 	@Override
 	public String readString() {
-		return strings[input.readUInt()];
+		int index = input.readVarUInt();
+		if (index >= strings.length)
+			throw new RuntimeException("Invalid string id");
+		
+		return strings[index];
 	}
 
 	@Override
 	public HighLevelDefinition readDefinition() {
-		return definitions.get(input.readUInt());
+		return definitions.get(input.readVarUInt());
 	}
 
 	@Override
 
 	@Override
 	public CodePosition deserializePosition() {
-		int flags = input.readVarUInt();
+		int flags = readUInt();
 		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_FILE) > 0) {
+			int fileIndex = input.readVarUInt();
+			if (fileIndex >= sourceFiles.length)
+				throw new IllegalArgumentException("Invalid file index: " + fileIndex);
+			
+			file = sourceFiles[fileIndex];
+		}
 		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();
+		int toLine = lastPosition.toLine;
+		if ((flags & CodePositionEncoding.FLAG_TO_LINE) > 0)
+			toLine = fromLine + input.readVarUInt();
+		int toLineOffset = lastPosition.toLineOffset;
+		if ((flags & CodePositionEncoding.FLAG_TO_OFFSET) > 0)
+			toLineOffset = input.readVarUInt();
 		return lastPosition = new CodePosition(file, fromLine, fromLineOffset, toLine, toLineOffset);
 	}
-
+	
 	@Override
 	public FunctionHeader deserializeHeader(TypeContext context) {
 		TypeParameter[] typeParameters = TypeParameter.NONE;
 			result[i] = new TypeParameter(position, name);
 		}
 		
+		if (currentStage == code || currentStage == members) {
+			readTypeParameterBounds(context, allflags, result);
+		} else {
+			members.enqueue(input -> readTypeParameterBounds(context, allflags, result));
+		}
+		
+		return result;
+	}
+	
+	private void readTypeParameterBounds(TypeContext context, int[] allFlags, TypeParameter[] result) {
 		TypeContext inner = new TypeContext(context, context.thisType, result);
 		for (int i = 0; i < result.length; i++) {
-			int flags = allflags[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

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

 import org.openzen.zenscript.codemodel.serialization.DecodingOperation;
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zenscript.codemodel.serialization.DeserializationException;
 
 /**
  *
 	private final List<DecodingOperation> operations = new ArrayList<>();
 	private boolean locked = false;
 	
-	public void decode(CodeReader encoder) {
+	public void decode(CodeReader encoder) throws DeserializationException {
 		locked = true;
 		for (DecodingOperation operation : operations) {
 			operation.decode(encoder);

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

  */
 package org.openzen.zenscript.moduledeserializer;
 
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.OperatorType;
+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.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.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.NewExpression;
+import org.openzen.zenscript.codemodel.member.CallerMember;
+import org.openzen.zenscript.codemodel.member.CasterMember;
+import org.openzen.zenscript.codemodel.member.ConstMember;
+import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.DestructorMember;
+import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.member.GetterMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.ImplementationMember;
+import org.openzen.zenscript.codemodel.member.IteratorMember;
+import org.openzen.zenscript.codemodel.member.MethodMember;
+import org.openzen.zenscript.codemodel.member.OperatorMember;
+import org.openzen.zenscript.codemodel.member.SetterMember;
+import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
+import org.openzen.zenscript.codemodel.member.ref.CasterMemberRef;
+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.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.moduleserialization.MemberEncoding;
 
 /**
  *
 	public DefinitionMemberDeserializer(CodeReader reader) {
 		this.reader = reader;
 	}
+	
+	private void visit(TypeContext context, HighLevelDefinition definition) {
+		ITypeID superType = reader.deserializeType(context);
+		definition.setSuperType(superType);
+		
+		IDefinitionMember[] members = new IDefinitionMember[reader.readUInt()];
+		for (int i = 0; i < members.length; i++) {
+			IDefinitionMember member = deserializeMember(context, definition, superType);
+			if (member != null) {
+				definition.members.add(member);
+				reader.add(member);
+			}
+			members[i] = member;
+		}
+	}
+	
+	private CodePosition readPosition(int flags) {
+		if ((flags & MemberEncoding.FLAG_POSITION) == 0)
+			return CodePosition.UNKNOWN;
+		
+		return reader.deserializePosition();
+	}
+	
+	private String readName(int flags) {
+		if ((flags & MemberEncoding.FLAG_NAME) == 0)
+			return null;
+		
+		return reader.readString();
+	}
+	
+	private IDefinitionMember deserializeMember(TypeContext context, HighLevelDefinition definition, ITypeID supertype) {
+		int kind = reader.readUInt();
+		int flags = 0;
+		CodePosition position = CodePosition.UNKNOWN;
+		int modifiers = 0;
+		
+		if (kind != MemberEncoding.TYPE_INNER_DEFINITION) {
+			flags = reader.readUInt();
+			position = readPosition(flags);
+			modifiers = reader.readUInt();
+		}
+		
+		switch (kind) {
+			case MemberEncoding.TYPE_CONST: {
+				String name = readName(flags);
+				ITypeID type = reader.deserializeType(context);
+				
+				ConstMember result = new ConstMember(position, definition, modifiers, name, type, null);
+				reader.enqueueCode(reader -> result.value = reader.deserializeExpression(new StatementContext(context)));
+				return result;
+			}
+			case MemberEncoding.TYPE_FIELD: {
+				String name = readName(flags);
+				int autoGetterAccess = (flags & MemberEncoding.FLAG_AUTO_GETTER) > 0 ? reader.readUInt() : 0;
+				int autoSetterAccess = (flags & MemberEncoding.FLAG_AUTO_SETTER) > 0 ? reader.readUInt() : 0;
+				ITypeID type = reader.deserializeType(context);
+				
+				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;
+			}
+			case MemberEncoding.TYPE_CONSTRUCTOR: {
+				FunctionHeader header = reader.deserializeHeader(context);
+				ConstructorMember result = new ConstructorMember(position, definition, modifiers, header, null);
+				reader.enqueueCode(reader -> {
+					result.setBody(reader.deserializeStatement(new StatementContext(context, header)));
+				});
+				return result;
+			}
+			case MemberEncoding.TYPE_DESTRUCTOR: {
+				DestructorMember result = new DestructorMember(position, definition, modifiers);
+				reader.enqueueCode(reader -> {
+					result.overrides = (FunctionalMemberRef)reader.readMember(context, supertype);
+					result.setBody(reader.deserializeStatement(new StatementContext(context, result.header)));
+				});
+				return result;
+			}
+			case MemberEncoding.TYPE_METHOD: {
+				String name = readName(flags);
+				FunctionHeader header = reader.deserializeHeader(context);
+				MethodMember result = new MethodMember(position, definition, modifiers, name, header, null);
+				reader.enqueueCode(reader -> {
+					result.setOverrides(context.moduleContext.registry, (FunctionalMemberRef)reader.readMember(context, supertype));
+					result.setBody(reader.deserializeStatement(new StatementContext(context, header)));
+				});
+				return result;
+			}
+			case MemberEncoding.TYPE_GETTER: {
+				ITypeID type = reader.deserializeType(context);
+				String name = readName(flags);
+				
+				GetterMember result = new GetterMember(position, definition, modifiers, name, type, null);
+				reader.enqueueCode(reader -> {
+					result.setOverrides((GetterMemberRef)reader.readMember(context, supertype));
+					FunctionHeader header = new FunctionHeader(type);
+					result.setBody(reader.deserializeStatement(new StatementContext(context, header)));
+				});
+				return result;
+			}
+			case MemberEncoding.TYPE_SETTER: {
+				ITypeID type = reader.deserializeType(context);
+				String name = readName(flags);
+				
+				SetterMember result = new SetterMember(position, definition, modifiers, name, type, null);
+				reader.enqueueCode(reader -> {
+					result.setOverrides((SetterMemberRef)reader.readMember(context, supertype));
+					FunctionHeader header = new FunctionHeader(BasicTypeID.VOID, result.parameter);
+					result.setBody(reader.deserializeStatement(new StatementContext(context, header)));
+				});
+				return result;
+			}
+			case MemberEncoding.TYPE_OPERATOR: {
+				OperatorType operator = readOperator();
+				FunctionHeader header = reader.deserializeHeader(context);
+				
+				OperatorMember result = new OperatorMember(position, definition, modifiers, operator, header, null);
+				reader.enqueueCode(reader -> {
+					result.setOverrides(context.moduleContext.registry, (FunctionalMemberRef)reader.readMember(context, supertype));
+					result.setBody(reader.deserializeStatement(new StatementContext(context, header)));
+				});
+				return result;
+			}
+			case MemberEncoding.TYPE_CASTER: {
+				ITypeID toType = reader.deserializeType(context);
+				
+				CasterMember result = new CasterMember(position, definition, modifiers, toType, null);
+				reader.enqueueCode(reader -> {
+					result.setOverrides(context.moduleContext.registry, (CasterMemberRef)reader.readMember(context, supertype));
+					result.setBody(reader.deserializeStatement(new StatementContext(context, new FunctionHeader(toType))));
+				});
+				return result;
+			}
+			case MemberEncoding.TYPE_ITERATOR: {
+				ITypeID[] types = new ITypeID[reader.readUInt()];
+				for (int i = 0; i < types.length; i++)
+					types[i] = reader.deserializeType(context);
+				
+				IteratorMember result = new IteratorMember(position, definition, modifiers, types, context.moduleContext.registry, null);
+				reader.enqueueCode(reader -> {
+					result.setOverrides((IteratorMemberRef)reader.readMember(context, supertype));
+					result.setBody(reader.deserializeStatement(new StatementContext(context, result.header)));
+				});
+				return result;
+			}
+			case MemberEncoding.TYPE_CALLER: {
+				FunctionHeader header = reader.deserializeHeader(context);
+				CallerMember result = new CallerMember(position, definition, modifiers, header, null);
+				
+				reader.enqueueCode(reader -> {
+					result.setOverrides(context.moduleContext.registry, (FunctionalMemberRef)reader.readMember(context, supertype));
+					result.setBody(reader.deserializeStatement(new StatementContext(context, header)));
+				});
+				return result;
+			}
+			case MemberEncoding.TYPE_IMPLEMENTATION: {
+				ITypeID type = reader.deserializeType(context);
+				ImplementationMember result = new ImplementationMember(position, definition, modifiers, type);
+				
+				int members = reader.readUInt();
+				for (int i = 0; i < members; i++) {
+					IDefinitionMember member = deserializeMember(context, definition, type);
+					result.addMember(member);
+					reader.add(member);
+				}
+				
+				return result;
+			}
+			case MemberEncoding.TYPE_INNER_DEFINITION:
+				return null;
+			case MemberEncoding.TYPE_STATIC_INITIALIZER: {
+				StaticInitializerMember result = new StaticInitializerMember(position, definition);
+				reader.enqueueCode(reader -> {
+					result.body = reader.deserializeStatement(new StatementContext(context, new FunctionHeader(BasicTypeID.VOID)));
+				});
+				return result;
+			}
+			default:
+				throw new RuntimeException("Invalid member type: " + kind);
+		}
+	}
+	
+	private OperatorType readOperator() {
+		int operator = reader.readUInt();
+		switch (operator) {
+			case MemberEncoding.OPERATOR_ADD: return OperatorType.ADD;
+			case MemberEncoding.OPERATOR_SUB: return OperatorType.SUB;
+			case MemberEncoding.OPERATOR_MUL: return OperatorType.MUL;
+			case MemberEncoding.OPERATOR_DIV: return OperatorType.DIV;
+			case MemberEncoding.OPERATOR_MOD: return OperatorType.MOD;
+			case MemberEncoding.OPERATOR_CAT: return OperatorType.CAT;
+			case MemberEncoding.OPERATOR_OR: return OperatorType.OR;
+			case MemberEncoding.OPERATOR_XOR: return OperatorType.XOR;
+			case MemberEncoding.OPERATOR_NEG: return OperatorType.NEG;
+			case MemberEncoding.OPERATOR_INVERT: return OperatorType.INVERT;
+			case MemberEncoding.OPERATOR_NOT: return OperatorType.NOT;
+			case MemberEncoding.OPERATOR_INDEXSET: return OperatorType.INDEXSET;
+			case MemberEncoding.OPERATOR_INDEXGET: return OperatorType.INDEXGET;
+			case MemberEncoding.OPERATOR_CONTAINS: return OperatorType.CONTAINS;
+			case MemberEncoding.OPERATOR_COMPARE: return OperatorType.COMPARE;
+			case MemberEncoding.OPERATOR_MEMBERGETTER: return OperatorType.MEMBERGETTER;
+			case MemberEncoding.OPERATOR_MEMBERSETTER: return OperatorType.MEMBERSETTER;
+			case MemberEncoding.OPERATOR_EQUALS: return OperatorType.EQUALS;
+			case MemberEncoding.OPERATOR_NOTEQUALS: return OperatorType.NOTEQUALS;
+			case MemberEncoding.OPERATOR_SAME: return OperatorType.SAME;
+			case MemberEncoding.OPERATOR_NOTSAME: return OperatorType.NOTSAME;
+			case MemberEncoding.OPERATOR_SHL: return OperatorType.SHL;
+			case MemberEncoding.OPERATOR_SHR: return OperatorType.SHR;
+			case MemberEncoding.OPERATOR_USHR: return OperatorType.USHR;
+			
+			case MemberEncoding.OPERATOR_ADDASSIGN: return OperatorType.ADDASSIGN;
+			case MemberEncoding.OPERATOR_SUBASSIGN: return OperatorType.ADDASSIGN;
+			case MemberEncoding.OPERATOR_MULASSIGN: return OperatorType.ADDASSIGN;
+			case MemberEncoding.OPERATOR_DIVASSIGN: return OperatorType.ADDASSIGN;
+			case MemberEncoding.OPERATOR_MODASSIGN: return OperatorType.ADDASSIGN;
+			case MemberEncoding.OPERATOR_CATASSIGN: return OperatorType.ADDASSIGN;
+			case MemberEncoding.OPERATOR_ORASSIGN: return OperatorType.ADDASSIGN;
+			case MemberEncoding.OPERATOR_XORASSIGN: return OperatorType.ADDASSIGN;
+			case MemberEncoding.OPERATOR_SHLASSIGN: return OperatorType.ADDASSIGN;
+			case MemberEncoding.OPERATOR_SHRASSIGN: return OperatorType.ADDASSIGN;
+			case MemberEncoding.OPERATOR_USHRASSIGN: return OperatorType.ADDASSIGN;
+			
+			case MemberEncoding.OPERATOR_INCREMENT: return OperatorType.INCREMENT;
+			case MemberEncoding.OPERATOR_DECREMENT: return OperatorType.DECREMENT;
+			
+			case MemberEncoding.OPERATOR_RANGE: return OperatorType.RANGE;
+			
+			default: throw new RuntimeException("Invalid operator: " + operator);
+		}
+	}
 
 	@Override
 	public Void visitClass(TypeContext context, ClassDefinition definition) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		visit(context, definition);
+		return null;
 	}
 
 	@Override
 	public Void visitInterface(TypeContext context, InterfaceDefinition definition) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		visit(context, definition);
+		
+		int baseInterfaces = reader.readUInt();
+		for (int i = 0; i < baseInterfaces; i++)
+			definition.baseInterfaces.add(reader.deserializeType(context));
+		
+		return null;
 	}
 
 	@Override
 	public Void visitEnum(TypeContext context, EnumDefinition definition) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		visit(context, definition);
+		
+		int constants = reader.readUInt();
+		DefinitionTypeID type = context.moduleContext.registry.getForMyDefinition(definition);
+		StatementContext initContext = new StatementContext(context);
+		for (int i = 0; i < constants; i++) {
+			int flags = reader.readUInt();
+			String name = reader.readString();
+			CodePosition position = readPosition(flags);
+			
+			EnumConstantMember constant = new EnumConstantMember(position, definition, name, i);
+			reader.enqueueCode(input -> {
+				FunctionalMemberRef constructor = (FunctionalMemberRef)reader.readMember(context, type);
+				CallArguments arguments = reader.deserializeArguments(initContext);
+				constant.constructor = new NewExpression(position, type, constructor, arguments);
+			});
+			definition.enumConstants.add(constant);
+		}
+		
+		return null;
 	}
 
 	@Override
 	public Void visitStruct(TypeContext context, StructDefinition definition) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		visit(context, definition);
+		return null;
 	}
 
 	@Override
 	public Void visitFunction(TypeContext context, FunctionDefinition definition) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		visit(context, definition);
+		return null;
 	}
 
 	@Override
 	public Void visitExpansion(TypeContext context, ExpansionDefinition definition) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		visit(context, definition);
+		definition.target = reader.deserializeType(context);
+		return null;
 	}
 
 	@Override
 	public Void visitAlias(TypeContext context, AliasDefinition definition) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		definition.type = reader.deserializeType(context);
+		return null;
 	}
 
 	@Override
 	public Void visitVariant(TypeContext context, VariantDefinition variant) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		visit(context, variant);
+		
+		int options = reader.readUInt();
+		for (int i = 0; i < options; i++) {
+			String name = reader.readString();
+			ITypeID[] types = new ITypeID[reader.readUInt()];
+			for (int j = 0; j < types.length; j++)
+				types[i] = reader.deserializeType(context);
+			
+			variant.options.add(new VariantDefinition.Option(variant, name, i, types));
+		}
+		
+		return null;
 	}
 }

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

 
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.PackageDefinitions;
 import org.openzen.zenscript.codemodel.ScriptBlock;
 		this.annotations = annotations;
 		
 		expansions = new ArrayList<>();
-		context = new ModuleContext(registry, expansions, rootPackage);
+		context = new ModuleContext(registry, module, expansions, rootPackage);
 	}
 	
 	public DeserializingModule(SemanticModule module) 
 				expansions,
 				annotations);
 	}
+	
+	public void add(HighLevelDefinition definition) {
+		definitions.add(definition);
+	}
+	
+	public void add(ScriptBlock script) {
+		scripts.add(script);
+	}
 }

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

  */
 package org.openzen.zenscript.moduledeserializer;
 
+import org.openzen.zenscript.codemodel.serialization.DeserializationException;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;

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

  */
 package org.openzen.zenscript.moduledeserializer;
 
+import org.openzen.zenscript.codemodel.serialization.DeserializationException;
 import compactio.CompactBytesDataInput;
 import compactio.CompactDataInput;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 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.ScriptBlock;
 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;
+import org.openzen.zenscript.codemodel.definition.AliasDefinition;
 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
+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;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.member.InnerDefinitionMember;
 import org.openzen.zenscript.codemodel.serialization.CodeSerializationInput;
 import org.openzen.zenscript.codemodel.serialization.DecodingOperation;
+import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.compiler.CompilationUnit;
 import org.openzen.zenscript.compiler.ModuleRegistry;
 import org.openzen.zenscript.compiler.SemanticModule;
 				sourceFiles,
 				compilationUnit.globalTypeRegistry);
 		
-		DeserializingModule[] packagedModules = new DeserializingModule[input.readVarUInt()];
+		DeserializingModule[] packagedModules = new DeserializingModule[decoder.readUInt()];
 		String[][] dependencyNames = new String[packagedModules.length][];
 		for (int i = 0; i < packagedModules.length; i++) {
-			int flags = input.readVarUInt();
-			String name = input.readString();
+			int flags = decoder.readUInt();
+			String name = decoder.readString();
 			
 			ZSPackage modulePackage = rootPackage;
-			int packageNameParts = input.readVarUInt();
+			int packageNameParts = decoder.readUInt();
 			for (int j = 0; j < packageNameParts; j++)
-				modulePackage = modulePackage.getOrCreatePackage(input.readString());
+				modulePackage = modulePackage.getOrCreatePackage(decoder.readString());
 
-			DeserializingModule[] dependencies = new DeserializingModule[input.readVarUInt()];
+			DeserializingModule[] dependencies = new DeserializingModule[decoder.readUInt()];
 			String[] dependencyNames2 = new String[dependencies.length];
 			dependencyNames[i] = dependencyNames2;
 			for (int j = 0; j < dependencyNames2.length; j++)
-				dependencyNames2[j] = input.readString();
+				dependencyNames2[j] = decoder.readString();
 			
 			packagedModules[i] = new DeserializingModule(
 					name,
 			decoder.classes.enqueue(new ModuleDecodeClassesOperation(packagedModules[i], decoder));
 		}
 		
-		DeserializingModule[] allModules = Arrays.copyOf(packagedModules, input.readVarUInt());
+		DeserializingModule[] allModules = Arrays.copyOf(packagedModules, packagedModules.length + input.readVarUInt());
 		for (int i = packagedModules.length; i < allModules.length; i++) {
 			int flags = input.readVarUInt();
 			String name = input.readString();
 		}
 
 		@Override
-		public void decode(CodeSerializationInput input) {
+		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);
+				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) {
-			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 HighLevelDefinition deserializeDefinition(CodeReader reader, ModuleContext context, HighLevelDefinition outer) throws DeserializationException {
+		int type = reader.readUInt();
+		int flags = reader.readUInt();
+		CodePosition position = CodePosition.UNKNOWN;
+		String name = null;
+		TypeParameter[] typeParameters = TypeParameter.NONE;
+		int modifiers = reader.readUInt();
+		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));
+
+		HighLevelDefinition result;
+		switch (type) { 
+			case DefinitionEncoding.TYPE_CLASS:
+				result = new ClassDefinition(position, context.module, pkg, name, modifiers, outer);
+				break;
+			case DefinitionEncoding.TYPE_STRUCT:
+				result = new StructDefinition(position, context.module, pkg, name, modifiers, outer);
+				break;
+			case DefinitionEncoding.TYPE_INTERFACE:
+				result = new InterfaceDefinition(position, context.module, pkg, name, modifiers, outer);
+				break;
+			case DefinitionEncoding.TYPE_ENUM:
+				result = new EnumDefinition(position, context.module, pkg, name, modifiers, outer);
+				break;
+			case DefinitionEncoding.TYPE_VARIANT:
+				result = new VariantDefinition(position, context.module, pkg, name, modifiers, outer);
+				break;
+			case DefinitionEncoding.TYPE_FUNCTION:
+				result = new FunctionDefinition(position, context.module, pkg, name, modifiers, outer);
+				break;
+			case DefinitionEncoding.TYPE_ALIAS:
+				result = new AliasDefinition(position, context.module, pkg, name, modifiers, outer);
+				break;
+			case DefinitionEncoding.TYPE_EXPANSION:
+				result = new ExpansionDefinition(position, context.module, pkg, modifiers, outer);
+				break;
+			default:
+				throw new DeserializationException("Invalid definition type: " + type);
 		}
+		
+		result.typeParameters = typeParameters;
+		decodeMembers(reader, context, result);
+		reader.add(result);
+		return result;
 	}
 	
 	private void decodeMembers(
 			CodeReader reader,
 			ModuleContext moduleContext,
-			HighLevelDefinition definition)
+			HighLevelDefinition definition) throws DeserializationException
 	{
+		int innerClasses = reader.readUInt();
+		for (int i = 0; i < innerClasses; i++) {
+			CodePosition position = reader.deserializePosition();
+			int modifiers = reader.readUInt();
+			HighLevelDefinition inner = deserializeDefinition(reader, moduleContext, definition);
+			definition.addMember(new InnerDefinitionMember(position, inner, modifiers, definition));
+		}
+		
 		reader.enqueueMembers(input -> {
 			TypeContext context = new TypeContext(moduleContext, definition.typeParameters, moduleContext.registry.getForMyDefinition(definition));
-			definition.addMember(reader.deserializeMember(context));
+			DefinitionMemberDeserializer memberDeserializer = new DefinitionMemberDeserializer(reader);
+			definition.accept(context, memberDeserializer);
 		});
-		
-		int innerMembers = reader.readUInt();
-		
 	}
 	
 	private class ModuleDecodeScriptsOperation implements DecodingOperation {
 
 		@Override
 		public void decode(CodeSerializationInput input) {
-			
+			int numberOfScripts = input.readUInt();
+			for (int i = 0; i < numberOfScripts; i++) {
+				List<Statement> statements = new ArrayList<>();
+				StatementContext context = new StatementContext(module.context, null);
+				int numStatements = input.readUInt();
+				for (int j = 0; j < numStatements; j++)
+					statements.add(input.deserializeStatement(context));
+				
+				module.add(new ScriptBlock(rootPackage, statements));
+			}
 		}
 	}
 }

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

 	
 	public static final int FLAG_POSITION = 1;
 	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 TYPE_BUILTIN = 1;
 	public static final int TYPE_CONST = 2;

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

 	private final List<HighLevelDefinition> definitions = new ArrayList<>();
 	private final Map<HighLevelDefinition, Integer> definitionsMap = new HashMap<>();
 	
+	private final Map<IDefinitionMember, Integer> memberMap = new HashMap<>();
+	
 	public final EncodingStage classes = new EncodingStage();
 	public final EncodingStage members = new EncodingStage();
 	public final EncodingStage code = new EncodingStage();
 			CompactDataOutput output,
 			SerializationOptions options,
 			String[] strings,
-			SourceFile[] sourceFiles)
+			SourceFile[] sourceFiles,
+			List<IDefinitionMember> members)
 	{
 		this.output = output;
 		this.options = options;
 			stringMap.put(string, stringMap.size());
 		for (SourceFile sourceFile : sourceFiles)
 			sourceFileMap.put(sourceFile, sourceFileMap.size());
+		for (IDefinitionMember member : members)
+			memberMap.put(member, memberMap.size());
 	}
 	
 	public void startClasses() {
 			throw new IllegalStateException("members not yet available!");
 		
 		if (member == null) {
-			writeUInt(0);
+			writeInt(0);
 			return;
 		} else if (member.getTarget().getBuiltin() != null) {
-			writeUInt(1);
-			writeUInt(member.getTarget().getBuiltin().ordinal()); // TODO: use something else?
+			writeInt(-member.getTarget().getBuiltin().ordinal() - 1); // TODO: use something else?
 			return;
 		}
 		
 		IDefinitionMember member_ = member.getTarget();
-		EncodingDefinition definition = member_.getDefinition().getTag(EncodingDefinition.class);
-		
-		int index = definition.members.indexOf(member_);
-		if (index < 0)
+		Integer index = memberMap.get(member_);
+		if (index == null)
 			throw new IllegalStateException("Member not registered!");
-		output.writeVarUInt(index);
+		writeInt(index + 1);
 	}
 	
 	@Override
 	
 	@Override
 	public void serialize(TypeContext context, TypeParameter[] parameters) {
-		output.writeVarUInt(parameters.length);
+		writeUInt(parameters.length);
 		int[] flags = new int[parameters.length];
 		for (int i = 0; i < parameters.length; i++)
 			flags[i] = serializeInitial(parameters[i]);
+		
+		TypeContext inner = new TypeContext(context, context.thisType, parameters);
 		for (int i = 0; i < parameters.length; i++)
-			serializeRemaining(flags[i], context, parameters[i]);
+			serializeRemaining(flags[i], inner, parameters[i]);
 	}
 	
 	private int serializeInitial(TypeParameter parameter) {
 		if ((flags & TypeParameterEncoding.FLAG_POSITION) > 0)
 			serialize(parameter.position);
 		if ((flags & TypeParameterEncoding.FLAG_NAME) > 0)
-			output.writeString(parameter.name);
+			writeString(parameter.name);
 		
 		return flags;
 	}
 			for (TypeParameterBound bound : parameter.bounds)
 				bound.accept(context, typeParameterEncoder);
 		} else {
-			code.enqueue(encoder -> {
-				output.writeVarUInt(parameter.bounds.size());
-				for (TypeParameterBound bound : parameter.bounds)
-					bound.accept(context, typeParameterEncoder);
+			members.enqueue(encoder -> {
+				if ((flags & TypeParameterEncoding.FLAG_BOUNDS) > 0) {
+					output.writeVarUInt(parameter.bounds.size());
+					for (TypeParameterBound bound : parameter.bounds)
+						bound.accept(context, typeParameterEncoder);
+				}
 			});
 		}
 	}
 			flags |= FunctionHeaderEncoding.FLAG_TYPE_PARAMETERS;
 		if (header.getReturnType() != BasicTypeID.VOID)
 			flags |= FunctionHeaderEncoding.FLAG_RETURN_TYPE;
-		if (header.parameters.length > 0)
+		if (header.thrownType != null)
 			flags |= FunctionHeaderEncoding.FLAG_THROWS;
-		if (header.hasAnyDefaultValues())
+		if (header.parameters.length > 0)
 			flags |= FunctionHeaderEncoding.FLAG_PARAMETERS;
 		if (header.parameters.length > 0 && header.parameters[header.parameters.length - 1].variadic)
 			flags |= FunctionHeaderEncoding.FLAG_VARIADIC;
-		if (header.thrownType != null)
+		if (header.hasAnyDefaultValues())
 			flags |= FunctionHeaderEncoding.FLAG_DEFAULT_VALUES;
 		
 		writeUInt(flags);

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

 		this.definition = definition;
 	}
 	
-	public void mark(IDefinitionMember member) {
-		if (memberSet.add(member))
+	public boolean mark(IDefinitionMember member) {
+		if (memberSet.add(member)) {
 			members.add(member);
+			return true;
+		} else {
+			return false;
+		}
 	}
 	
 	public void mark(EnumConstantMember member) {

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

 		ModuleSerializer serializer = new ModuleSerializer(new SerializationOptions(
 				true,
 				false,
-				false,
+				true,
 				true,
 				false));
 		byte[] encoded = serializer.serialize(Collections.singletonList(module));

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

 import org.openzen.zenscript.moduleserializer.encoder.DefinitionSerializer;
 import org.openzen.zenscript.codemodel.context.StatementContext;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.serialization.CodeSerializationOutput;
 
 /**
 		
 		for (SemanticModule module : modules) {
 			EncodingModule encodedModule = tableBuilder.register(module.module, module.getContext());
-			ModuleContext moduleContext = new ModuleContext(module.compilationUnit.globalTypeRegistry, module.expansions, module.rootPackage);
+			ModuleContext moduleContext = module.getContext();
 			for (HighLevelDefinition definition : module.definitions.getAll()) {
 				encodedModule.add(EncodingDefinition.complete(definition));
 				tableBuilder.serialize(moduleContext, definition);
 		
 		SourceFile[] sourceFiles = tableBuilder.getSourceFileList();
 		String[] strings = tableBuilder.getStrings();
+		List<IDefinitionMember> members = tableBuilder.getMembers();
 		
 		CompactBytesDataOutput output = new CompactBytesDataOutput();
 		CodeWriter encoder = new CodeWriter(
 				output,
 				options,
 				strings,
-				sourceFiles);
+				sourceFiles,
+				members);
 		
 		output.writeInt(0x5A43424D); // 'ZCBM' = ZenCode Binary Module
 		output.writeVarUInt(0); // version
 		for (SourceFile file : sourceFiles)
 			output.writeString(file.getFilename());
 		
-		output.writeVarUInt(encodingModules.size());
+		encoder.writeUInt(encodingModules.size());
 		System.out.println("Encoding list of modules");
 		for (int i = 0; i < encodingModules.size(); i++) {
 			EncodingModule encodingModule = encodingModules.get(i);
 			SemanticModule module = modules.get(i);
 			
 			int flags = ModuleEncoding.FLAG_CODE;
-			output.writeVarUInt(flags);
-			output.writeString(encodingModule.getName());
+			encoder.writeUInt(flags);
+			encoder.writeString(encodingModule.getName());
 			String[] packageName = getPackageName(module.modulePackage);
-			output.writeStringArray(packageName);
+			encoder.writeUInt(packageName.length);
+			for (String element : packageName)
+				encoder.writeString(element);
 			
-			output.writeVarUInt(module.dependencies.length);
+			encoder.writeUInt(module.dependencies.length);
 			for (SemanticModule dependency : module.dependencies)
-				output.writeString(dependency.name);
+				encoder.writeString(dependency.name);
 			
-			ModuleContext moduleContext = new ModuleContext(
-					module.compilationUnit.globalTypeRegistry,
-					module.expansions,
-					module.rootPackage);
+			ModuleContext moduleContext = module.getContext();
 			encoder.code.enqueue(new ModuleEncodeScriptsOperation(moduleContext, module.scripts));
 			encoder.classes.enqueue(new ModuleEncodeClassesOperation(options, encodingModule, encoder));
 		}
 		
-		output.writeVarUInt(tableBuilder.modules.size() - encodingModules.size()); // number of modules defined (first is always the current module)
+		encoder.writeUInt(tableBuilder.modules.size() - encodingModules.size()); // number of modules defined (first is always the current module)
 		for (int i = encodingModules.size(); i < tableBuilder.modules.size(); i++) {
 			EncodingModule encodingModule = tableBuilder.modules.get(i);
 			System.out.println("Encoding dependency module " + encodingModule.getName());
 			
-			output.writeVarUInt(0);
-			output.writeString(encodingModule.getName());
+			encoder.writeUInt(0);
+			encoder.writeString(encodingModule.getName());
 			encoder.classes.enqueue(new ModuleEncodeClassesOperation(options, encodingModule, encoder));
 		}
 		
 		System.out.println("Encoding code");
 		encoder.startCode();
 		encoder.code.encode(encoder);
+		
 		return output.asByteArray();
 	}
 	

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

 	private final Set<Module> moduleSet = new HashSet<>();
 	private final Set<SourceFile> sourceFiles = new HashSet<>();
 	public final List<EncodingModule> modules = new ArrayList<>();
+	private final List<IDefinitionMember> members = new ArrayList<>();
 	
 	private final SerializationOptions options;
 	
 		return result;
 	}
 	
+	public List<IDefinitionMember> getMembers() {
+		return members;
+	}
+	
 	private EncodingDefinition prepare(HighLevelDefinition definition) {
 		register(definition.module, null);
 		
 
 	@Override
 	public void write(TypeContext context, DefinitionMemberRef member) {
-		if (member != null)
-			prepare(member.getTarget().getDefinition()).mark(member.getTarget());
+		if (member != null && member.getTarget().getBuiltin() == null) {
+			if (prepare(member.getTarget().getDefinition()).mark(member.getTarget()))
+				members.add(member.getTarget());
+		}
 	}
 
 	@Override
 	
 	@Override
 	public void serialize(TypeContext context, TypeParameter[] parameters) {
+		TypeContext inner = new TypeContext(context, context.thisType, parameters);
 		for (TypeParameter parameter : parameters)
-			serialize(context, parameter);
+			serialize(inner, parameter);
 	}
 
 	@Override

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

 
 	@Override
 	public Void visitClass(TypeContext context, ClassDefinition definition) {
-		output.writeUInt(DefinitionEncoding.TYPE_CLASS);
 		visit(context, definition);
 		return null;
 	}
 
 	@Override
 	public Void visitInterface(TypeContext context, InterfaceDefinition definition) {
-		output.writeUInt(DefinitionEncoding.TYPE_INTERFACE);
 		visit(context, definition);
 		
 		output.writeUInt(definition.baseInterfaces.size());
 
 	@Override
 	public Void visitEnum(TypeContext context, EnumDefinition definition) {
-		output.writeUInt(DefinitionEncoding.TYPE_ENUM);
 		visit(context, definition);
 		
 		output.writeUInt(definition.enumConstants.size());
 
 	@Override
 	public Void visitStruct(TypeContext context, StructDefinition definition) {
-		output.writeUInt(DefinitionEncoding.TYPE_STRUCT);
 		visit(context, definition);
 		return null;
 	}
 
 	@Override
 	public Void visitFunction(TypeContext context, FunctionDefinition definition) {
-		output.writeUInt(DefinitionEncoding.TYPE_FUNCTION);
 		visit(context, definition);
 		return null;
 	}
 
 	@Override
 	public Void visitExpansion(TypeContext context, ExpansionDefinition definition) {
-		output.writeUInt(DefinitionEncoding.TYPE_EXPANSION);
 		visit(context, definition);
+		output.serialize(context, definition.target);
 		return null;
 	}
 
 	@Override
 	public Void visitAlias(TypeContext context, AliasDefinition definition) {
-		output.writeUInt(DefinitionEncoding.TYPE_ALIAS);
-		
 		EncodingDefinition encoding = definition.getTag(EncodingDefinition.class);
 		for (DefinitionAnnotation annotation : definition.annotations) {
 			// TODO: how to serialize annotations?
 
 	@Override
 	public Void visitVariant(TypeContext context, VariantDefinition variant) {
-		output.writeUInt(DefinitionEncoding.TYPE_VARIANT);
 		visit(context, variant);
 		
 		output.writeUInt(variant.options.size());

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

 		if (definition.name != null)
 			output.writeString(definition.name);
 		if (definition.typeParameters.length > 0) {
-			output.writeUInt(definition.typeParameters.length);
 			TypeContext typeContext = new TypeContext(context, TypeParameter.NONE, null);
 			output.serialize(typeContext, definition.typeParameters);
 		}
 			if ((member instanceof InnerDefinitionMember))
 				innerDefinitions.add((InnerDefinitionMember)member);
 		
+		output.writeUInt(innerDefinitions.size());
+		for (InnerDefinitionMember innerDefinition : innerDefinitions) {
+			System.out.println("Inner definition: " + innerDefinition.definition.name);
+			output.serialize(innerDefinition.position);
+			output.writeUInt(innerDefinition.modifiers);
+			innerDefinition.innerDefinition.accept(moduleContext, this);
+		}
+		
 		output.enqueueMembers(output -> {
 			DefinitionMemberSerializer memberEncoder = new DefinitionMemberSerializer(options, output);
 			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

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

 		
 		output.writeUInt(member.getModifiers());
 	}
+	
+	private void writeName(int flags, String name) {
+		if ((flags & MemberEncoding.FLAG_NAME) > 0)
+			output.writeString(name);
+	}
 
 	@Override
 	public Void visitConst(TypeContext context, ConstMember member) {
 		int flags = getFlags(member);
 		if (member.name != null)
 			flags |= MemberEncoding.FLAG_NAME;
+		if (member.autoGetterAccess != 0)
+			flags |= MemberEncoding.FLAG_AUTO_GETTER;
+		if (member.autoSetterAccess != 0)
+			flags |= MemberEncoding.FLAG_AUTO_SETTER;
 		
 		serialize(flags, member);
-		if ((flags & MemberEncoding.FLAG_NAME) > 0)
-			output.writeString(member.name);
+		writeName(flags, member.name);
+		if ((flags & MemberEncoding.FLAG_AUTO_GETTER) > 0)
+			output.writeUInt(member.autoGetterAccess);
+		if ((flags & MemberEncoding.FLAG_AUTO_SETTER) > 0)
+			output.writeUInt(member.autoSetterAccess);
 		
 		output.serialize(context, member.type);
 		output.enqueueCode(encoder -> encoder.serialize(new StatementContext(context), member.initializer));
 	public Void visitMethod(TypeContext context, MethodMember member) {
 		output.writeUInt(MemberEncoding.TYPE_METHOD);
 		int flags = getFlags(member);
+		if (member.name != null)
+			flags |= MemberEncoding.FLAG_NAME;
 		serialize(flags, member);
+		writeName(flags, member.name);
 		
 		StatementContext inner = new StatementContext(context, member.header);
 		output.serialize(inner, member.header);
 	public Void visitGetter(TypeContext context, GetterMember member) {
 		output.writeUInt(MemberEncoding.TYPE_GETTER);
 		int flags = getFlags(member);
+		if (member.name != null)
+			flags |= MemberEncoding.FLAG_NAME;
 		serialize(flags, member);
 		output.serialize(context, member.type);
+		writeName(flags, member.name);
 		
 		output.enqueueCode(encoder -> {
 			encoder.write(context, member.getOverrides());
 		int flags = getFlags(member);
 		serialize(flags, member);
 		output.serialize(context, member.type);
+		writeName(flags, member.name);
 		
 		output.enqueueCode(encoder -> {
 			encoder.write(context, member.getOverrides());
 			encoder.serialize(new StatementContext(
 					context,
-					new FunctionHeader(BasicTypeID.VOID, member.type)),
+					new FunctionHeader(BasicTypeID.VOID, member.parameter)),
 					member.body);
 		});
 		return null;
 		output.enqueueCode(encoder -> {
 			encoder.write(context, member.getOverrides());
 			encoder.serialize(
-					new StatementContext(context, new FunctionHeader(new IteratorTypeID(null, member.getLoopVariableTypes()))),
+					new StatementContext(context, member.header),
 					member.body);
 		});
 		return null;