- Added support for zipped packages

- Simplified compilation process somewhat; removed CompilationUnit class and work more module-oriented instead

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

  */
 package org.openzen.zenscript.formatter;
 
-import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.ConstMember;
 		output.append("const")
 				.append(member.name)
 				.append(" as ")
-				.append(typeFormatter.format(member.type))
+				.append(typeFormatter.format(member.getType()))
 				.append(" = ")
 				.append(member.value.accept(new ExpressionFormatter(settings, typeFormatter, indent)))
 				.append(";\n");
 		output.append(member.isFinal() ? "val " : "var ")
 				.append(member.name)
 				.append(" as ")
-				.append(typeFormatter.format(member.type));
+				.append(typeFormatter.format(member.getType()));
 		
 		if (member.initializer != null) {
 			output.append(" = ")
 		output.append("get ");
 		output.append(member.name);
 		output.append(" as ");
-		output.append(typeFormatter.format(member.type));
+		output.append(typeFormatter.format(member.getType()));
 		formatBody(member.body);
 		return null;
 	}
 		output.append("set ");
 		output.append(member.name);
 		output.append(" as ");
-		output.append(typeFormatter.format(member.type));
+		output.append(typeFormatter.format(member.getType()));
 		formatBody(member.body);
 		return null;
 	}

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

 				isDestructible = true;
 			if (member instanceof FieldMember) {
 				FieldMember field = (FieldMember)member;
-				if (field.type.isDestructible(scanning))
+				if (field.getType().isDestructible(scanning))
 					isDestructible = true;
 			}
 			if ((member instanceof ImplementationMember) && ((ImplementationMember)member).type.isDestructible())

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

 			if (member.body == null)
 				return null;
 			
-			StatementScope scope = new FunctionScope(this.scope, new FunctionHeader(member.type));
+			StatementScope scope = new FunctionScope(this.scope, new FunctionHeader(member.getType()));
 			member.body = process(member.body, scope);
 			return null;
 		}

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 	private final ModuleTypeResolutionContext module;
 	private final CompilingPackage modulePackage;
 	private final Map<String, HighLevelDefinition> imports = new HashMap<>();
+	private final ZSPackage root;
 	
-	public FileResolutionContext(ModuleTypeResolutionContext module, CompilingPackage modulePackage) {
+	public FileResolutionContext(ModuleTypeResolutionContext module, ZSPackage root, CompilingPackage modulePackage) {
 		this.module = module;
+		this.root = root;
 		this.modulePackage = modulePackage;
 	}
 	
 	public void addImport(String name, HighLevelDefinition definition) {
+		if (definition == null)
+			throw new NullPointerException();
+		
 		imports.put(name, definition);
 	}
+	
+	@Override
+	public ZSPackage getRootPackage() {
+		return root;
+	}
 
 	@Override
 	public GlobalTypeRegistry getTypeRegistry() {
 	public TypeID getType(CodePosition position, List<GenericName> name) {
 		if (imports.containsKey(name.get(0).name)) {
 			HighLevelDefinition definition = imports.get(name.get(0).name);
-			if (definition.getNumberOfGenericParameters() != name.get(0).arguments.length)
+			if (definition.getNumberOfGenericParameters() != name.get(0).getNumberOfArguments())
 				return new InvalidTypeID(position, CompileExceptionCode.INVALID_TYPE_ARGUMENTS, "Invalid number of type arguments");
 			
 			return GenericName.getInnerType(
 					getTypeRegistry().getForDefinition(definition, name.get(0).arguments),
 					name,
 					1);
+		} else if (root.contains(name.get(0).name)) {
+			return root.getType(position, this, name);
 		}
 		
 		TypeID moduleType = modulePackage.getType(this, name);

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

 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
-import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *
 		this.type = type;
 		this.parameters = parameters;
 	}
+	
+	@Override
+	public ZSPackage getRootPackage() {
+		return outer.getRootPackage();
+	}
 
 	@Override
 	public GlobalTypeRegistry getTypeRegistry() {

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

 			this.storageTypes.put(storageType.getName(), storageType);
 	}
 	
+	@Override
+	public ZSPackage getRootPackage() {
+		return rootPackage;
+	}
+	
 	@Override
 	public GlobalTypeRegistry getTypeRegistry() {
 		return registry;

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
  * @author Hoofdgebruiker
  */
 public interface TypeResolutionContext {
+	ZSPackage getRootPackage();
+	
 	GlobalTypeRegistry getTypeRegistry();
 	
 	AnnotationDefinition getAnnotation(String name);

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

 	public ZSPackage(ZSPackage parent, String name) {
 		this.parent = parent;
 		this.name = name;
-		this.fullName = parent == null ? name : parent.fullName + "." + name;
+		this.fullName = parent == null || parent.fullName.isEmpty() ? name : parent.fullName + "." + name;
 	}
 	
 	private final Map<String, ZSPackage> subPackages = new HashMap<>();

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

 
 	@Override
 	public void normalize(TypeScope scope) {
-		type = type.getNormalized();
+		setType(getType().getNormalized());
 		value = value.normalize(scope);
 	}
 

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

 
 	@Override
 	public void normalize(TypeScope scope) {
-		type = type.getNormalized();
+		setType(getType().getNormalized());
 		if (initializer != null)
 			initializer = initializer.normalize(scope);
 	}

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

 	public void setBody(Statement body) {
 		this.body = body;
 		
-		if (type.type == BasicTypeID.UNDETERMINED)
-			type = body.getReturnType();
+		if (getType().type == BasicTypeID.UNDETERMINED) {
+			StoredType returnType = body.getReturnType();
+			if (returnType != null)
+				setType(returnType);
+		}
 	}
 	
 	@Override
 	public void setOverrides(GetterMemberRef override) {
 		this.overrides = override;
 		
-		if (type.type == BasicTypeID.UNDETERMINED)
-			type = override.getType();
+		if (getType().type == BasicTypeID.UNDETERMINED)
+			setType(override.getType());
 	}
 
 	@Override
 	
 	@Override
 	public FunctionHeader getHeader() {
-		return new FunctionHeader(type);
+		return new FunctionHeader(getType());
 	}
 }

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

  * @author Hoofdgebruiker
  */
 public abstract class PropertyMember extends DefinitionMember {
-	public StoredType type;
+	private StoredType type;
 	public final BuiltinID builtin;
 	
 	public PropertyMember(CodePosition position, HighLevelDefinition definition, int modifiers, StoredType type, BuiltinID builtin) {
 		super(position, definition, modifiers);
 		
+		if (type == null)
+			throw new NullPointerException();
+		
 		this.type = type;
 		this.builtin = builtin;
 	}
 		return type;
 	}
 	
+	public void setType(StoredType type) {
+		if (type == null)
+			throw new NullPointerException();
+		
+		this.type = type;
+	}
+	
 	@Override
 	public BuiltinID getBuiltin() {
 		return builtin;

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

 	public void setOverrides(SetterMemberRef overrides) {
 		this.overrides = overrides;
 		
-		if (type.type == BasicTypeID.UNDETERMINED) {
-			type = overrides.getType();
+		if (getType().type == BasicTypeID.UNDETERMINED) {
+			setType(overrides.getType());
 			parameter = new FunctionParameter(overrides.getType(), "value");
 		}
 	}
 	
 	@Override
 	public FunctionHeader getHeader() {
-		return new FunctionHeader(BasicTypeID.VOID, type);
+		return new FunctionHeader(BasicTypeID.VOID, getType());
 	}
 }

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

 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 		this.parent = parent;
 	}
 	
+	@Override
+	public ZSPackage getRootPackage() {
+		return parent.getRootPackage();
+	}
+	
 	@Override
 	public LocalMemberCache getMemberCache() {
 		return parent.getMemberCache();

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

 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 			for (TypeParameter parameter : parameters)
 				typeParameters.put(parameter.name, parameter);
 	}
+	
+	@Override
+	public ZSPackage getRootPackage() {
+		return outer.getRootPackage();
+	}
 
 	@Override
 	public LocalMemberCache getMemberCache() {

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

 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.TypeID;
-import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StaticExpressionStorageTag;
 
 /**
 		innerTypes.put(name, innerType);
 	}
 	
+	@Override
+	public ZSPackage getRootPackage() {
+		return outer.getRootPackage();
+	}
+	
 	@Override
 	public LocalMemberCache getMemberCache() {
 		return outer.getMemberCache();

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

 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 		return new ExpressionScope(outer, hints, dollar, genericInferenceMap, innerVariables);
 	}
 	
+	@Override
+	public ZSPackage getRootPackage() {
+		return outer.getRootPackage();
+	}
+	
 	@Override
 	public LocalMemberCache getMemberCache() {
 		return outer.getMemberCache();

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

 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.expression.InvalidExpression;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
  */
 public class FileScope extends BaseScope {
 	private final TypeResolutionContext context;
+	private final ZSPackage root;
 	private final LocalMemberCache memberCache;
 	private final Map<String, ISymbol> globals;
 	private final TypeMemberPreparer preparer;
 		this.context = context;
 		this.globals = globals;
 		this.preparer = preparer;
+		this.root = context.getRootPackage();
 		
 		memberCache = new LocalMemberCache(context.getTypeRegistry(), expansions);
 	}
 	
+	@Override
+	public ZSPackage getRootPackage() {
+		return root;
+	}
+	
 	@Override
 	public LocalMemberCache getMemberCache() {
 		return memberCache;
 		if (globals.containsKey(name.name)) {
 			IPartialExpression resolution = globals.get(name.name).getExpression(position, this, name.arguments);
 			return new PartialGlobalExpression(position, name.name, resolution, name.arguments);
+		} else if (root.contains(name.name)) {
+			try {
+				return root.getMember(position, context.getTypeRegistry(), name);
+			} catch (CompileException ex) {
+				return new InvalidExpression(BasicTypeID.UNDETERMINED.stored, ex);
+			}
 		}
 		
 		return null;

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

 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 		this.statement = statement;
 		this.outer = outer;
 	}
+	
+	@Override
+	public ZSPackage getRootPackage() {
+		return outer.getRootPackage();
+	}
 
 	@Override
 	public LocalMemberCache getMemberCache() {

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

 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 		typeParameterMap = outer.getLocalTypeParameters().getInner(outer.getTypeRegistry(), header.typeParameters);
 	}
 	
+	@Override
+	public ZSPackage getRootPackage() {
+		return outer.getRootPackage();
+	}
+	
 	@Override
 	public LocalMemberCache getMemberCache() {
 		return outer.getMemberCache();

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

 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 				this.parameters.put(parameter.name, parameter);
 	}
 	
+	@Override
+	public ZSPackage getRootPackage() {
+		return outer.getRootPackage();
+	}
+	
 	@Override
 	public LocalMemberCache getMemberCache() {
 		return outer.getMemberCache();

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

 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 	public GlobalScriptScope(BaseScope file) {
 		this.file = file;
 	}
+	
+	@Override
+	public ZSPackage getRootPackage() {
+		return file.getRootPackage();
+	}
 
 	@Override
 	public LocalMemberCache getMemberCache() {

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

 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 		
 		members = outer.getTypeMembers(implementation.type.stored(BorrowStorageTag.THIS));
 	}
+	
+	@Override
+	public ZSPackage getRootPackage() {
+		return outer.getRootPackage();
+	}
 
 	@Override
 	public LocalMemberCache getMemberCache() {

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

 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 		this.closure = closure;
 	}
 	
+	@Override
+	public ZSPackage getRootPackage() {
+		return outer.getRootPackage();
+	}
+	
 	@Override
 	public LocalMemberCache getMemberCache() {
 		return outer.getMemberCache();

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

 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 		this.statement = statement;
 		this.outer = outer;
 	}
+	
+	@Override
+	public ZSPackage getRootPackage() {
+		return outer.getRootPackage();
+	}
 
 	@Override
 	public LocalMemberCache getMemberCache() {

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

 		super(ex.position, null);
 		
 		this.code = ex.code;
-		this.message = ex.getMessage();
+		this.message = ex.message;
 	}
 
 	@Override

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

 					FunctionParameter[] parameters = new FunctionParameter[fields.size()];
 					for (int i = 0; i < parameters.length; i++) {
 						FieldMember field = fields.get(i);
-						parameters[i] = new FunctionParameter(field.type, field.name, field.initializer, false);
+						parameters[i] = new FunctionParameter(field.getType(), field.name, field.initializer, false);
 					}
 					
 					constructors.addMethod(new ConstructorMember(

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

 		if (toType.equals(value.type))
 			return value;
 		
-		if (!(toType.type instanceof StringTypeID))
-			System.out.println(position + ": " + value.type.getActualStorage() + " -> " + toType.getActualStorage());
+		//if (!(toType.type instanceof StringTypeID))
+		//	System.out.println(position + ": " + value.type.getActualStorage() + " -> " + toType.getActualStorage());
 		
 		return new StorageCastExpression(position, value, toType);
 	}

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

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.compiler;
-
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class CompilationUnit {
-	public final ZSPackage stdlib = new ZSPackage(null, "stdlib");
-	public final GlobalTypeRegistry globalTypeRegistry = new GlobalTypeRegistry(stdlib);
-	
-	public CompilationUnit() {
-		
-	}
-}

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

 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 	private final GlobalTypeRegistry globalRegistry;
 	private final List<ExpansionDefinition> expansions;
 	private final LocalMemberCache cache;
+	private final ZSPackage rootPackage;
 	private final Map<String, AnnotationDefinition> annotations = new HashMap<>();
 	private final Map<String, StorageType> storageTypes = new HashMap<>();
 	
-	public CompileScope(GlobalTypeRegistry globalRegistry, List<ExpansionDefinition> expansions, AnnotationDefinition[] annotations, StorageType[] storageTypes) {
+	public CompileScope(GlobalTypeRegistry globalRegistry, ZSPackage rootPackage, List<ExpansionDefinition> expansions, AnnotationDefinition[] annotations, StorageType[] storageTypes) {
 		this.globalRegistry = globalRegistry;
+		this.rootPackage = rootPackage;
 		this.expansions = expansions;
 		this.cache = new LocalMemberCache(globalRegistry, expansions);
 		
 		for (StorageType type : storageTypes)
 			this.storageTypes.put(type.getName(), type);
 	}
+	
+	@Override
+	public ZSPackage getRootPackage() {
+		return rootPackage;
+	}
 
 	@Override
 	public GlobalTypeRegistry getTypeRegistry() {

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

 import org.openzen.zenscript.codemodel.annotations.PreconditionAnnotationDefinition;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.codemodel.type.storage.StorageType;
 
  * @author Hoofdgebruiker
  */
 public final class ModuleSpace {
-	private final ZSPackage rootPackage = new ZSPackage(null, "");
-	public final CompilationUnit compilationUnit;
+	public final ZSPackage rootPackage = new ZSPackage(null, "");
+	public final GlobalTypeRegistry registry;
 	public final ZSPackage globalsPackage = new ZSPackage(null, "");
 	private final List<ExpansionDefinition> expansions = new ArrayList<>();
 	private final Map<String, ISymbol> globals = new HashMap<>();
 	private final AnnotationDefinition[] annotations;
 	private final StorageType[] storageTypes;
 	
-	public ModuleSpace(CompilationUnit compilationUnit, List<AnnotationDefinition> annotations, StorageType[] storageTypes) {
-		this.compilationUnit = compilationUnit;
+	public ModuleSpace(GlobalTypeRegistry registry, List<AnnotationDefinition> annotations, StorageType[] storageTypes) {
+		this.registry = registry;
 		
 		annotations.add(NativeAnnotationDefinition.INSTANCE);
 		annotations.add(PreconditionAnnotationDefinition.INSTANCE);

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

 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.scope.FileScope;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.codemodel.type.storage.StorageType;
 import org.openzen.zenscript.validator.ValidationLogEntry;
  * @author Hoofdgebruiker
  */
 public class SemanticModule {
+	public static final SemanticModule[] NONE = new SemanticModule[0];
+	
 	public final String name;
 	public final SemanticModule[] dependencies;
 	
 	public final List<ScriptBlock> scripts;
 	public final Map<String, ISymbol> globals = new HashMap<>();
 	
-	public final CompilationUnit compilationUnit;
+	public final GlobalTypeRegistry registry;
 	public final List<ExpansionDefinition> expansions;
 	public final AnnotationDefinition[] annotations;
 	public final StorageType[] storageTypes;
 	
 	public SemanticModule(
-			String name,
 			Module module,
 			SemanticModule[] dependencies,
 			State state,
 			ZSPackage modulePackage,
 			PackageDefinitions definitions,
 			List<ScriptBlock> scripts,
-			CompilationUnit compilationUnit,
+			GlobalTypeRegistry registry,
 			List<ExpansionDefinition> expansions,
 			AnnotationDefinition[] annotations,
 			StorageType[] storageTypes)
 	{
-		this.name = name;
+		this.name = module.name;
 		this.module = module;
 		this.dependencies = dependencies;
 		
 		this.definitions = definitions;
 		this.scripts = scripts;
 		
-		this.compilationUnit = compilationUnit;
+		this.registry = registry;
 		this.expansions = expansions;
 		this.annotations = annotations;
 		this.storageTypes = storageTypes;
 		if (state != State.ASSEMBLED)
 			throw new IllegalStateException("Module is invalid");
 		
-		ModuleTypeResolutionContext context = new ModuleTypeResolutionContext(compilationUnit.globalTypeRegistry, annotations, storageTypes, rootPackage, null, globals);
+		ModuleTypeResolutionContext context = new ModuleTypeResolutionContext(registry, annotations, storageTypes, rootPackage, null, globals);
 		AnnotationProcessor annotationProcessor = new AnnotationProcessor(context, expansions);
 		List<ScriptBlock> processedScripts = new ArrayList<>();
 		FileScope fileScope = new FileScope(context, expansions, globals, member -> {});
 		}
 		
 		return new SemanticModule(
-				name,
 				module,
 				dependencies,
 				State.NORMALIZED,
 				modulePackage,
 				definitions,
 				processedScripts,
-				compilationUnit,
+				registry,
 				expansions,
 				annotations,
 				storageTypes);
 		if (state != State.NORMALIZED)
 			throw new IllegalStateException("Module is not yet normalized");
 		
-		Validator validator = new Validator(compilationUnit.globalTypeRegistry, expansions, annotations);
+		Validator validator = new Validator(registry, expansions, annotations);
 		for (ScriptBlock script : scripts) {
 			validator.validate(script);
 		}
 	}
 	
 	public ModuleContext getContext() {
-		return new ModuleContext(compilationUnit.globalTypeRegistry, module, expansions, rootPackage);
+		return new ModuleContext(registry, module, expansions, rootPackage);
 	}
 	
 	public enum State {

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

 package org.openzen.zenscript.constructor;
 
 import java.io.File;
-import org.openzen.zenscript.compiler.CompilationUnit;
 import java.io.IOException;
 import java.util.function.Consumer;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.constructor.module.DirectoryModuleReference;
 import org.openzen.zenscript.constructor.module.ModuleReference;
 
 		Consumer<CompileException> exceptionLogger = exception -> System.err.println(exception.toString());
 		
 		File currentDirectory = new File(arguments.directory);
-		CompilationUnit compilationUnit = new CompilationUnit();
+		ZSPackage root = ZSPackage.createRoot();
+		ZSPackage stdlib = new ZSPackage(root, "stdlib");
+		GlobalTypeRegistry registry = new GlobalTypeRegistry(stdlib);
 		
-		ModuleLoader moduleLoader = new ModuleLoader(compilationUnit, exceptionLogger);
+		ModuleLoader moduleLoader = new ModuleLoader(registry, exceptionLogger);
 		moduleLoader.register("stdlib", new DirectoryModuleReference("stdlib", new File("../../StdLibs/stdlib"), true));
 		
 		Project project = new Project(currentDirectory);

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

  */
 package org.openzen.zenscript.constructor;
 
-import org.openzen.zenscript.compiler.CompilationUnit;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Stack;
 import java.util.function.Consumer;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.constructor.module.ModuleReference;
 import org.openzen.zenscript.compiler.SemanticModule;
 
 	private final HashSet<String> compilingModulesSet = new HashSet<>();
 	private final Stack<String> compilingModulesStack = new Stack<>();
 	
-	private final CompilationUnit compilationUnit;
+	private final GlobalTypeRegistry registry;
 	private final Consumer<CompileException> exceptionLogger;
 	
-	public ModuleLoader(CompilationUnit compilationUnit, Consumer<CompileException> exceptionLogger) {
-		this.compilationUnit = compilationUnit;
+	public ModuleLoader(GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger) {
+		this.registry = registry;
 		this.exceptionLogger = exceptionLogger;
 	}
 	
 		compilingModulesSet.add(name);
 		compilingModulesStack.add(name);
 		
-		SemanticModule module = modules.get(name).load(this, compilationUnit, exceptionLogger);
+		SemanticModule module = modules.get(name).load(this, registry, exceptionLogger);
 		moduleCache.put(name, module);
 		
 		compilingModulesSet.remove(name);

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

 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.compiler.CompilationUnit;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.constructor.ConstructorException;
 import org.openzen.zenscript.constructor.JSONUtils;
 import org.openzen.zenscript.constructor.ParsedModule;
 	}
 
 	@Override
-	public SemanticModule load(ModuleLoader loader, CompilationUnit unit, Consumer<CompileException> exceptionLogger) {
+	public SemanticModule load(ModuleLoader loader, GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger) {
 		if (!directory.exists())
 			throw new ConstructorException("Error: module directory not found: " + directory);
 		
 			}
 
 			// TODO: annotation type registration
-			ModuleSpace space = new ModuleSpace(unit, new ArrayList<>(), StorageType.getStandard());
+			ModuleSpace space = new ModuleSpace(registry, new ArrayList<>(), StorageType.getStandard());
 			SemanticModule[] dependencies = new SemanticModule[dependencyNames.size()];
 			for (int i = 0; i < dependencies.length; i++) {
 				String dependencyName = dependencyNames.get(i);
 			}
 
 			ParsedModule parsedModule = new ParsedModule(moduleName, directory, jsonFile, exceptionLogger);
-			ZSPackage pkg = isStdlib ? unit.globalTypeRegistry.stdlib : new ZSPackage(null, parsedModule.packageName);
+			ZSPackage pkg = isStdlib ? registry.stdlib : new ZSPackage(null, parsedModule.packageName);
 			Module module = new Module(moduleName);
 			CompilingPackage compilingPackage = new CompilingPackage(pkg, module);
 			
 			ParsedFile[] parsedFiles = parsedModule.parse(compilingPackage);
-			SemanticModule result = ParsedFile.compileSyntaxToSemantic(parsedModule.name, dependencies, compilingPackage, parsedFiles, space, exceptionLogger);
+			SemanticModule result = ParsedFile.compileSyntaxToSemantic(dependencies, compilingPackage, parsedFiles, space, exceptionLogger);
 			
 			JSONObject globals = json.optJSONObject("globals");
 			if (globals != null) {

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

 
 import java.util.function.Consumer;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.compiler.SemanticModule;
-import org.openzen.zenscript.compiler.CompilationUnit;
 import org.openzen.zenscript.constructor.ModuleLoader;
 
 /**
 public interface ModuleReference {
 	public String getName();
 	
-	public SemanticModule load(ModuleLoader loader, CompilationUnit unit, Consumer<CompileException> exceptionLogger);
+	public SemanticModule load(ModuleLoader loader, GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger);
 	
 	public SourcePackage getRootPackage();
 }

IDE/src/main/java/org/openzen/zenscript/ide/codemodel/IDECodeSpace.java

  */
 package org.openzen.zenscript.ide.codemodel;
 
-import java.io.File;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
-import java.util.function.Consumer;
-import org.openzen.zenscript.compiler.CompilationUnit;
-import org.openzen.zenscript.compiler.SemanticModule;
-import org.openzen.zenscript.compiler.ZenCodeCompiler;
-import org.openzen.zenscript.constructor.Library;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.constructor.ModuleLoader;
-import org.openzen.zenscript.constructor.module.DirectoryModuleReference;
-import org.openzen.zenscript.constructor.module.ModuleReference;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
 import org.openzen.zenscript.ide.host.IDEModule;
 import org.openzen.zenscript.ide.host.IDESourceFile;
-import org.openzen.zenscript.ide.ui.view.output.ErrorOutputSpan;
-import org.openzen.zenscript.ide.ui.view.output.OutputLine;
-import org.openzen.zenscript.validator.ValidationLogEntry;
-import stdlib.Strings;
 
 /**
  *
 	public IDECodeSpace(DevelopmentHost host) {
 		this.host = host;
 		
-		ModuleLoader loader = new ModuleLoader(new CompilationUnit(), exception -> {
+		ZSPackage root = ZSPackage.createRoot();
+		ZSPackage stdlib = new ZSPackage(root, "stdlib");
+		GlobalTypeRegistry registry = new GlobalTypeRegistry(stdlib);
+		ModuleLoader loader = new ModuleLoader(registry, exception -> {
 			
 		});
 		for (IDEModule module : host.getModules()) {

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalTarget.java

 import java.util.Set;
 import java.util.Stack;
 import java.util.function.Consumer;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.compiler.Target;
 import org.openzen.zenscript.compiler.ZenCodeCompiler;
 import org.openzen.zenscript.constructor.Library;
 import org.openzen.zenscript.constructor.module.DirectoryModuleReference;
 import org.openzen.zenscript.constructor.module.ModuleReference;
 import org.openzen.zenscript.compiler.SemanticModule;
-import org.openzen.zenscript.compiler.CompilationUnit;
 import org.openzen.zenscript.ide.host.IDETarget;
 import org.openzen.zenscript.ide.ui.view.output.ErrorOutputSpan;
 import org.openzen.zenscript.ide.ui.view.output.OutputLine;
 	}
 	
 	private ZenCodeCompiler buildInternal(Consumer<OutputLine> output) {
-		CompilationUnit compilationUnit = new CompilationUnit();
-		ModuleLoader moduleLoader = new ModuleLoader(compilationUnit, exception -> {
+		ZSPackage root = ZSPackage.createRoot();
+		ZSPackage stdlibPackage = new ZSPackage(root, "stdlib");
+		GlobalTypeRegistry registry = new GlobalTypeRegistry(stdlibPackage);
+		
+		ModuleLoader moduleLoader = new ModuleLoader(registry, exception -> {
 			String[] lines = Strings.split(exception.getMessage(), '\n');
 			for (String line : lines) {
 				output.accept(new OutputLine(new ErrorOutputSpan(line)));

JavaAnnotations/build.gradle

+// Note: "common.gradle" in the root project contains additional initialization
+//   for this project. This initialization is applied in the "build.gradle"
+//   of the root project.
+
+// NetBeans will automatically add "run" and "debug" tasks relying on the
+// "mainClass" property. You may however define the property prior executing
+// tasks by passing a "-PmainClass=<QUALIFIED_CLASS_NAME>" argument.
+//
+// Note however, that you may define your own "run" and "debug" task if you
+// prefer. In this case NetBeans will not add these tasks but you may rely on
+// your own implementation.
+if (!hasProperty('mainClass')) {
+    ext.mainClass = ''
+}
+
+dependencies {
+    // TODO: Add dependencies here
+    //   but note that JUnit should have already been added in parent.gradle.
+    //   By default, only the Maven Central Repository is specified in
+    //   parent.gradle.
+    //
+    // You can read more about how to add dependency here:
+    //   http://www.gradle.org/docs/current/userguide/dependency_management.html#sec:how_to_declare_your_dependencies
+}

JavaAnnotations/src/main/java/org/openzen/zencode/java/ZenCodeGlobals.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zencode.java;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface ZenCodeGlobals {
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target({ElementType.FIELD, ElementType.METHOD})
+	@interface Global {
+		String value() default "";
+	}
+}

JavaAnnotations/src/main/java/org/openzen/zencode/java/ZenCodeType.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zencode.java;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface ZenCodeType {
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.TYPE)
+	@interface Expansion {
+		String value();
+	}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.TYPE)
+	@interface Name {
+		String value();
+	}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.TYPE)
+	@interface Struct {}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.FIELD)
+	@interface Field {
+		String value() default "";
+	}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.METHOD)
+	@interface Method {
+		String value() default "";
+	}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.METHOD)
+	@interface Operator {
+		OperatorType value();
+	}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.METHOD)
+	@interface Getter {
+		String value() default "";
+	}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.METHOD)
+	@interface Setter {
+		String value() default "";
+	}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.METHOD)
+	@interface Caster {
+		boolean implicit() default false;
+	}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.TYPE_USE)
+	@interface Nullable {}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.TYPE_USE)
+	@interface Unsigned {}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.TYPE_USE)
+	@interface USize {}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.TYPE_USE)
+	@interface NullableUSize {}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.TYPE_USE)
+	@interface BorrowForCall {}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.TYPE_USE)
+	@interface BorrowForThis {}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.PARAMETER)
+	@interface Optional {}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.PARAMETER)
+	@interface OptionalInt {
+		int value() default 0;
+	}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.PARAMETER)
+	@interface OptionalLong {
+		long value() default 0;
+	}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.PARAMETER)
+	@interface OptionalFloat {
+		float value() default 0;
+	}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.PARAMETER)
+	@interface OptionalDouble {
+		double value() default 0;
+	}
+	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.PACKAGE)
+	@interface OptionalString {
+		String value() default "";
+	}
+	
+	enum OperatorType {
+		ADD,		// binary + (addition)
+		SUB,		// binary - (subtraction)
+		MUL,			// binary * (multiplication)
+		DIV,		// binary / (division)
+		MOD,		// binary % (modulo)
+		CAT,		// binary ~ (concatenation)
+		OR,			// binary | (or)
+		AND,		// binary & (and)
+		XOR,		// binary ^ (xor)
+		NEG,		// unary - (negation)
+		INVERT,		// unary ~ (bitwise not)
+		NOT,		// unary ! (logical not)
+		INDEXSET,	// indexed set (array[x, y] = z will be translated to array.INDEXSET(x, y, z)
+		INDEXGET,	// indexed get (array[x, y] will be translated to array.INDEXGET(x, y)
+		CONTAINS,	// contains (x in y will be translated to y.CONTAINS(x)
+		COMPARE,	// comparison (x < y will be translated to x.COMPARE(y) < 0)
+		MEMBERGETTER, // member getter (x.name will be translated to x.MEMBERGETTER("name") if there is no member name in x)
+		MEMBERSETTER, // member setter (x.name = y will be translated to x.MEMBERSETTER("name", y) if there is no member name in x)
+		EQUALS,		// equality operator ==
+		NOTEQUALS,	// inequality operator != (note that by default, the inverse of equals will be used)
+		SHL,			// binary << (shift left)
+		SHR,		// binary >> (shift right)
+		
+		ADDASSIGN,	// += (by default, x += y will be translated to x = x + y unless this operator is implemented)
+		SUBASSIGN,	// -= (by default, x -= y will be translated to x = x - y unless this operator is implemented)
+		MULASSIGN,	// *= (by default, x *= y will be translated to x = x * y unless this operator is implemented)
+		DIVASSIGN,	// /= (by default, x /= y will be translated to x = x / y unless this operator is implemented)
+		MODASSIGN,	// %= (by default, x %= y will be translated to x = x % y unless this operator is implemented)
+		CATASSIGN,	// ~= (by default, x ~= y will be translated to x = x ~ y unless this operator is implemented)
+		ORASSIGN,	// |= (by default, x |= y will be translated to x = x | y unless this operator is implemented)
+		ANDASSIGN,	// &= (by default, x &= y will be translated to x = x & y unless this operator is implemented)
+		XORASSIGN,	// ^= (by default, x ^= y will be translated to x = x ^ y unless this operator is implemented)
+		SHLASSIGN,	// >>= (by default, x >>= y will be translated to x = x >> y unless this operator is implemented)
+		SHRASSIGN	// <<= (by default, x <<= y will be translated to x = x << y unless this operator is implemented)
+	}
+}

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

 
 	@Override
 	public JavaCompiler createCompiler(SemanticModule module) {
-		return new JavaCompiler(module.compilationUnit.globalTypeRegistry, debugCompiler, file);
+		return new JavaCompiler(module.registry, debugCompiler, file);
 	}
 
 	@Override

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javabytecode;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.javashared.JavaCompiledModule;
+import org.openzen.zenscript.javashared.JavaMethod;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaBytecodeModule extends JavaCompiledModule {
+	private final Map<String, byte[]> classes = new HashMap<>();
+	private final List<JavaMethod> scripts = new ArrayList<>();
+	
+	public JavaBytecodeModule(Module module) {
+		super(module);
+	}
+	
+	public void addClass(String name, byte[] bytecode) {
+		classes.put(name, bytecode);
+	}
+	
+	public void addScript(JavaMethod method) {
+		scripts.add(method);
+	}
+	
+	public Map<String, byte[]> getClasses() {
+		return classes;
+	}
+	
+	public List<JavaMethod> getScripts() {
+		return scripts;
+	}
+}

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

 
 	@Override
 	public JavaCompiler createCompiler(SemanticModule module) {
-		return new JavaCompiler(module.compilationUnit.globalTypeRegistry, debugCompiler, null);
+		return new JavaCompiler(module.registry, debugCompiler, null);
 	}
 
 	@Override

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javabytecode;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
+import org.openzen.zenscript.javabytecode.compiler.JavaClassWriter;
+import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
+import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaMethod;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaBytecodeRunUnit {
+	private final Map<String, byte[]> classes = new HashMap<>();
+	private final List<JavaMethod> scripts = new ArrayList<>();
+	
+	private boolean scriptsWritten = false;
+	
+	public void add(JavaBytecodeModule module) {
+		scriptsWritten = false;
+		
+		for (Map.Entry<String, byte[]> classEntry : module.getClasses().entrySet())
+			classes.put(classEntry.getKey().replace('/', '.'), classEntry.getValue());
+		
+		scripts.addAll(module.getScripts());
+	}
+	
+	public void run() {
+		if (!scriptsWritten)
+			writeScripts();
+		
+		ScriptClassLoader classLoader = new ScriptClassLoader();
+
+		try {
+			classLoader.loadClass("Scripts").getMethod("run").invoke(null);
+		} catch (ClassNotFoundException | InvocationTargetException | NoSuchMethodException | IllegalAccessException | SecurityException | IllegalArgumentException ex) {
+			Logger.getLogger(JavaModule.class.getName()).log(Level.SEVERE, null, ex);
+		}
+	}
+	
+	private void writeScripts() {
+		JavaClassWriter scriptsClassWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
+		scriptsClassWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Scripts", null, "java/lang/Object", null);
+		
+		JavaMethod runMethod = JavaMethod.getStatic(new JavaClass("script", "Scripts", JavaClass.Kind.CLASS), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+		final JavaWriter runWriter = new JavaWriter(scriptsClassWriter, runMethod, null, null, null);
+		runWriter.start();
+		for (JavaMethod method : scripts)
+			runWriter.invokeStatic(method);
+		
+		runWriter.ret();
+		runWriter.end();
+		
+		classes.put("Scripts", scriptsClassWriter.toByteArray());
+	}
+
+	public class ScriptClassLoader extends ClassLoader {
+		private final Map<String, Class> customClasses = new HashMap<>();
+
+		@Override
+		public Class<?> loadClass(String name) throws ClassNotFoundException {
+			//System.out.println("LoadClass " + name);
+			
+			if (customClasses.containsKey(name))
+				return customClasses.get(name);
+			if (classes.containsKey(name)) {
+				final byte[] bytes = classes.get(name);
+				customClasses.put(name, defineClass(name, bytes, 0, bytes.length, null));
+				return customClasses.get(name);
+			}
+			return super.loadClass(name);
+		}
+	}
+}

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

 import org.openzen.zenscript.javabytecode.compiler.definitions.JavaDefinitionVisitor;
 import org.openzen.zenscript.javashared.JavaBaseCompiler;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaCompileSpace;
+import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.JavaContext;
 import org.openzen.zenscript.javashared.JavaMethod;
 import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionMemberVisitor;
 		return context;
 	}
 	
+	//@Override
+	public JavaBytecodeModule compile(SemanticModule module, JavaCompileSpace space) {
+		context.addModule(module.module);
+		
+		JavaBytecodeModule target = new JavaBytecodeModule(module.module);
+		for (HighLevelDefinition definition : module.definitions.getAll()) {
+			JavaPrepareDefinitionMemberVisitor memberPreparer = new JavaPrepareDefinitionMemberVisitor(context, context.getJavaModule(definition.module));
+			definition.accept(memberPreparer);
+		}
+		
+		for (HighLevelDefinition definition : module.definitions.getAll()) {
+			String className = getClassName(definition.position.getFilename());
+			JavaScriptFile scriptFile = getScriptFile(className);
+			
+			target.addClass(definition.name, definition.accept(new JavaDefinitionVisitor(context, scriptFile.classWriter)));
+		}
+		
+		for (ScriptBlock script : module.scripts) {
+			final SourceFile sourceFile = script.getTag(SourceFile.class);
+			final String className = getClassName(sourceFile == null ? null : sourceFile.getFilename());
+			JavaScriptFile scriptFile = getScriptFile(script.pkg.fullName + "/" + className);
+
+			String methodName = scriptFile.scriptMethods.isEmpty() ? "run" : "run" + scriptFile.scriptMethods.size();
+
+			// convert scripts into methods (add them to a Scripts class?)
+			// (TODO: can we break very long scripts into smaller methods? for the extreme scripts)
+			final JavaClassWriter visitor = scriptFile.classWriter;
+			JavaMethod method = JavaMethod.getStatic(new JavaClass(script.pkg.fullName, className, JavaClass.Kind.CLASS), methodName, "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+			scriptFile.scriptMethods.add(method);
+
+			final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, context.getJavaModule(script.module), new JavaWriter(visitor, method, null, null, null));
+			statementVisitor.start();
+			for (Statement statement : script.statements) {
+				statement.accept(statementVisitor);
+			}
+			statementVisitor.end();
+		}
+		
+		for (Map.Entry<String, JavaScriptFile> entry : scriptBlocks.entrySet()) {
+			for (JavaMethod method : entry.getValue().scriptMethods)
+				target.addScript(method);
+
+			entry.getValue().classWriter.visitEnd();
+			target.addClass(entry.getKey(), entry.getValue().classWriter.toByteArray());
+		}
+
+		return target;
+	}
+	
 	@Override
 	public ZenCodeCompilingModule addModule(SemanticModule module) {
 		context.addModule(module.module);

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

                     constructorWriter.loadObject(0);
                 field.initializer.accept(expressionVisitor);
                 if (staticFields)
-                    constructorWriter.putStaticField(definition.name, field.name, context.getDescriptor(field.type));
+                    constructorWriter.putStaticField(definition.name, field.name, context.getDescriptor(field.getType()));
                 else
-                    constructorWriter.putField(definition.name, field.name, context.getDescriptor(field.type));
+                    constructorWriter.putField(definition.name, field.name, context.getDescriptor(field.getType()));
             }
         }
     }

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

     private final LocalVariablesSorter visitor;
     private final List<JavaLocalVariableInfo> localVariableInfos = new ArrayList<>();
     public final ClassVisitor clazzVisitor;
-    private boolean debug = true;
+    private boolean debug = false;
     private boolean nameVariables = true;
     private int labelIndex = 1;
     private Map<Label, String> labelNames = new HashMap<>();

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaBaseCompiler.java

 package org.openzen.zenscript.javashared;
 
+import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.compiler.ZenCodeCompiler;
 
 /*
  * @author Hoofdgebruiker
  */
 public abstract class JavaBaseCompiler implements ZenCodeCompiler {
-	
+	//public abstract JavaCompiledModule compile(SemanticModule module, JavaCompileSpace space);
 }

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaCompileSpace.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javashared;
+
+import org.openzen.zenscript.codemodel.Module;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface JavaCompileSpace {
+	public JavaCompiledModule getCompiled(Module module);
+}

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaCompiledModule.java

  */
 package org.openzen.zenscript.javashared;
 
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
+import org.openzen.zenscript.codemodel.statement.BlockStatement;
+import org.openzen.zenscript.codemodel.statement.Statement;
 
 /**
  *
 		this.module = module;
 	}
 	
+	/*public Statement generateModuleDefinitionMethod() {
+		List<Statement> statements = new ArrayList<>();
+		
+		
+		return new BlockStatement(CodePosition.GENERATED, statements.toArray(new Statement[statements.size()]));
+	}*/
+	
 	public void setClassInfo(HighLevelDefinition definition, JavaClass cls) {
 		classes.put(definition, cls);
 	}

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaContext.java

 	
 	public abstract String getDescriptor(StoredType type);
 	
+	public void registerModule(JavaCompiledModule module) {
+		modules.put(module.module, module);
+	}
+	
 	public void addModule(Module module) {
 		modules.put(module, new JavaCompiledModule(module));
 	}

JavaShared/src/main/java/org/openzen/zenscript/javashared/SimpleJavaCompileSpace.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javashared;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.openzen.zenscript.codemodel.Module;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SimpleJavaCompileSpace implements JavaCompileSpace {
+	private final Map<Module, JavaCompiledModule> modules = new HashMap<>();
+	
+	public void register(JavaCompiledModule module) {
+		modules.put(module.module, module);
+	}
+	
+	@Override
+	public JavaCompiledModule getCompiled(Module module) {
+		return modules.get(module);
+	}
+}

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareClassMethodVisitor.java

 import org.openzen.zenscript.javashared.JavaNativeClass;
 import org.openzen.zencode.shared.StringExpansion;
 import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.annotations.NativeTag;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 			System.out.println("Class " + cls.fullName + " not empty because of const " + member.name);
 		
 		cls.empty = false;
-		module.setFieldInfo(member, new JavaField(cls, member.name, context.getDescriptor(member.type)));
+		module.setFieldInfo(member, new JavaField(cls, member.name, context.getDescriptor(member.getType())));
 		return null;
 	}
 	
 	@Override
 	public Void visitField(FieldMember member) {
-		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.type));
+		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.getType()));
 		module.setFieldInfo(member, field);
 		if (member.hasAutoGetter()) {
 			visitGetter(member.autoGetter);
 
 	@Override
 	public Void visitGetter(GetterMember member) {
-		visitFunctional(member, new FunctionHeader(member.type), "get" + StringExpansion.capitalize(member.name));
+		visitFunctional(member, new FunctionHeader(member.getType()), "get" + StringExpansion.capitalize(member.name));
 		return null;
 	}
 
 	@Override
 	public Void visitSetter(SetterMember member) {
-		visitFunctional(member, new FunctionHeader(BasicTypeID.VOID, member.type), "set" + StringExpansion.capitalize(member.name));
+		visitFunctional(member, new FunctionHeader(BasicTypeID.VOID, member.getType()), "set" + StringExpansion.capitalize(member.name));
 		return null;
 	}
 

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareDefinitionVisitor.java

 			cls.addInstanceMethod("lastIndexOf", "lastIndexOf", "(I)I");
 			cls.addInstanceMethod("lastIndexOfFrom", "lastIndexOf", "(II)I");
 			cls.addInstanceMethod("trim", "trim", "()Ljava/lang/String;");
+			cls.addInstanceMethod("startsWith", "startsWith", "(Ljava/lang/String;)Z");
+			cls.addInstanceMethod("endsWith", "endsWith", "(Ljava/lang/String;)Z");
 			cls.addMethod("fromAsciiBytes", new JavaMethod((expression, translator) -> {
 				CallStaticExpression call = (CallStaticExpression)expression;
 				return translator.bytesAsciiToString(call.arguments.arguments[0]);

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareExpansionMethodVisitor.java

 	
 	@Override
 	public Void visitConst(ConstMember member) {
-		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.type));
+		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.getType()));
 		module.setFieldInfo(member, field);
 		
 		if (DEBUG_EMPTY && cls.empty)
 	@Override
 	public Void visitField(FieldMember member) {
 		// TODO: expansion fields
-		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.type));
+		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.getType()));
 		module.setFieldInfo(member, field);
 		
 		if (member.hasAutoGetter() || member.hasAutoSetter())
 
 	@Override
 	public Void visitGetter(GetterMember member) {
-		visitFunctional(member, new FunctionHeader(member.type), "get" + StringExpansion.capitalize(member.name));
+		visitFunctional(member, new FunctionHeader(member.getType()), "get" + StringExpansion.capitalize(member.name));
 		return null;
 	}
 
 	@Override
 	public Void visitSetter(SetterMember member) {
-		visitFunctional(member, new FunctionHeader(BasicTypeID.VOID, member.type), "set" + StringExpansion.capitalize(member.name));
+		visitFunctional(member, new FunctionHeader(BasicTypeID.VOID, member.getType()), "set" + StringExpansion.capitalize(member.name));
 		return null;
 	}
 

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

 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.formattershared.ExpressionString;
 import org.openzen.zenscript.formattershared.StatementFormattingTarget;
+import org.openzen.zenscript.javashared.JavaTypeUtils;
 import org.openzen.zenscript.javasource.scope.JavaSourceStatementScope;
 
 /**

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

 	}
 	
 	private JavaSourceFileScope createScope(HighLevelDefinition definition) {
-		GlobalTypeRegistry typeRegistry = semanticModule.compilationUnit.globalTypeRegistry;
+		GlobalTypeRegistry typeRegistry = semanticModule.registry;
 		DefinitionTypeID thisType = typeRegistry.getForMyDefinition(definition);
 		
-		CompileScope scope = new CompileScope(semanticModule.compilationUnit.globalTypeRegistry, semanticModule.expansions, semanticModule.annotations, semanticModule.storageTypes);
+		CompileScope scope = new CompileScope(
+				semanticModule.registry,
+				semanticModule.rootPackage,
+				semanticModule.expansions,
+				semanticModule.annotations,
+				semanticModule.storageTypes);
 		return new JavaSourceFileScope(file.importer, compiler.helperGenerator, cls, scope, definition instanceof InterfaceDefinition, thisType, compiler.context);
 	}
 	

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

 	public Void visitConst(ConstMember member) {
 		begin(ElementType.FIELD);
 		modifiers(member.getEffectiveModifiers() | Modifiers.STATIC | Modifiers.FINAL);
-		output.append(scope.type(member.type));
+		output.append(scope.type(member.getType()));
 		output.append(" ");
 		output.append(member.name);
 		output.append(" = ");
 		
 		this.modifiers(modifiers);
 		
-		output.append(scope.type(member.type));
+		output.append(scope.type(member.getType()));
 		output.append(" ");
 		output.append(member.name);
 		if (member.initializer != null) {
 
 	@Override
 	public Void visitGetter(GetterMember member) {
-		compileMethod(member, new FunctionHeader(member.type), member.body);
+		compileMethod(member, new FunctionHeader(member.getType()), member.body);
 		return null;
 	}
 
 	@Override
 	public Void visitSetter(SetterMember member) {
-		compileMethod(member, new FunctionHeader(BasicTypeID.VOID, new FunctionParameter(member.type, "value")), member.body);
+		compileMethod(member, new FunctionHeader(BasicTypeID.VOID, new FunctionParameter(member.getType(), "value")), member.body);
 		return null;
 	}
 

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

 		
 		output.append(indent);
 		modifiers(member.getEffectiveModifiers() | Modifiers.STATIC | Modifiers.FINAL);
-		output.append(scope.type(member.type));
+		output.append(scope.type(member.getType()));
 		output.append(" ");
 		output.append(member.name);
 		output.append(" = ");
 		
 		this.modifiers(modifiers);
 		
-		output.append(scope.type(member.type));
+		output.append(scope.type(member.getType()));
 		output.append(" ");
 		output.append(member.name);
 		if (member.initializer != null) {
 
 	@Override
 	public Void visitGetter(GetterMember member) {
-		compileMethod(member, new FunctionHeader(member.type), member.body);
+		compileMethod(member, new FunctionHeader(member.getType()), member.body);
 		return null;
 	}
 
 	@Override
 	public Void visitSetter(SetterMember member) {
-		compileMethod(member, new FunctionHeader(BasicTypeID.VOID, new FunctionParameter(member.type, "value")), member.body);
+		compileMethod(member, new FunctionHeader(BasicTypeID.VOID, new FunctionParameter(member.getType(), "value")), member.body);
 		return null;
 	}
 

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.compiler.CompilationUnit;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.compiler.ZenCodeCompiler;
 import org.openzen.zenscript.compiler.ZenCodeCompilingModule;
 	public final JavaSourceContext context;
 	private final List<SourceModule> modules = new ArrayList<>();
 	
-	public JavaSourceCompiler(File directory, CompilationUnit compilationUnit) {
+	public JavaSourceCompiler(File directory, GlobalTypeRegistry registry) {
 		if (!directory.exists())
 			directory.mkdirs();
 		
 		settings = new JavaSourceFormattingSettings.Builder().build();
-		context = new JavaSourceContext(compilationUnit.globalTypeRegistry, directory, settings);
+		context = new JavaSourceContext(registry, directory, settings);
 		helperGenerator = new JavaSourceSyntheticHelperGenerator(context, directory, settings);
 		
 		this.directory = directory;

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

 		this.scope = scope;
 		context = scope.context;
 	}
+	
+	private ExpressionString getValue(Expression expression) {
+		ExpressionString source = expression.accept(this);
+		if (JavaTypeUtils.isShared(expression.type) && !(expression instanceof ThisExpression))
+			source = source.unaryPostfix(JavaOperator.CALL, ".get()");
+		return source;
+	}
 
 	@Override
 	public ExpressionString visitAndAnd(AndAndExpression expression) {
 			return visitBuiltinCompare(expression, expression.operator.getBuiltin());
 		
 		StringBuilder output = new StringBuilder();
-		output.append(expression.left.accept(this).value);
+		output.append(getValue(expression.left).value);
 		output.append(".compareTo(");
 		output.append(expression.right.accept(this));
 		output.append(") ");
 				output.append(scope.type(method.cls));
 				output.append('.');
 				output.append(method.name);
-				FormattingUtils.formatExpansionCall(output, this.target, scope, target.accept(this), arguments);
+				FormattingUtils.formatExpansionCall(output, this.target, scope, getValue(target), arguments);
 				return new ExpressionString(output.toString(), JavaOperator.CALL);
 			}
 			case INSTANCE: {
 				StringBuilder output = new StringBuilder();
-				output.append(target.accept(this).value);
+				output.append(getValue(target).value);
 				output.append('.');
 				output.append(method.name);
 				FormattingUtils.formatCall(output, this.target, scope, arguments);
 	public ExpressionString visitGetField(GetFieldExpression expression) {
 		StringBuilder result = new StringBuilder();
 		if (!(expression.target instanceof ThisExpression && !scope.hasLocalVariable(expression.field.member.name))) {
-			result.append(expression.target.accept(this));
+			result.append(getValue(expression.target));
 			result.append('.');
 		}
 		result.append(expression.field.member.name);
 		if (expression.getter.member.builtin != null)
 			return visitBuiltinGetter(expression, expression.getter.member.builtin);
 		
-		ExpressionString target = expression.target.accept(this);
+		ExpressionString target = getValue(expression.target);
 		if (context.hasJavaField(expression.getter)) {
 			JavaField field = context.getJavaField(expression.getter);
 			if (target.value.equals("this") && !scope.hasLocalVariable(field.name))
 	@Override
 	public ExpressionString visitSetter(SetterExpression expression) {
 		return new ExpressionString(
-				expression.target.accept(this) + "." + expression.setter.member.name + " = " + expression.value.accept(this),
+				getValue(expression.target) + "." + expression.setter.member.name + " = " + expression.value.accept(this),
 				JavaOperator.ASSIGN);
 	}
 

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

 		contents.append(settings.indent).append(settings.indent).append("this.value = value;\n");
 		contents.append(settings.indent).append("}\n");
 		contents.append(settings.indent).append("\n");
+		contents.append(settings.indent).append("public T get() {\n");
+		contents.append(settings.indent).append(settings.indent).append("return value;\n");
+		contents.append(settings.indent).append("}\n");
+		contents.append(settings.indent).append("\n");
 		contents.append(settings.indent).append("public synchronized void addRef() {\n");
 		contents.append(settings.indent).append(settings.indent).append("refcount++;\n");
 		contents.append(settings.indent).append("}\n");

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

 
 	@Override
 	public ZenCodeCompiler createCompiler(SemanticModule module) {
-		return new JavaSourceCompiler(output, module.compilationUnit);
+		return new JavaSourceCompiler(output, module.registry);
 	}
 
 	@Override

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

  */
 public class ParsedFile {
 	public static SemanticModule compileSyntaxToSemantic(
-			String name,
 			SemanticModule[] dependencies,
 			CompilingPackage pkg,
 			ParsedFile[] files,
 		boolean failed = false;
 		
 		ModuleTypeResolutionContext moduleContext = new ModuleTypeResolutionContext(
-				registry.compilationUnit.globalTypeRegistry,
+				registry.registry,
 				registry.getAnnotations(),
 				registry.getStorageTypes(),
 				rootPackage,
 		}
 		
 		if (failed)
-			return new SemanticModule(name, pkg.module, dependencies, SemanticModule.State.INVALID, rootPackage, pkg.getPackage(), definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations(), registry.getStorageTypes());
+			return new SemanticModule(pkg.module, dependencies, SemanticModule.State.INVALID, rootPackage, pkg.getPackage(), definitions, Collections.emptyList(), registry.registry, expansions, registry.getAnnotations(), registry.getStorageTypes());
 		
 		// scripts will store all the script blocks encountered in the files
 		PrecompilationState precompiler = new PrecompilationState();
 		}
 		
 		return new SemanticModule(
-				name,
 				pkg.module,
 				dependencies,
 				SemanticModule.State.ASSEMBLED,
 				pkg.getPackage(),
 				definitions,
 				scripts,
-				registry.compilationUnit,
+				registry.registry,
 				expansions,
 				registry.getAnnotations(),
 				registry.getStorageTypes());
 			ModuleTypeResolutionContext moduleContext,
 			ZSPackage rootPackage,
 			CompilingPackage modulePackage) {
-		FileResolutionContext context = new FileResolutionContext(moduleContext, modulePackage);
+		FileResolutionContext context = new FileResolutionContext(moduleContext, rootPackage, modulePackage);
 		loadImports(context, rootPackage, modulePackage);
 		
 		for (ParsedDefinition definition : this.definitions) {
 			ModuleTypeResolutionContext moduleContext,
 			ZSPackage rootPackage,
 			CompilingPackage modulePackage) {
-		FileResolutionContext context = new FileResolutionContext(moduleContext, modulePackage);
+		FileResolutionContext context = new FileResolutionContext(moduleContext, rootPackage, modulePackage);
 		loadImports(context, rootPackage, modulePackage);
 		
 		for (ParsedDefinition definition : this.definitions) {
 			CompilingPackage modulePackage,
 			List<ExpansionDefinition> expansions,
 			Map<String, ISymbol> globals) {
-		FileResolutionContext context = new FileResolutionContext(moduleContext, modulePackage);
+		FileResolutionContext context = new FileResolutionContext(moduleContext, rootPackage, modulePackage);
 		loadImports(context, rootPackage, modulePackage);
 		
 		FileScope scope = new FileScope(context, expansions, globals, precompiler);
 			List<ScriptBlock> scripts,
 			Map<String, ISymbol> globals,
 			Consumer<CompileException> exceptionLogger) {
-		FileResolutionContext context = new FileResolutionContext(moduleContext, modulePackage);
+		FileResolutionContext context = new FileResolutionContext(moduleContext, rootPackage, modulePackage);
 		loadImports(context, rootPackage, modulePackage);
 		
 		FileScope scope = new FileScope(context, expansions, globals, precompiler);
 			//if (definition == null)
 			//	importErrors.add(new CompileException(importEntry.position, CompileExceptionCode.IMPORT_NOT_FOUND, "Could not find type " + importEntry.toString()));
 			
-			context.addImport(importEntry.getName(), definition);
+			if (definition != null)
+				context.addImport(importEntry.getName(), definition);
 		}
 	}
 }

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.parser;
+
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+import org.openzen.zencode.shared.LiteralSourceFile;
+import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.compiler.ModuleSpace;
+import org.openzen.zenscript.compiler.SemanticModule;
+import org.openzen.zenscript.lexer.ParseException;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ZippedPackage {
+	private Map<String, List<SourceFile>> files = new HashMap<>();
+	
+	public ZippedPackage(InputStream input) throws IOException {
+		try (ZipInputStream zipInput = new ZipInputStream(new BufferedInputStream(input))) {
+			ZipEntry entry = zipInput.getNextEntry();
+			while (entry != null) {
+				int slash = entry.getName().indexOf("/src/");
+				if (slash > 0) {
+					String moduleName = entry.getName().substring(0, slash);
+					String filename = entry.getName().substring(slash + 5);
+					if (!files.containsKey(moduleName))
+						files.put(moduleName, new ArrayList<>());
+					
+					byte[] data = new byte[(int)entry.getSize()];
+					int read = 0;
+					while (read < data.length)
+						read += zipInput.read(data, read, data.length - read);
+					
+					files.get(moduleName).add(new LiteralSourceFile(filename, new String(data, StandardCharsets.UTF_8)));
+				}
+				
+				zipInput.closeEntry();
+				entry = zipInput.getNextEntry();
+			}
+		}
+	}
+	
+	public SemanticModule loadModule(ModuleSpace space, String name, BracketExpressionParser bracketParser, SemanticModule[] dependencies) throws ParseException {
+		return loadModule(space, name, bracketParser, dependencies, new ZSPackage(space.rootPackage, name));
+	}
+	
+	public SemanticModule loadModule(ModuleSpace space, String name, BracketExpressionParser bracketParser, SemanticModule[] dependencies, ZSPackage pkg) throws ParseException {
+		List<SourceFile> sourceFiles = files.get(name);
+		if (sourceFiles == null)
+			return null; // no such module
+		
+		Module scriptModule = new Module(name);
+		CompilingPackage scriptPackage = new CompilingPackage(pkg, scriptModule);
+		ParsedFile[] files = new ParsedFile[sourceFiles.size()];
+		for (int i = 0; i < files.length; i++)
+			files[i] = ParsedFile.parse(scriptPackage, bracketParser, sourceFiles.get(i));
+		
+		SemanticModule scripts = ParsedFile.compileSyntaxToSemantic(
+				dependencies,
+				scriptPackage,
+				files,
+				space,
+				ex -> ex.printStackTrace());
+		return scripts.normalize();
+	}
+}

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

 			return;
 		typesCompiled = true;
 		
-		System.out.println("compileTypes " + getCompiled().name);
+		//System.out.println("compileTypes " + getCompiled().name);
 		linkTypesLocal(context);
 	}
 	

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

 		try {
 			TypeMembers members = scope.getTypeMembers(type);
 			TypeMemberGroup constructors = members.getOrCreateGroup(OperatorType.CONSTRUCTOR);
-			for (TypeMember<FunctionalMemberRef> member : constructors.getMethodMembers()) {
+			/*for (TypeMember<FunctionalMemberRef> member : constructors.getMethodMembers()) {
 				if (member.member.getBuiltin() == BuiltinID.ARRAY_CONSTRUCTOR_PROJECTED)
 					System.out.println("X");
-			}
+			}*/
 
 			List<StoredType>[] predictedTypes = constructors.predictCallTypes(scope, scope.hints, arguments.arguments.size());
 			CallArguments compiledArguments = arguments.compileCall(position, scope, null, constructors);

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

 		
 		if (expression != null) {
 			Expression initializer = expression
-					.compile(new ExpressionScope(scope, compiled.type))
+					.compile(new ExpressionScope(scope, compiled.getType()))
 					.eval()
-					.castImplicit(position, scope, compiled.type);
+					.castImplicit(position, scope, compiled.getType());
 			compiled.value = initializer;
 			
-			if (compiled.type.isBasic(BasicTypeID.UNDETERMINED))
-				compiled.type = initializer.type;
-		} else if (compiled.type.isBasic(BasicTypeID.UNDETERMINED)) {
+			if (compiled.getType().isBasic(BasicTypeID.UNDETERMINED))
+				compiled.setType(initializer.type);
+		} else if (compiled.getType().isBasic(BasicTypeID.UNDETERMINED)) {
 			throw new CompileException(position, CompileExceptionCode.PRECOMPILE_FAILED, "No type or initializer given");
 		}
 	}

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

 		
 		if (expression != null) {
 			Expression initializer = expression
-					.compile(new ExpressionScope(scope, compiled.type))
+					.compile(new ExpressionScope(scope, compiled.getType()))
 					.eval()
-					.castImplicit(position, scope, compiled.type);
+					.castImplicit(position, scope, compiled.getType());
 			compiled.setInitializer(initializer);
 			
-			if (compiled.type.isBasic(BasicTypeID.UNDETERMINED))
-				compiled.type = initializer.type;
-		} else if (compiled.type.isBasic(BasicTypeID.UNDETERMINED)) {
+			if (compiled.getType().isBasic(BasicTypeID.UNDETERMINED))
+				compiled.setType(initializer.type);
+		} else if (compiled.getType().isBasic(BasicTypeID.UNDETERMINED)) {
 			throw new CompileException(position, CompileExceptionCode.PRECOMPILE_FAILED, "Could not infer type since no initializer is given");
 		}
 	}

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

 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.member.GetterMember;
+import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.scope.FunctionScope;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 	}
 
 	private void fillOverride(TypeScope scope, StoredType baseType) {
-		compiled.setOverrides(scope.getTypeMembers(baseType).getOrCreateGroup(name, false).getGetter());
+		GetterMemberRef getter = scope.getTypeMembers(baseType).getOrCreateGroup(name, false).getGetter();
+		if (getter != null)
+			compiled.setOverrides(getter);
 	}
 	
 	@Override
 		
 		inferHeaders(scope);
 		
-		FunctionHeader header = new FunctionHeader(compiled.type);
+		FunctionHeader header = new FunctionHeader(compiled.getType());
 		FunctionScope innerScope = new FunctionScope(scope, header);
 		compiled.annotations = ParsedAnnotation.compileForMember(annotations, getCompiled(), scope);
 		compiled.setBody(body.compile(innerScope, header));
-		
-		if (compiled.type.isBasic(BasicTypeID.UNDETERMINED))
-			compiled.type = compiled.body.getReturnType();
 	}
 }

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

 			return;
 		typesCompiled = true;
 		
-		System.out.println("compileTypes " + definition.name + "::" + innerDefinition.getCompiled().name);
+		//System.out.println("compileTypes " + definition.name + "::" + innerDefinition.getCompiled().name);
 		innerDefinition.linkTypes(context);
 	}
 

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

 		
 		inferHeaders(scope);
 		
-		FunctionHeader header = new FunctionHeader(compiled.type);
+		FunctionHeader header = new FunctionHeader(compiled.getType());
 		FunctionScope innerScope = new FunctionScope(
 				scope,
 				header,

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

 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
 import org.openzen.zenscript.codemodel.statement.VariableID;
 			this.outer = outer;
 			this.exceptionVariable = exceptionVariable;
 		}
-	
+
+		@Override
+		public ZSPackage getRootPackage() {
+			return outer.getRootPackage();
+		}
+		
 		@Override
 		public IPartialExpression get(CodePosition position, GenericName name) throws CompileException {
 			if (name.hasNoArguments() && exceptionVariable.name.equals(name.name))

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

 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.SwitchStatement;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
 			this.outer = outer;
 			this.target = target;
 		}
+
+		@Override
+		public ZSPackage getRootPackage() {
+			return outer.getRootPackage();
+		}
 	
 		@Override
 		public IPartialExpression get(CodePosition position, GenericName name) throws CompileException {

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedTypeGenericMap.java

 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 			this.outer = outer;
 			this.parameter = parameter;
 		}
+
+		@Override
+		public ZSPackage getRootPackage() {
+			return outer.getRootPackage();
+		}
 		
 		@Override
 		public GlobalTypeRegistry getTypeRegistry() {

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

 package org.openzen.zenscript.scriptingexample;
 
 import java.io.File;
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.codemodel.type.storage.StorageType;
-import org.openzen.zenscript.compiler.CompilationUnit;
 import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.formatter.FileFormatter;
 import org.openzen.zenscript.formatter.ScriptFormattingSettings;
 		CompilingPackage compilingPkg = new CompilingPackage(pkg, module);
 		ParsedFile[] parsedFiles = parse(compilingPkg, inputFiles);
 		
-		CompilationUnit compileUnit = new CompilationUnit();
+		ZSPackage root = ZSPackage.createRoot();
+		ZSPackage stdlib = new ZSPackage(root, "stdlib");
+		GlobalTypeRegistry typeRegistry = new GlobalTypeRegistry(stdlib);
+		
 		ZSPackage global = new ZSPackage(null, "");
-		GlobalRegistry registry = new GlobalRegistry(compileUnit.globalTypeRegistry, global);
-		SemanticModule semantic = compileSyntaxToSemantic(compileUnit, compilingPkg, parsedFiles, registry);
+		GlobalRegistry registry = new GlobalRegistry(typeRegistry, global);
+		SemanticModule semantic = compileSyntaxToSemantic(typeRegistry, compilingPkg, parsedFiles, registry);
 		
 		//formatFiles(pkg, module);
 		
 		}
 	}
 	
-	private static SemanticModule compileSyntaxToSemantic(CompilationUnit compileUnit, CompilingPackage compiling, ParsedFile[] files, GlobalRegistry registry) {
-		ModuleSpace space = new ModuleSpace(compileUnit, new ArrayList<>(), StorageType.getStandard());
+	private static SemanticModule compileSyntaxToSemantic(GlobalTypeRegistry typeRegistry, CompilingPackage compiling, ParsedFile[] files, GlobalRegistry registry) {
+		ModuleSpace space = new ModuleSpace(typeRegistry, new ArrayList<>(), StorageType.getStandard());
 		for (Map.Entry<String, ISymbol> global : registry.collectGlobals().entrySet()) {
 			space.addGlobal(global.getKey(), global.getValue());
 		}
 		SemanticModule result = ParsedFile.compileSyntaxToSemantic(
-				"scripts",
 				new SemanticModule[0],
 				compiling,
 				files,
 	}
 	
 	private static JavaModule compileSemanticToJava(GlobalRegistry registry, SemanticModule module) {
-		JavaCompiler compiler = new JavaCompiler(module.compilationUnit.globalTypeRegistry, false, null);
+		JavaCompiler compiler = new JavaCompiler(module.registry, false, null);
 		registry.register(compiler.getContext());
 		
 		ZenCodeCompilingModule compiling = compiler.addModule(module);

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

     public static final CodePosition NATIVE = new CodePosition(new VirtualSourceFile("native"), 0, 0, 0, 0);
     public static final CodePosition META = new CodePosition(new VirtualSourceFile("meta"), 0, 0, 0, 0);
     public static final CodePosition UNKNOWN = new CodePosition(new VirtualSourceFile("unknown"), 0, 0, 0, 0);
+    public static final CodePosition GENERATED = new CodePosition(new VirtualSourceFile("generated"), 0, 0, 0, 0);
+	
     public final SourceFile file;
     public final int fromLine;
     public final int fromLineOffset;

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

     
     public final CodePosition position;
     public final CompileExceptionCode code;
+	public final String message;
     
     public CompileException(CodePosition position, CompileExceptionCode code, String message) {
         super(position.toString() + ": [" + code.toString() + "] " + message);
+		
         this.position = position;
         this.code = code;
+		this.message = message;
     }
     
     public CodePosition getPosition() {

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

         throw new AssertionError("Cannot update literal source files");
     }
     
+	@Override
     public String getFilename() {
         return filename;
     }

Validator/src/main/java/org/openzen/zenscript/validator/ValidationLogEntry.java

 		this.message = message;
 	}
 	
+	@Override
+	public String toString() {
+		return kind + " " + position + ": " + message; 
+	}
+	
 	public static enum Kind {
 		ERROR,
 		WARNING

Validator/src/main/java/org/openzen/zenscript/validator/visitors/DefinitionMemberValidator.java

 				Modifiers.PUBLIC | Modifiers.PROTECTED | Modifiers.PRIVATE,
 				member.position,
 				"Invalid modifier");
-		if (member.type != member.value.type) {
+		if (member.getType() != member.value.type) {
 			validator.logError(
 					ValidationLogEntry.Code.INVALID_TYPE,
 					member.position,
 					"Duplicate field name: " + member.name);
 		}
 		fieldNames.add(member.name);
-		new TypeValidator(validator, member.position).validate(TypeContext.FIELD_TYPE, member.type);
+		new TypeValidator(validator, member.position).validate(TypeContext.FIELD_TYPE, member.getType());
 		
 		if (member.initializer != null) {
 			member.initializer.accept(new ExpressionValidator(validator, new FieldInitializerScope(member)));
 	@Override
 	public Void visitGetter(GetterMember member) {
 		ValidationUtils.validateIdentifier(validator, member.position, member.name);
-		new TypeValidator(validator, member.position).validate(TypeContext.GETTER_TYPE, member.type);
-		validateGetter(member, new MethodStatementScope(new FunctionHeader(member.type), member.getAccessScope()));
+		new TypeValidator(validator, member.position).validate(TypeContext.GETTER_TYPE, member.getType());
+		validateGetter(member, new MethodStatementScope(new FunctionHeader(member.getType()), member.getAccessScope()));
 		return null;
 	}
 
 	@Override
 	public Void visitSetter(SetterMember member) {
 		ValidationUtils.validateIdentifier(validator, member.position, member.name);
-		new TypeValidator(validator, member.position).validate(TypeContext.SETTER_TYPE, member.type);
+		new TypeValidator(validator, member.position).validate(TypeContext.SETTER_TYPE, member.getType());
 		validateSetter(member, new MethodStatementScope(new FunctionHeader(BasicTypeID.VOID, member.parameter), member.getAccessScope()));
 		return null;
 	}
 			StatementValidator statementValidator = new StatementValidator(validator, scope);
 			member.body.accept(statementValidator);
 			
-			validateThrow(member, new FunctionHeader(member.type), member.body);
+			validateThrow(member, new FunctionHeader(member.getType()), member.body);
 		}
 	}
 	
 		if (member.body != null) {
 			StatementValidator statementValidator = new StatementValidator(validator, scope);
 			member.body.accept(statementValidator);
-			validateThrow(member, new FunctionHeader(BasicTypeID.VOID, member.type), member.body);
+			validateThrow(member, new FunctionHeader(BasicTypeID.VOID, member.getType()), member.body);
 		}
 	}
 	

Validator/src/main/java/org/openzen/zenscript/validator/visitors/DefinitionValidator.java

 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.GenericName;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 			for (AnnotationDefinition annotation : annotations)
 				this.annotations.put(annotation.getAnnotationName(), annotation);
 		}
+
+		@Override
+		public ZSPackage getRootPackage() {
+			throw new UnsupportedOperationException();
+		}
 		
 		@Override
 		public LocalMemberCache getMemberCache() {