Revamped the compilation system; it now works fully modular. Also, a new ScriptingEngine class has been created to make it very easy to create a scripting environment.

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

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 		return new FunctionHeader(resultTypeParameters, resultReturnType, resultThrownType, resultStorage, resultParameters);
 	}
 	
-	public boolean matchesExactly(CallArguments arguments, TypeScope scope) {
+	public boolean matchesExactly(CodePosition position, CallArguments arguments, TypeScope scope) {
 		if (arguments.arguments.length < minParameters || arguments.arguments.length > maxParameters)
 			return false;
 		
-		FunctionHeader header = fillGenericArguments(scope, arguments.typeArguments);
+		FunctionHeader header = fillGenericArguments(position, scope, arguments.typeArguments);
 		for (int i = 0; i < header.parameters.length; i++) {
 			if (!arguments.arguments[i].type.equals(header.parameters[i].type))
 				return false;
 		return true;
 	}
 	
-	public boolean matchesImplicitly(CallArguments arguments, TypeScope scope) {
+	public boolean matchesImplicitly(CodePosition position, CallArguments arguments, TypeScope scope) {
 		if (arguments.arguments.length < minParameters || arguments.arguments.length > maxParameters)
 			return false;
 		
-		FunctionHeader header = fillGenericArguments(scope, arguments.typeArguments);
+		FunctionHeader header = fillGenericArguments(position, scope, arguments.typeArguments);
 		for (int i = 0; i < header.parameters.length; i++) {
 			if (!scope.getTypeMembers(arguments.arguments[i].type).canCastImplicit(header.parameters[i].type))
 				return false;
 		return true;
 	}
 	
-	public FunctionHeader instanceForCall(GlobalTypeRegistry registry, CallArguments arguments) {
+	public FunctionHeader instanceForCall(CodePosition position, GlobalTypeRegistry registry, CallArguments arguments) {
 		if (arguments.getNumberOfTypeArguments() > 0) {
 			Map<TypeParameter, StoredType> typeParameters = StoredType.getMapping(this.typeParameters, arguments.typeArguments);
-			return instance(new GenericMapper(registry, typeParameters));
+			return instance(new GenericMapper(position, registry, typeParameters));
 		} else {
 			return this;
 		}
 	
 	public FunctionHeader withGenericArguments(GenericMapper mapper) {
 		if (typeParameters.length > 0)
-			mapper = mapper.getInner(mapper.registry, StoredType.getSelfMapping(mapper.registry, typeParameters));
+			mapper = mapper.getInner(mapper.position, mapper.registry, StoredType.getSelfMapping(mapper.registry, typeParameters));
 		
 		return instance(mapper);
 	}
 		return new FunctionHeader(typeParameters, returnType, thrownType == null ? null : thrownType.instance(mapper), storage, parameters);
 	}
 	
-	public FunctionHeader fillGenericArguments(TypeScope scope, StoredType[] arguments) {
+	public FunctionHeader fillGenericArguments(CodePosition position, TypeScope scope, StoredType[] arguments) {
 		if (arguments == null || arguments.length == 0)
 			return this;
 		
 		Map<TypeParameter, StoredType> typeArguments = StoredType.getMapping(typeParameters, arguments);
-		GenericMapper mapper = scope.getLocalTypeParameters().getInner(scope.getTypeRegistry(), typeArguments);
+		GenericMapper mapper = scope.getLocalTypeParameters().getInner(position, scope.getTypeRegistry(), typeArguments);
 		
 		StoredType returnType = this.returnType.instance(mapper);
 		FunctionParameter[] parameters = new FunctionParameter[this.parameters.length];

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

 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
  * @author Hoofdgebruiker
  */
 public class GenericMapper {
-	public static final GenericMapper EMPTY = new GenericMapper(null, Collections.emptyMap());
+	public static final GenericMapper EMPTY = new GenericMapper(CodePosition.BUILTIN, null, Collections.emptyMap());
 	
+	public final CodePosition position;
 	public final GlobalTypeRegistry registry;
 	private final Map<TypeParameter, StoredType> mapping;
 	
-	public GenericMapper(GlobalTypeRegistry registry, Map<TypeParameter, StoredType> mapping) {
+	public GenericMapper(CodePosition position, GlobalTypeRegistry registry, Map<TypeParameter, StoredType> mapping) {
+		this.position = position;
 		this.registry = registry;
 		this.mapping = mapping;
 	}
 		return mapping.isEmpty() ? original : original.withGenericArguments(this);
 	}
 	
-	public GenericMapper getInner(GlobalTypeRegistry registry, Map<TypeParameter, StoredType> mapping) {
+	public GenericMapper getInner(CodePosition position, GlobalTypeRegistry registry, Map<TypeParameter, StoredType> mapping) {
 		Map<TypeParameter, StoredType> resultMap = new HashMap<>(this.mapping);
 		resultMap.putAll(mapping);
-		return new GenericMapper(registry, resultMap);
+		return new GenericMapper(position, registry, resultMap);
 	}
 	
-	public GenericMapper getInner(GlobalTypeRegistry registry, TypeParameter[] parameters) {
+	public GenericMapper getInner(CodePosition position, GlobalTypeRegistry registry, TypeParameter[] parameters) {
 		Map<TypeParameter, StoredType> resultMap = new HashMap<>(this.mapping);
 		for (TypeParameter parameter : parameters)
 			resultMap.put(parameter, new StoredType(registry.getGeneric(parameter), null));
-		return new GenericMapper(registry, resultMap);
+		return new GenericMapper(position, registry, resultMap);
 	}
 	
 	@Override

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

 
 		@Override
 		public Void visitStaticInitializer(StaticInitializerMember member) {
-			StatementScope scope = new FunctionScope(this.scope, new FunctionHeader(BasicTypeID.VOID));
+			StatementScope scope = new FunctionScope(member.position, this.scope, new FunctionHeader(BasicTypeID.VOID));
 			if (member.body == null) {
 				throw new IllegalStateException("No body in static initializer @ " + member.position);
 			} else {
 			if (member.body == null)
 				return null;
 			
-			StatementScope scope = new FunctionScope(this.scope, member.header);
+			StatementScope scope = new FunctionScope(member.position, this.scope, member.header);
 			member.body = process(member.body, scope);
 			return null;
 		}
 			if (member.body == null)
 				return null;
 			
-			StatementScope scope = new FunctionScope(this.scope, new FunctionHeader(member.getType()));
+			StatementScope scope = new FunctionScope(member.position, this.scope, new FunctionHeader(member.getType()));
 			member.body = process(member.body, scope);
 			return null;
 		}
 			if (member.body == null)
 				return null;
 			
-			StatementScope scope = new FunctionScope(this.scope, new FunctionHeader(BasicTypeID.VOID, member.parameter));
+			StatementScope scope = new FunctionScope(member.position, this.scope, new FunctionHeader(BasicTypeID.VOID, member.parameter));
 			member.body = process(member.body, scope);
 			return null;
 		}

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

 	public ExpressionScope getScopeForMember(IDefinitionMember member, BaseScope scope) {
 		if (member instanceof FunctionalMember) {
 			FunctionHeader header = ((FunctionalMember)member).header;
-			return new ExpressionScope(new FunctionScope(scope, header));
+			return new ExpressionScope(new FunctionScope(((FunctionalMember) member).position, scope, header));
 		} else {
 			throw new UnsupportedOperationException("Can only assign preconditions to methods");
 		}
 	public ExpressionScope getScopeForType(HighLevelDefinition definition, BaseScope scope) {
 		if (definition instanceof FunctionDefinition) {
 			FunctionHeader header = ((FunctionDefinition)definition).header;
-			return new ExpressionScope(new FunctionScope(scope, header));
+			return new ExpressionScope(new FunctionScope(((FunctionDefinition) definition).position, scope, header));
 		} else {
 			throw new UnsupportedOperationException("Can only assign preconditions to functions");
 		}
 	public MemberAnnotation deserializeForMember(CodeSerializationInput input, TypeContext context, IDefinitionMember member) {
 		CodePosition position = input.deserializePosition();
 		String enforcement = input.readString();
-		StatementContext statementContext = new StatementContext(context, member.getHeader());
+		StatementContext statementContext = new StatementContext(position, context, member.getHeader());
 		Expression condition = input.deserializeExpression(statementContext);
 		Expression message = input.deserializeExpression(statementContext);
 		return new PreconditionForMethod(position, enforcement, condition, message);

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

 	public void serialize(CodeSerializationOutput output, IDefinitionMember member, TypeContext context) {
 		output.serialize(position);
 		output.writeString(enforcement);
-		StatementContext statementContext = new StatementContext(context, member.getHeader());
+		StatementContext statementContext = new StatementContext(position, context, member.getHeader());
 		output.serialize(statementContext, condition);
 		output.serialize(statementContext, message);
 	}

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

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.expression.LambdaClosure;
 	
 	public VariantOptionSwitchValue variantOptionSwitchValue;
 	
-	public StatementContext(ModuleContext module, StoredType thisType) {
-		super(module, TypeParameter.NONE, thisType);
+	public StatementContext(CodePosition position, ModuleContext module, StoredType thisType) {
+		super(position, module, TypeParameter.NONE, thisType);
 		
 		loops = LoopStatement.NONE;
 		header = null;
 		lambdaOuter = null;
 	}
 	
-	public StatementContext(ModuleContext module, StoredType thisType, FunctionHeader header) {
-		super(module, header.typeParameters, thisType);
+	public StatementContext(CodePosition position, ModuleContext module, StoredType thisType, FunctionHeader header) {
+		super(position, module, header.typeParameters, thisType);
 		
 		loops = LoopStatement.NONE;
 		this.header = header;
 		lambdaOuter = null;
 	}
 	
-	public StatementContext(TypeContext outer) {
-		super(outer.moduleContext, outer.typeParameters, outer.thisType);
+	public StatementContext(CodePosition position, TypeContext outer) {
+		super(position, outer.moduleContext, outer.typeParameters, outer.thisType);
+		
 		loops = LoopStatement.NONE;
 		header = null;
 		closure = null;
 		lambdaOuter = null;
 	}
 	
-	public StatementContext(TypeContext outer, FunctionHeader header) {
-		super(outer, outer.thisType, header == null ? TypeParameter.NONE : header.typeParameters);
+	public StatementContext(CodePosition position, TypeContext outer, FunctionHeader header) {
+		super(position, outer, outer.thisType, header == null ? TypeParameter.NONE : header.typeParameters);
+		
 		loops = LoopStatement.NONE;
 		this.header = header;
 		closure = null;
 	}
 	
 	public StatementContext(StatementContext outer) {
-		super(outer.moduleContext, outer.typeParameters, outer.thisType);
+		super(outer.position, outer.moduleContext, outer.typeParameters, outer.thisType);
 		
 		variables.addAll(outer.variables);
 		loops = outer.loops;
 	}
 	
 	public StatementContext(StatementContext outer, LoopStatement loop) {
-		super(outer.moduleContext, outer.typeParameters, outer.thisType);
+		super(outer.position, outer.moduleContext, outer.typeParameters, outer.thisType);
 		
 		variables.addAll(outer.variables);
 		loops = Arrays.copyOf(outer.loops, outer.loops.length + 1);
 	}
 	
 	public StatementContext(StatementContext outer, FunctionHeader lambdaHeader, LambdaClosure lambdaClosure) {
-		super(outer, outer.thisType, lambdaHeader.typeParameters);
+		super(outer.position, outer, outer.thisType, lambdaHeader.typeParameters);
 		
 		loops = LoopStatement.NONE;
 		header = lambdaHeader;

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

 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.StoredType;
  * @author Hoofdgebruiker
  */
 public class TypeContext {
+	protected final CodePosition position;
 	protected final TypeParameter[] typeParameters;
 	public final StoredType thisType;
 	private final LocalMemberCache memberCache;
 	public final ModuleContext moduleContext;
 	
-	public TypeContext(ModuleContext context, TypeParameter[] parameters, StoredType thisType) {
+	public TypeContext(CodePosition position, ModuleContext context, TypeParameter[] parameters, StoredType thisType) {
+		this.position = position;
 		this.typeParameters = parameters;
 		this.thisType = thisType;
 		memberCache = new LocalMemberCache(context.registry, context.expansions);
 		moduleContext = context;
 	}
 	
-	public TypeContext(TypeContext outer, StoredType thisType, TypeParameter... inner) {
+	public TypeContext(CodePosition position, TypeContext outer, StoredType thisType, TypeParameter... inner) {
+		this.position = position;
 		typeParameters = concat(outer.typeParameters, inner);
 		this.thisType = thisType;
 		moduleContext = outer.moduleContext;
 		memberCache = new LocalMemberCache(moduleContext.registry, moduleContext.expansions);
 	}
 	
-	public TypeContext(TypeContext outer, StoredType thisType, List<TypeParameter> inner) {
-		this(outer, thisType, inner.toArray(new TypeParameter[inner.size()]));
+	public TypeContext(CodePosition position, TypeContext outer, StoredType thisType, List<TypeParameter> inner) {
+		this(position, outer, thisType, inner.toArray(new TypeParameter[inner.size()]));
 	}
 	
 	public int getId(TypeParameter parameter) {
 	
 	public GenericMapper getMapper() {
 		Map<TypeParameter, StoredType> mapper = StoredType.getSelfMapping(moduleContext.registry, typeParameters);
-		return new GenericMapper(moduleContext.registry, mapper);
+		return new GenericMapper(position, moduleContext.registry, mapper);
 	}
 	
 	public static <T> T[] concat(T[] first, T[] second) {

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

 	}
 	
 	@Override
-	public List<StoredType>[] predictCallTypes(TypeScope scope, List<StoredType> hints, int arguments) {
-		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).predictCallTypes(scope, hints, arguments);
+	public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) {
+		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).predictCallTypes(position, scope, hints, arguments);
 	}
 	
 	@Override

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

 		this.scope = scope;
 	}
 	
-	public Expression constructNew(String typename, Expression... arguments) throws CompileException {
+	public Expression constructNew(CodePosition position, String typename, Expression... arguments) throws CompileException {
 		String[] nameParts = Strings.split(typename, '.');
 		List<GenericName> name = new ArrayList<>();
 		for (String namePart : nameParts)
 		if (type == null)
 			throw new CompileException(position, CompileExceptionCode.NO_SUCH_TYPE, "No such type: " + typename);
 		
-		return constructNew(type.stored(UniqueStorageTag.INSTANCE), arguments);
+		return constructNew(position, type.stored(UniqueStorageTag.INSTANCE), arguments);
 	}
 	
-	public Expression constructNew(StoredType type, Expression... arguments) throws CompileException {
+	public Expression constructNew(CodePosition position, StoredType type, Expression... arguments) throws CompileException {
 		TypeMemberGroup constructors = scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CONSTRUCTOR);
-		List<StoredType>[] predictedTypes = constructors.predictCallTypes(scope, scope.hints, arguments.length);
+		List<StoredType>[] predictedTypes = constructors.predictCallTypes(position, scope, scope.hints, arguments.length);
 		CallArguments compiledArguments = new CallArguments(arguments);
 		FunctionalMemberRef member = constructors.selectMethod(position, scope, compiledArguments, true, true);
 		if (member == null)
 				type,
 				member,
 				compiledArguments,
-				compiledArguments.getNumberOfTypeArguments() == 0 ? member.getHeader() : member.getHeader().fillGenericArguments(scope, compiledArguments.typeArguments));
+				compiledArguments.getNumberOfTypeArguments() == 0 ? member.getHeader() : member.getHeader().fillGenericArguments(CodePosition.BUILTIN, scope, compiledArguments.typeArguments));
 	}
 	
 	public Expression not(Expression value) throws CompileException {

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.expression;
+
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
+import org.openzen.zenscript.codemodel.partial.IPartialExpression;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.type.ISymbol;
+import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ExpressionSymbol implements ISymbol {
+	private final BiFunction<CodePosition, BaseScope, IPartialExpression> function;
+	
+	public ExpressionSymbol(BiFunction<CodePosition, BaseScope, IPartialExpression> function) {
+		this.function = function;
+	}
+
+	@Override
+	public IPartialExpression getExpression(CodePosition position, BaseScope scope, StoredType[] typeArguments) {
+		return function.apply(position, scope);
+	}
+
+	@Override
+	public TypeID getType(CodePosition position, TypeResolutionContext context, StoredType[] typeArguments) {
+		return null;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/IPartialExpression.java

 	
 	Expression eval() throws CompileException;
 	
-	List<StoredType>[] predictCallTypes(TypeScope scope, List<StoredType> hints, int arguments) throws CompileException;
+	List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) throws CompileException;
 	
 	List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) throws CompileException;
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialGlobalExpression.java

 	}
 
 	@Override
-	public List<StoredType>[] predictCallTypes(TypeScope scope, List<StoredType> hints, int arguments) throws CompileException {
-		return resolution.predictCallTypes(scope, hints, arguments);
+	public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) throws CompileException {
+		return resolution.predictCallTypes(position, scope, hints, arguments);
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialMemberGroupExpression.java

 	}
 
 	@Override
-	public List<StoredType>[] predictCallTypes(TypeScope scope, List<StoredType> hints, int arguments) {
-		return group.predictCallTypes(scope, hints, arguments);
+	public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) {
+		return group.predictCallTypes(position, scope, hints, arguments);
 	}
 	
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialPackageExpression.java

 	}
 
 	@Override
-	public List<StoredType>[] predictCallTypes(TypeScope scope, List<StoredType> hints, int arguments) {
+	public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) {
 		return new List[arguments];
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialStaticMemberGroupExpression.java

 	}
 
 	@Override
-	public List<StoredType>[] predictCallTypes(TypeScope scope, List<StoredType> hints, int arguments) {
-		return group.predictCallTypes(scope, hints, arguments);
+	public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) {
+		return group.predictCallTypes(position, scope, hints, arguments);
 	}
 	
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialTypeExpression.java

 	}
 
 	@Override
-	public List<StoredType>[] predictCallTypes(TypeScope scope, List<StoredType> hints, int arguments) {
-		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).predictCallTypes(scope, hints, arguments);
+	public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) {
+		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).predictCallTypes(position, scope, hints, arguments);
 	}
 	
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialVariantOptionExpression.java

 	}
 
 	@Override
-	public List<StoredType>[] predictCallTypes(TypeScope scope, List<StoredType> hints, int arguments) {
+	public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) {
 		if (arguments != option.getOption().types.length)
 			return new List[0];
 		

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

 		}
 		
 		members = withMembers ? outer.getMemberCache().get(type) : null;
-		typeParameterMap = outer.getLocalTypeParameters().getInner(getTypeRegistry(), typeParameters);
+		typeParameterMap = outer.getLocalTypeParameters().getInner(definition.position, getTypeRegistry(), typeParameters);
 	}
 	
 	public void addInnerType(String name, Supplier<HighLevelDefinition> innerType) {

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

 	private final StoredType thisType;
 	private final DollarEvaluator dollar;
 	
-	public FunctionScope(BaseScope outer, FunctionHeader header) {
-		this(outer, header, null);
+	public FunctionScope(CodePosition position, BaseScope outer, FunctionHeader header) {
+		this(position, outer, header, null);
 	}
 	
-	public FunctionScope(BaseScope outer, FunctionHeader header, DollarEvaluator dollar) {
+	public FunctionScope(CodePosition position, BaseScope outer, FunctionHeader header, DollarEvaluator dollar) {
 		this.outer = outer;
 		this.header = header;
 		this.thisType = outer.getThisType() == null || header.storage == null ? outer.getThisType() : outer.getThisType().type.stored(header.storage);
 		if (header == null)
 			throw new NullPointerException();
 		
-		typeParameterMap = outer.getLocalTypeParameters().getInner(outer.getTypeRegistry(), header.typeParameters);
+		typeParameterMap = outer.getLocalTypeParameters().getInner(position, outer.getTypeRegistry(), header.typeParameters);
 	}
 	
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/BasicTypeID.java

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
-import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 
 /**
  *

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/DefinitionTypeID.java

 			Map<TypeParameter, StoredType> typeMapping = new HashMap<>();
 			for (int i = 0; i < definition.typeParameters.length; i++)
 				typeMapping.put(definition.typeParameters[i], typeArguments[i].getNormalized());
-			GenericMapper mapper = new GenericMapper(typeRegistry, typeMapping);
+			GenericMapper mapper = new GenericMapper(definition.position, typeRegistry, typeMapping);
 			TypeID result = alias.type.instance(mapper, null).type.getNormalized();
 			return result;
 		}
 	
 	@Override
 	public TypeID getSuperType(GlobalTypeRegistry registry) {
-		return definition.getSuperType() == null ? null : definition.getSuperType().instance(new GenericMapper(registry, getTypeParameterMapping()), null).type;
+		return definition.getSuperType() == null ? null : definition.getSuperType().instance(new GenericMapper(definition.position, registry, getTypeParameterMapping()), null).type;
 	}
 	
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/GenericTypeID.java

 	@Override
 	public StoredType instance(GenericMapper mapper, StorageTag storage) {
 		StoredType mapped = mapper.map(this);
-		return new StoredType(mapped.type, StorageTag.union(mapped.getSpecifiedStorage(), storage));
+		return new StoredType(mapped.type, StorageTag.union(mapper.position, mapped.getSpecifiedStorage(), storage));
 	}
 	
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/OptionalTypeID.java

 	@Override
 	public StoredType instance(GenericMapper mapper, StorageTag storage) {
 		StoredType base = baseType.instance(mapper, storage);
-		return mapper.registry.getOptional(base.type).stored(StorageTag.union(base.getSpecifiedStorage(), storage));
+		return mapper.registry.getOptional(base.type).stored(StorageTag.union(mapper.position, base.getSpecifiedStorage(), storage));
 	}
 	
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/StoredType.java

 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;

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

 			if (mapping == null)
 				continue;
 			
-			GenericMapper mapper = new GenericMapper(registry, mapping);
+			GenericMapper mapper = new GenericMapper(definition.position, registry, mapping);
 			for (IDefinitionMember member : expansion.members)
 				member.registerTo(members, TypeMemberPriority.SPECIFIED, mapper);
 		}
 	public Void visitGenericMap(Void context, GenericMapTypeID map) {
 		TypeParameter functionParameter = new TypeParameter(BUILTIN, "T");
 		Map<TypeParameter, StoredType> parameterFilled = Collections.singletonMap(map.key, registry.getGeneric(functionParameter).stored());
-		StoredType valueType = map.value.instance(new GenericMapper(registry, parameterFilled));
+		StoredType valueType = map.value.instance(new GenericMapper(CodePosition.BUILTIN, registry, parameterFilled));
 		
 		FunctionHeader getOptionalHeader = new FunctionHeader(
 				new TypeParameter[] { functionParameter },
 		GenericMapper mapper = null;
 		if (definitionType.hasTypeParameters() || (definitionType.outer != null && definitionType.outer.hasTypeParameters())) {
 			Map<TypeParameter, StoredType> mapping = definitionType.getTypeParameterMapping();
-			mapper = new GenericMapper(registry, mapping);
+			mapper = new GenericMapper(CodePosition.BUILTIN, registry, mapping);
 		}
 		
 		for (IDefinitionMember member : definition.members) {

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

 		}
 	}
 	
-	public List<StoredType>[] predictCallTypes(TypeScope scope, List<StoredType> typeHints, int arguments) {
+	public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> typeHints, int arguments) {
 		List<StoredType>[] result = (List<StoredType>[])(new List[arguments]);
 		for (int i = 0; i < result.length; i++)
 			result[i] = new ArrayList<>();
 				for (StoredType resultHint : typeHints) {
 					Map<TypeParameter, StoredType> mapping = header.getReturnType().inferTypeParameters(scope.getMemberCache(), resultHint);
 					if (mapping != null) {
-						header = header.withGenericArguments(scope.getLocalTypeParameters().getInner(scope.getTypeRegistry(), mapping));
+						header = header.withGenericArguments(scope.getLocalTypeParameters().getInner(position, scope.getTypeRegistry(), mapping));
 						break;
 					}
 				}
 	
 	public Expression call(CodePosition position, TypeScope scope, Expression target, CallArguments arguments, boolean allowStaticUsage) throws CompileException {
 		FunctionalMemberRef method = selectMethod(position, scope, arguments, true, allowStaticUsage);
-		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope, arguments.typeArguments);
+		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(position, scope, arguments.typeArguments);
 		for (int i = 0; i < arguments.arguments.length; i++) {
 			arguments.arguments[i] = arguments.arguments[i].castImplicit(position, scope, instancedHeader.parameters[i].type);
 		}
 			CompareType compareType) throws CompileException
 	{
 		FunctionalMemberRef method = selectMethod(position, scope, arguments, true, false);
-		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope, arguments.typeArguments);
+		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(position, scope, arguments.typeArguments);
 		return method.callWithComparator(position, compareType, target, instancedHeader, arguments, scope);
 	}
 	
 	public Expression callStatic(CodePosition position, TypeID target, TypeScope scope, CallArguments arguments) throws CompileException {
 		FunctionalMemberRef method = selectMethod(position, scope, arguments, false, true);
-		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope, arguments.typeArguments);
+		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(position, scope, arguments.typeArguments);
 		return method.callStatic(position, target, instancedHeader, arguments, scope);
 	}
 	
 			if (!(method.member.isStatic() ? allowStatic : allowNonStatic))
 				continue;
 			
-			FunctionHeader header = method.member.getHeader().instanceForCall(scope.getTypeRegistry(), arguments);
-			if (header.matchesExactly(arguments, scope))
+			FunctionHeader header = method.member.getHeader().instanceForCall(position, scope.getTypeRegistry(), arguments);
+			if (header.matchesExactly(position, arguments, scope))
 				return method.member;
 		}
 		
 			
 			scope.getPreparer().prepare(method.member.getTarget());
 			
-			FunctionHeader header = method.member.getHeader().instanceForCall(scope.getTypeRegistry(), arguments);
-			if (!header.matchesImplicitly(arguments, scope))
+			FunctionHeader header = method.member.getHeader().instanceForCall(position, scope.getTypeRegistry(), arguments);
+			if (!header.matchesImplicitly(position, arguments, scope))
 				continue;
 			
 			if (selected != null) {
 				StringBuilder explanation = new StringBuilder();
-				FunctionHeader selectedHeader = selected.getHeader().instanceForCall(scope.getTypeRegistry(), arguments);
+				FunctionHeader selectedHeader = selected.getHeader().instanceForCall(position, scope.getTypeRegistry(), arguments);
 				explanation.append("Function A: ").append(selectedHeader.toString()).append("\n");
 				explanation.append("Function B: ").append(header.toString());
 				throw new CompileException(position, CompileExceptionCode.CALL_AMBIGUOUS, "Ambiguous call; multiple methods match:\n" + explanation.toString());
 					continue;
 				}
 				
-				FunctionHeader instancedHeader = method.member.getHeader().instanceForCall(scope.getTypeRegistry(), arguments);
+				FunctionHeader instancedHeader = method.member.getHeader().instanceForCall(position, scope.getTypeRegistry(), arguments);
 				message.append(instancedHeader.explainWhyIncompatible(scope, arguments)).append("\n");
 			}
 			

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/storage/StorageTag.java

  */
 package org.openzen.zenscript.codemodel.type.storage;
 
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileExceptionCode;
+
 /**
  *
  * @author Hoofdgebruiker
 	
 	boolean isImmutable();
 	
-	static StorageTag union(StorageTag minor, StorageTag major) {
+	static StorageTag union(CodePosition position, StorageTag minor, StorageTag major) {
 		if (minor == AutoStorageTag.INSTANCE || minor == null)
 			return major;
 		if (major == AutoStorageTag.INSTANCE || major == null)
 			return minor;
 		if (!minor.equals(major))
-			throw new IllegalArgumentException("Could not unite storage types: " + minor + " and " + major); // TODO: proper reporting
+			return new InvalidStorageTag(position, CompileExceptionCode.TYPE_CANNOT_UNITE, "Could not unite storage types: " + minor + " and " + major);
 		
 		return major;
 	}

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

 		if (state != State.VALIDATED)
 			throw new IllegalStateException("Module is not yet validated");
 		
-		ZenCodeCompilingModule module = compiler.addModule(this);
-		for (HighLevelDefinition definition : definitions.getAll()) {
-			module.addDefinition(definition);
-		}
-		for (ScriptBlock script : scripts) {
-			module.addScriptBlock(script);
-		}
-		module.finish();
+		compiler.addModule(this);
 	}
 	
 	public ModuleContext getContext() {

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

  * @author Hoofdgebruiker
  */
 public interface ZenCodeCompiler {
-	ZenCodeCompilingModule addModule(SemanticModule module);
+	void addModule(SemanticModule module);
 	
 	void finish();
 	

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

  */
 package org.openzen.zenscript.constructor;
 
+import java.io.File;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import org.json.JSONObject;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.compiler.SemanticModule;
+import org.openzen.zenscript.compiler.Target;
 import org.openzen.zenscript.compiler.TargetType;
-import org.openzen.zenscript.javabytecode.JavaBytecodeJarTargetType;
-import org.openzen.zenscript.javabytecode.JavaBytecodeRunTargetType;
-import org.openzen.zenscript.javasource.JavaSourceTargetType;
+import org.openzen.zenscript.compiler.ZenCodeCompiler;
+import org.openzen.zenscript.javabytecode.JavaBytecodeModule;
+import org.openzen.zenscript.javabytecode.JavaBytecodeRunUnit;
+import org.openzen.zenscript.javabytecode.JavaCompiler;
+import org.openzen.zenscript.javashared.JavaCompileSpace;
+import org.openzen.zenscript.javashared.SimpleJavaCompileSpace;
+import org.openzen.zenscript.javasource.JavaDirectoryOutput;
+import org.openzen.zenscript.javasource.JavaSourceCompiler;
+import org.openzen.zenscript.javasource.JavaSourceModule;
 
 /**
  *
 	private static final Map<String, TargetType> targetTypes = new HashMap<>();
 	
 	static {
-		registerTargetType("javaSource", JavaSourceTargetType.INSTANCE);
-		registerTargetType("javaBytecodeJar", JavaBytecodeJarTargetType.INSTANCE);
-		registerTargetType("javaBytecodeRun", JavaBytecodeRunTargetType.INSTANCE);
+		registerTargetType("javaSource", new JavaSourceTargetType());
+		registerTargetType("javaBytecodeJar", new JavaBytecodeTargetType());
+		registerTargetType("javaBytecodeRun", new JavaBytecodeTargetType());
 	}
 	
 	public static void registerTargetType(String name, TargetType type) {
 	}
 
 	private ConstructorRegistry() {}
+	
+	private static class JavaSourceTargetType implements TargetType {
+
+		@Override
+		public Target create(File projectDir, JSONObject definition) {
+			return new JavaSourceTarget(projectDir, definition);
+		}
+	}
+	
+	private static class JavaSourceTarget implements Target {
+		private final String module;
+		private final String name;
+		private final File output;
+
+		public JavaSourceTarget(File projectDir, JSONObject definition) {
+			module = definition.getString("module");
+			name = definition.optString("name", "Java Source: " + module);
+			output = new File(projectDir, definition.getString("output"));
+		}
+
+		@Override
+		public ZenCodeCompiler createCompiler(SemanticModule module) {
+			return new JavaSourceZenCompiler(output, module.registry);
+		}
+
+		@Override
+		public String getModule() {
+			return module;
+		}
+
+		@Override
+		public String getName() {
+			return name;
+		}
+
+		@Override
+		public boolean canRun() {
+			return false;
+		}
+
+		@Override
+		public boolean canBuild() {
+			return true;
+		}
+	}
+	
+	private static class JavaSourceZenCompiler implements ZenCodeCompiler {
+		private final File output;
+		private final JavaSourceCompiler compiler;
+		private final List<JavaSourceModule> modules = new ArrayList<>();
+		
+		public final GlobalTypeRegistry registry;
+		private final SimpleJavaCompileSpace space;
+		
+		public JavaSourceZenCompiler(File output, GlobalTypeRegistry registry) {
+			this.output = output;
+			compiler = new JavaSourceCompiler(registry);
+			this.registry = registry;
+			space = new SimpleJavaCompileSpace(registry);
+		}
+
+		@Override
+		public void addModule(SemanticModule module) {
+			JavaSourceModule result = compiler.compile(module, space, module.modulePackage.fullName);
+			modules.add(result);
+			space.register(result);
+		}
+
+		@Override
+		public void finish() {
+			JavaDirectoryOutput output = new JavaDirectoryOutput(this.output);
+			for (JavaSourceModule module : modules)
+				output.add(module);
+			output.add(compiler.helpers);
+		}
+
+		@Override
+		public void run() {
+			throw new UnsupportedOperationException();
+		}
+	}
+	
+	private static class JavaBytecodeTargetType implements TargetType {
+
+		@Override
+		public Target create(File projectDir, JSONObject definition) {
+			return new JavaBytecodeJarTarget(definition);
+		}
+	}
+	
+	private static class JavaBytecodeJarTarget implements Target {
+		private final String module;
+		private final String name;
+		private final File file;
+		private final boolean debugCompiler;
+
+		public JavaBytecodeJarTarget(JSONObject definition) {
+			module = definition.getString("module");
+			name = definition.getString("name");
+			file = new File(definition.getString("output"));
+			debugCompiler = definition.optBoolean("debugCompiler", false);
+		}
+
+		@Override
+		public ZenCodeCompiler createCompiler(SemanticModule module) {
+			return new JavaBytecodeJarCompiler();
+		}
+
+		@Override
+		public String getModule() {
+			return module;
+		}
+
+		@Override
+		public String getName() {
+			return name;
+		}
+
+		@Override
+		public boolean canRun() {
+			return true;
+		}
+
+		@Override
+		public boolean canBuild() {
+			return true;
+		}
+	}
+	
+	private static class JavaBytecodeJarCompiler implements ZenCodeCompiler {
+		private final ZSPackage root = ZSPackage.createRoot();
+		private final ZSPackage stdlib = new ZSPackage(root, "stdlib");
+		public final GlobalTypeRegistry registry = new GlobalTypeRegistry(stdlib);
+		
+		private final JavaCompiler compiler = new JavaCompiler();
+		private final List<JavaBytecodeModule> modules = new ArrayList<>();
+		private final JavaCompileSpace space = new SimpleJavaCompileSpace(registry);
+
+		@Override
+		public void addModule(SemanticModule module) {
+			JavaBytecodeModule result = compiler.compile(module.modulePackage.fullName, module, space);
+			modules.add(result);
+		}
+
+		@Override
+		public void finish() {
+			
+		}
+
+		@Override
+		public void run() {
+			JavaBytecodeRunUnit unit = new JavaBytecodeRunUnit();
+			for (JavaBytecodeModule module : modules)
+				unit.add(module);
+			//unit.add(compiler.helpers);
+			unit.run();
+		}
+	}
 }

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

 		String value() default "";
 	}
 	
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.CONSTRUCTOR)
+	@interface Constructor {}
+	
 	@Retention(RetentionPolicy.RUNTIME)
 	@Target(ElementType.METHOD)
 	@interface Method {

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

 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+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.javabytecode.compiler.JavaWriter;
+import org.openzen.zenscript.javashared.JavaCompileSpace;
 import org.openzen.zenscript.javashared.JavaContext;
 import org.openzen.zenscript.javashared.JavaMethod;
 import org.openzen.zenscript.javashared.JavaSynthesizedFunction;
  * @author Hoofdgebruiker
  */
 public class JavaBytecodeContext extends JavaContext {
-	private final JavaModule module;
+	private final JavaBytecodeModule target;
 	private final TypeGenerator typeGenerator;
 	private final JavaTypeInternalNameVisitor internalNameVisitor;
 	private final JavaTypeDescriptorVisitor descriptorVisitor;
 	private int lambdaCounter = 0;
 	
-	public JavaBytecodeContext(GlobalTypeRegistry registry, JavaModule module) {
-		super(registry);
+	public JavaBytecodeContext(JavaBytecodeModule target, JavaCompileSpace space, ZSPackage modulePackage, String basePackage) {
+		super(space, modulePackage, basePackage);
 		
-		this.module = module;
+		this.target = target;
 		
 		typeGenerator = new TypeGenerator();
 		internalNameVisitor = new JavaTypeInternalNameVisitor(this);
 	}
 	
 	public void register(String name, byte[] bytecode) {
-		module.register(name, bytecode);
+		target.addClass(name, bytecode);
 	}
 
     private void createLambdaInterface(JavaSynthesizedFunction function) {

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaBytecodeJarTarget.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.io.File;
-import org.json.JSONObject;
-import org.openzen.zenscript.compiler.SemanticModule;
-import org.openzen.zenscript.compiler.Target;
-
-/**
- * @author Hoofdgebruiker
- */
-public class JavaBytecodeJarTarget implements Target {
-	private final String module;
-	private final String name;
-	private final File file;
-	private final boolean debugCompiler;
-
-	public JavaBytecodeJarTarget(JSONObject definition) {
-		module = definition.getString("module");
-		name = definition.getString("name");
-		file = new File(definition.getString("output"));
-		debugCompiler = definition.optBoolean("debugCompiler", false);
-	}
-
-	@Override
-	public JavaCompiler createCompiler(SemanticModule module) {
-		return new JavaCompiler(module.registry, debugCompiler, file);
-	}
-
-	@Override
-	public String getModule() {
-		return module;
-	}
-
-	@Override
-	public String getName() {
-		return name;
-	}
-
-	@Override
-	public boolean canRun() {
-		return true;
-	}
-
-	@Override
-	public boolean canBuild() {
-		return true;
-	}
-}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaBytecodeJarTargetType.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 org.json.JSONObject;
-import org.openzen.zenscript.compiler.Target;
-import org.openzen.zenscript.compiler.TargetType;
-
-import java.io.File;
-
-/**
- * @author Hoofdgebruiker
- */
-public class JavaBytecodeJarTargetType implements TargetType {
-	public static final JavaBytecodeJarTargetType INSTANCE = new JavaBytecodeJarTargetType();
-
-	private JavaBytecodeJarTargetType() {
-	}
-
-	@Override
-	public Target create(File projectDir, JSONObject definition) {
-		return new JavaBytecodeJarTarget(definition);
-	}
-}

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

 	}
 	
 	public void addClass(String name, byte[] bytecode) {
+		if (bytecode == null)
+			return;
+		
 		classes.put(name, bytecode);
 	}
 	

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaBytecodeRunTarget.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 org.json.JSONObject;
-import org.openzen.zenscript.compiler.SemanticModule;
-import org.openzen.zenscript.compiler.Target;
-
-/**
- * @author Hoofdgebruiker
- */
-public class JavaBytecodeRunTarget implements Target {
-	private final String module;
-	private final String name;
-	private final boolean debugCompiler;
-
-	public JavaBytecodeRunTarget(JSONObject definition) {
-		module = definition.getString("module");
-		name = definition.getString("name");
-		debugCompiler = definition.optBoolean("debugCompiler", false);
-	}
-
-	@Override
-	public JavaCompiler createCompiler(SemanticModule module) {
-		return new JavaCompiler(module.registry, debugCompiler, null);
-	}
-
-	@Override
-	public String getModule() {
-		return module;
-	}
-
-	@Override
-	public String getName() {
-		return name;
-	}
-
-	@Override
-	public boolean canRun() {
-		return true;
-	}
-
-	@Override
-	public boolean canBuild() {
-		return true;
-	}
-}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaBytecodeRunTargetType.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 org.json.JSONObject;
-import org.openzen.zenscript.compiler.Target;
-import org.openzen.zenscript.compiler.TargetType;
-
-import java.io.File;
-
-/**
- * @author Hoofdgebruiker
- */
-public class JavaBytecodeRunTargetType implements TargetType {
-	public static final JavaBytecodeRunTargetType INSTANCE = new JavaBytecodeRunTargetType();
-
-	private JavaBytecodeRunTargetType() {
-	}
-
-	@Override
-	public Target create(File projectDir, JSONObject definition) {
-		return new JavaBytecodeRunTarget(definition);
-	}
-}

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

  */
 package org.openzen.zenscript.javabytecode;
 
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.HashMap;
 	}
 	
 	public void run() {
-		if (!scriptsWritten)
-			writeScripts();
+		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);
+			Logger.getLogger(JavaBytecodeRunUnit.class.getName()).log(Level.SEVERE, null, ex);
+		}
+	}
+	
+	public void dump(File directory) {
+		writeScripts();
+		
+		for (Map.Entry<String, byte[]> classEntry : classes.entrySet()) {
+			File output = new File(directory, classEntry.getKey() + ".class");
+			try (FileOutputStream outputStream = new FileOutputStream(output)) {
+				outputStream.write(classEntry.getValue());
+			} catch (IOException ex) {
+				ex.printStackTrace();
+			}
 		}
 	}
 	
 	private void writeScripts() {
+		if (scriptsWritten)
+			return;
+		
 		JavaClassWriter scriptsClassWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 		scriptsClassWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Scripts", null, "java/lang/Object", null);
 		
 		runWriter.end();
 		
 		classes.put("Scripts", scriptsClassWriter.toByteArray());
+		scriptsWritten = true;
 	}
 
 	public class ScriptClassLoader extends ClassLoader {

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

  */
 package org.openzen.zenscript.javabytecode;
 
-import java.io.File;
-import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.statement.Statement;
-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;
 import org.openzen.zenscript.javabytecode.compiler.JavaClassWriter;
 import org.openzen.zenscript.javabytecode.compiler.JavaScriptFile;
 import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
 import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
 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;
 import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionVisitor;
 /**
  * @author Hoofdgebruiker
  */
-public class JavaCompiler extends JavaBaseCompiler implements ZenCodeCompiler {
-	private final JavaModule target;
-	private final Map<String, JavaScriptFile> scriptBlocks = new HashMap<>();
-	private final JavaClassWriter scriptsClassWriter;
+public class JavaCompiler {
 	private int generatedScriptBlockCounter = 0;
-	private boolean finished = false;
-	private final File jarFile;
-	private final JavaBytecodeContext context;
 	
-	private final List<HighLevelDefinition> definitions = new ArrayList<>();
-	private final List<ScriptBlock> scripts = new ArrayList<>();
+	public JavaCompiler() {}
 	
-	public JavaCompiler(GlobalTypeRegistry registry, File jarFile) {
-		this(registry, false, jarFile);
-	}
-
-	public JavaCompiler(GlobalTypeRegistry registry, boolean debug, File jarFile) {
-		target = new JavaModule(new File("classes"));
-		this.jarFile = jarFile;
-		this.context = new JavaBytecodeContext(registry, target);
-		
-		scriptsClassWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
-		scriptsClassWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Scripts", null, "java/lang/Object", null);
-	}
-	
-	public JavaContext getContext() {
-		return context;
-	}
-	
-	//@Override
-	public JavaBytecodeModule compile(SemanticModule module, JavaCompileSpace space) {
-		context.addModule(module.module);
+	public JavaBytecodeModule compile(String packageName, SemanticModule module, JavaCompileSpace space) {
+		Map<String, JavaScriptFile> scriptBlocks = new HashMap<>();
 		
 		JavaBytecodeModule target = new JavaBytecodeModule(module.module);
+		JavaBytecodeContext context = new JavaBytecodeContext(target, space, module.modulePackage, packageName);
+		context.addModule(module.module, target);
+		
 		for (HighLevelDefinition definition : module.definitions.getAll()) {
-			JavaPrepareDefinitionMemberVisitor memberPreparer = new JavaPrepareDefinitionMemberVisitor(context, context.getJavaModule(definition.module));
+			String filename = getFilename(definition);
+			JavaPrepareDefinitionVisitor definitionPreparer = new JavaPrepareDefinitionVisitor(context, target, filename, null);
+			definition.accept(definitionPreparer);
+		}
+		
+		for (HighLevelDefinition definition : module.definitions.getAll()) {
+			JavaPrepareDefinitionMemberVisitor memberPreparer = new JavaPrepareDefinitionMemberVisitor(context, target);
 			definition.accept(memberPreparer);
 		}
 		
 		for (HighLevelDefinition definition : module.definitions.getAll()) {
 			String className = getClassName(definition.position.getFilename());
-			JavaScriptFile scriptFile = getScriptFile(className);
+			JavaScriptFile scriptFile = getScriptFile(scriptBlocks, definition.pkg.fullName + "/" + className);
 			
-			target.addClass(definition.name, definition.accept(new JavaDefinitionVisitor(context, scriptFile.classWriter)));
+			JavaClass cls = definition instanceof ExpansionDefinition ? context.getJavaExpansionClass(definition) : context.getJavaClass(definition);
+			target.addClass(cls.internalName, 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);
+			JavaScriptFile scriptFile = getScriptFile(scriptBlocks, 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);
+			JavaMethod method = JavaMethod.getStatic(new JavaClass(context.getPackageName(script.pkg), 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));
 		return target;
 	}
 	
-	@Override
-	public ZenCodeCompilingModule addModule(SemanticModule module) {
-		context.addModule(module.module);
-		
-		return new ZenCodeCompilingModule() {
-			@Override
-			public void addDefinition(HighLevelDefinition definition) {
-				JavaPrepareDefinitionVisitor preparer = new JavaPrepareDefinitionVisitor(context, context.getJavaModule(module.module), definition.position.getFilename(), null);
-				definition.accept(preparer);
-
-				definitions.add(definition);
-			}
-
-			@Override
-			public void addScriptBlock(ScriptBlock script) {
-				scripts.add(script);
-			}
-
-			@Override
-			public void finish() {
-				
-			}
-		};
+	private String getFilename(HighLevelDefinition definition) {
+		SourceFile source = definition.getTag(SourceFile.class);
+		if (source != null) {
+			int slash = Math.max(source.getFilename().lastIndexOf('/'), source.getFilename().lastIndexOf('\\'));
+			String filename = source.getFilename().substring(slash < 0 ? 0 : slash + 1);
+			filename = filename.substring(0, filename.lastIndexOf('.'));
+			return filename;
+		} else {
+			return definition.name == null ? "Expansion" : definition.name;
+		}
 	}
 
 	private String getClassName(String filename) {
 		}
 	}
 
-	private JavaScriptFile getScriptFile(String className) {
+	private JavaScriptFile getScriptFile(Map<String, JavaScriptFile> scriptBlocks, String className) {
 		if (!scriptBlocks.containsKey(className)) {
 			JavaClassWriter scriptFileWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 			scriptFileWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, className, null, "java/lang/Object", null);
 
 		return scriptBlocks.get(className);
 	}
-
-	@Override
-	public void finish() {
-		JavaModule module = finishAndGetModule();
-
-		if (jarFile != null) {
-			// TODO: write module to a Jar file
-		}
-	}
-
-	@Override
-	public void run() {
-		if (!finished)
-			throw new IllegalStateException("Not yet built!");
-		
-		// TODO: execute this
-	}
-
-	public JavaModule finishAndGetModule() {
-		if (finished)
-			throw new IllegalStateException("Already finished!");
-		
-		finished = true;
-		
-		for (HighLevelDefinition definition : definitions) {
-			JavaPrepareDefinitionMemberVisitor memberPreparer = new JavaPrepareDefinitionMemberVisitor(context, context.getJavaModule(definition.module));
-			definition.accept(memberPreparer);
-		}
-		
-		for (HighLevelDefinition definition : definitions) {
-			String className = getClassName(definition.position.getFilename());
-			JavaScriptFile scriptFile = getScriptFile(className);
-			
-			target.register(definition.name, definition.accept(new JavaDefinitionVisitor(context, scriptFile.classWriter)));
-		}
- 
-		for (ScriptBlock script : scripts) {
-			final SourceFile sourceFile = script.getTag(SourceFile.class);
-			final String className = getClassName(sourceFile == null ? null : sourceFile.getFilename());
-			JavaScriptFile scriptFile = getScriptFile(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();
-		}
-		
-		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 (Map.Entry<String, JavaScriptFile> entry : scriptBlocks.entrySet()) {
-			for (JavaMethod method : entry.getValue().scriptMethods)
-				runWriter.invokeStatic(method);
-
-			entry.getValue().classWriter.visitEnd();
-			target.register(entry.getKey(), entry.getValue().classWriter.toByteArray());
-		}
-		runWriter.ret();
-		runWriter.end();
-
-		target.register("Scripts", scriptsClassWriter.toByteArray());
-		return target;
-	}
 }

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaModule.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.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-/**
- * @author Hoofdgebruiker
- */
-public class JavaModule {
-	private final Map<String, byte[]> classes = new HashMap<>();
-	private final File debugOutput;
-	
-	public JavaModule() {
-		debugOutput = null;
-	}
-	
-	public JavaModule(File debugOutput) {
-		this.debugOutput = debugOutput;
-		debugOutput.mkdirs();
-	}
-	
-	public void register(String classname, byte[] bytecode) {
-		if (bytecode == null)
-			return;
-		
-		classname = classname.replace('/', '.');
-		classes.put(classname, bytecode);
-		
-		if (debugOutput != null) {
-			try (FileOutputStream writer = new FileOutputStream(new File(debugOutput, classname + ".class"))) {
-				writer.write(bytecode);
-			} catch (IOException e) {
-				e.printStackTrace();
-			}
-		}
-	}
-
-	public void execute() {
-		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);
-		}
-	}
-
-	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/compiler/JavaExpressionVisitor.java

 
     @Override
     public Void visitNew(NewExpression expression) {
-		// TODO: this code is incorrect!
 		JavaMethod method = context.getJavaMethod(expression.constructor);
-
-        final String type;
-        if (expression.type.type instanceof DefinitionTypeID)
-            type = ((DefinitionTypeID) expression.type.type).definition.name;
-        else
-            type = context.getDescriptor(expression.type);
-
-        javaWriter.newObject(type);
+        javaWriter.newObject(method.cls.internalName);
         javaWriter.dup();
 
 		for (Expression argument : expression.arguments.arguments) {

JavaIntegration/build.gradle

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

JavaIntegration/src/main/java/org/openzen/zencode/java/JavaNativeModule.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.reflect.AnnotatedType;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.PackageDefinitions;
+import org.openzen.zenscript.codemodel.definition.ClassDefinition;
+import org.openzen.zenscript.codemodel.definition.EnumDefinition;
+import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
+import org.openzen.zenscript.codemodel.definition.StructDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.expression.ExpressionSymbol;
+import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
+import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.member.CasterMember;
+import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.member.GetterMember;
+import org.openzen.zenscript.codemodel.member.MethodMember;
+import org.openzen.zenscript.codemodel.member.OperatorMember;
+import org.openzen.zenscript.codemodel.member.SetterMember;
+import org.openzen.zenscript.codemodel.partial.PartialStaticMemberGroupExpression;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ISymbol;
+import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
+import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
+import org.openzen.zenscript.compiler.ModuleSpace;
+import org.openzen.zenscript.compiler.SemanticModule;
+import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaCompiledModule;
+import org.openzen.zenscript.javashared.JavaField;
+import org.openzen.zenscript.javashared.JavaMethod;
+import stdlib.Strings;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaNativeModule {
+	public final Module module;
+	private final ZSPackage pkg;
+	private final String basePackage;
+	private final GlobalTypeRegistry registry;
+	private final boolean allowNonAnnonated;
+	private final PackageDefinitions definitions = new PackageDefinitions();
+	private final JavaCompiledModule compiled;
+	
+	private final Map<Class<?>, HighLevelDefinition> definitionByClass = new HashMap<>();
+	private final Map<Class<?>, TypeID> typeByClass = new HashMap<>();
+	private final Map<Class<?>, TypeID> unsignedByClass = new HashMap<>();
+	
+	public final Map<String, ISymbol> globals = new HashMap<>();
+	
+	public JavaNativeModule(ZSPackage pkg, String name, String basePackage, GlobalTypeRegistry registry, boolean allowNonAnnotated) {
+		this.pkg = pkg;
+		this.basePackage = basePackage;
+		module = new Module(name);
+		this.registry = registry;
+		
+		this.allowNonAnnonated = allowNonAnnotated;
+		compiled = new JavaCompiledModule(module);
+		
+		typeByClass.put(void.class, BasicTypeID.VOID);
+		typeByClass.put(boolean.class, BasicTypeID.BOOL);
+		typeByClass.put(byte.class, BasicTypeID.SBYTE);
+		typeByClass.put(short.class, BasicTypeID.SHORT);
+		typeByClass.put(int.class, BasicTypeID.INT);
+		typeByClass.put(long.class, BasicTypeID.LONG);
+		typeByClass.put(float.class, BasicTypeID.FLOAT);
+		typeByClass.put(double.class, BasicTypeID.DOUBLE);
+		typeByClass.put(String.class, StringTypeID.INSTANCE);
+		typeByClass.put(Boolean.class, registry.getOptional(BasicTypeID.BOOL));
+		typeByClass.put(Byte.class, registry.getOptional(BasicTypeID.BYTE));
+		typeByClass.put(Short.class, registry.getOptional(BasicTypeID.SHORT));
+		typeByClass.put(Integer.class, registry.getOptional(BasicTypeID.INT));
+		typeByClass.put(Long.class, registry.getOptional(BasicTypeID.LONG));
+		typeByClass.put(Float.class, registry.getOptional(BasicTypeID.FLOAT));
+		typeByClass.put(Double.class, registry.getOptional(BasicTypeID.DOUBLE));
+		
+		unsignedByClass.put(byte.class, BasicTypeID.BYTE);
+		unsignedByClass.put(short.class, BasicTypeID.USHORT);
+		unsignedByClass.put(int.class, BasicTypeID.UINT);
+		unsignedByClass.put(long.class, BasicTypeID.ULONG);
+		unsignedByClass.put(Byte.class, registry.getOptional(BasicTypeID.BYTE));
+		unsignedByClass.put(Short.class, registry.getOptional(BasicTypeID.SHORT));
+		unsignedByClass.put(Integer.class, registry.getOptional(BasicTypeID.INT));
+		unsignedByClass.put(Long.class, registry.getOptional(BasicTypeID.LONG));
+	}
+	
+	public SemanticModule toSemantic(ModuleSpace space) {
+		return new SemanticModule(
+				module,
+				SemanticModule.NONE,
+				SemanticModule.State.NORMALIZED,
+				space.rootPackage,
+				pkg,
+				definitions,
+				Collections.emptyList(),
+				space.registry,
+				space.collectExpansions(),
+				space.getAnnotations(),
+				space.getStorageTypes());
+	}
+	
+	public JavaCompiledModule getCompiled() {
+		return compiled;
+	}
+	
+	public HighLevelDefinition addClass(Class<?> cls) {
+		if (definitionByClass.containsKey(cls))
+			return definitionByClass.get(cls);
+		
+		HighLevelDefinition result = addClass(cls, ZenCodeType.class.isAssignableFrom(cls));
+		definitionByClass.put(cls, result);
+		return result;
+	}
+	
+	public void addGlobals(Class<?> cls) {
+		HighLevelDefinition definition = new ClassDefinition(CodePosition.NATIVE, module, pkg, "__globals__", Modifiers.PUBLIC);
+		JavaClass jcls = JavaClass.fromInternalName(getInternalName(cls), JavaClass.Kind.CLASS);
+		compiled.setClassInfo(definition, jcls);
+		StoredType thisType = registry.getForMyDefinition(definition).stored();
+		
+		for (Field field : cls.getDeclaredFields()) {
+			if (!field.isAnnotationPresent(ZenCodeGlobals.Global.class))
+				continue;
+			if (!isStatic(field.getModifiers()))
+				continue;
+			
+			ZenCodeGlobals.Global global = field.getAnnotation(ZenCodeGlobals.Global.class);
+			StoredType type = loadStoredType(field.getAnnotatedType());
+			String name = global.value().isEmpty() ? field.getName() : global.value();
+			FieldMember fieldMember = new FieldMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC | Modifiers.STATIC, name, thisType, type, registry, Modifiers.PUBLIC, 0, null);
+			definition.addMember(fieldMember);
+			compiled.setFieldInfo(fieldMember, new JavaField(jcls, name, getDescriptor(field.getType())));
+			globals.put(name, new ExpressionSymbol((position, scope) -> new StaticGetterExpression(CodePosition.BUILTIN, fieldMember.autoGetter.ref(thisType, GenericMapper.EMPTY))));
+		}
+		
+		for (Method method : cls.getDeclaredMethods()) {
+			if (!method.isAnnotationPresent(ZenCodeGlobals.Global.class))
+				continue;
+			if (!isStatic(method.getModifiers()))
+				continue;
+			
+			ZenCodeGlobals.Global global = method.getAnnotation(ZenCodeGlobals.Global.class);
+			String name = global.value().isEmpty() ? method.getName() : global.value();
+			MethodMember methodMember = new MethodMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC | Modifiers.STATIC, name, getHeader(method), null);
+			definition.addMember(methodMember);
+			
+			boolean isGenericResult = methodMember.header.getReturnType().isGeneric();
+			compiled.setMethodInfo(methodMember, new JavaMethod(jcls, JavaMethod.Kind.STATIC, name, false, getMethodDescriptor(method), method.getModifiers(), isGenericResult));
+			globals.put(name, new ExpressionSymbol((position, scope) -> {
+				TypeMembers members = scope.getTypeMembers(thisType);
+				return new PartialStaticMemberGroupExpression(position, scope, thisType.type, members.getGroup(name), StoredType.NONE);
+			}));
+		}
+	}
+	
+	private ZSPackage getPackage(String className) {
+		if (!className.contains("."))
+			return pkg;
+		
+		if (className.startsWith("."))
+			className = className.substring(1);
+		else if (className.startsWith(basePackage + "."))
+			className = className.substring(basePackage.length() + 1);
+		else
+			throw new IllegalArgumentException("Invalid class name: not in the given base package");
+		
+		String[] classNameParts = Strings.split(className, '.');
+		ZSPackage classPkg = pkg;
+		for (int i = 0; i < classNameParts.length - 1; i++)
+			classPkg = classPkg.getOrCreatePackage(classNameParts[i]);
+		
+		return classPkg;
+	}
+	
+	private <T> HighLevelDefinition addClass(Class<T> cls, boolean annotated) {
+		if (!annotated && !allowNonAnnonated)
+			throw new IllegalArgumentException("This class is not annotated as ZenCode class");
+		if ((cls.getModifiers() & Modifier.PUBLIC) == 0)
+			throw new IllegalArgumentException("Class must be public");
+		
+		ZenCodeType.Name name = cls.getDeclaredAnnotation(ZenCodeType.Name.class);
+		String className = name == null ? cls.getName() : name.value();
+		boolean isStruct = cls.getAnnotation(ZenCodeType.Struct.class) != null;
+		
+		ZSPackage classPkg = getPackage(className);
+		className = className.contains(".") ? className.substring(className.lastIndexOf('.') + 1) : className;
+		
+		TypeVariable<Class<T>>[] javaTypeParameters = cls.getTypeParameters();
+		TypeParameter[] typeParameters = new TypeParameter[cls.getTypeParameters().length];
+		for (int i = 0; i < javaTypeParameters.length; i++) {
+			TypeVariable<Class<T>> typeVariable = javaTypeParameters[i];
+			TypeParameter parameter = new TypeParameter(CodePosition.NATIVE, typeVariable.getName());
+			for (AnnotatedType bound : typeVariable.getAnnotatedBounds()) {
+				TypeID type = loadType(bound);
+				parameter.addBound(new ParameterTypeBound(CodePosition.NATIVE, type));
+			}
+		}
+		
+		HighLevelDefinition definition;
+		String internalName = getInternalName(cls);
+		JavaClass javaClass;
+		if (cls.isInterface()) {
+			definition = new InterfaceDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC, null);
+			javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.INTERFACE);
+		} else if (cls.isEnum()) {
+			definition = new EnumDefinition(CodePosition.NATIVE, module, pkg, className, Modifiers.PUBLIC, null);
+			javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.ENUM);
+		} else if (isStruct) {
+			definition = new StructDefinition(CodePosition.NATIVE, module, pkg, className, Modifiers.PUBLIC, null);
+			javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.CLASS);
+		} else {
+			definition = new ClassDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC);
+			javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.CLASS);
+		}
+		
+		definition.typeParameters = typeParameters;
+		compiled.setClassInfo(definition, javaClass);
+		
+		StoredType thisType = new StoredType(registry.getForMyDefinition(definition), AutoStorageTag.INSTANCE);
+		for (Field field : cls.getDeclaredFields()) {
+			ZenCodeType.Field annotation = field.getAnnotation(ZenCodeType.Field.class);
+			if (annotated && annotation == null)
+				continue;
+			if (!isPublic(field.getModifiers()))
+				continue;
+
+			String fieldName = field.getName();
+			if (annotation != null && !annotation.value().isEmpty())
+				fieldName = annotation.value();
+			
+			StoredType fieldType = loadStoredType(field.getAnnotatedType());
+			FieldMember member = new FieldMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC, fieldName, thisType, fieldType, registry, 0, 0, null);
+			definition.addMember(member);
+			compiled.setFieldInfo(member, new JavaField(javaClass, field.getName(), getDescriptor(field.getType())));
+		}
+		
+		for (Method method : cls.getDeclaredMethods()) {
+			ZenCodeType.Constructor constructorAnnotation = method.getAnnotation(ZenCodeType.Constructor.class);
+			if (constructorAnnotation != null || (!annotated && method.getName().equals("<init>"))) {
+				ConstructorMember member = asConstructor(definition, method);
+				definition.addMember(member);
+				compiled.setMethodInfo(member, getMethod(javaClass, method, BasicTypeID.VOID.stored));
+			}
+			
+			ZenCodeType.Method methodAnnotation = method.getAnnotation(ZenCodeType.Method.class);
+			if (methodAnnotation != null) {
+				MethodMember member = asMethod(definition, method, methodAnnotation);
+				definition.addMember(member);
+				compiled.setMethodInfo(member, getMethod(javaClass, method, member.header.getReturnType()));
+				continue;
+			}
+			
+			ZenCodeType.Getter getter = method.getAnnotation(ZenCodeType.Getter.class);
+			if (getter != null || (!annotated && isGetterName(method.getName()) && method.getParameterCount() == 0)) {
+				GetterMember member = asGetter(definition, method, getter);
+				definition.addMember(member);
+				compiled.setMethodInfo(member, getMethod(javaClass, method, member.getType()));
+				continue;
+			}
+			
+			ZenCodeType.Setter setter = method.getAnnotation(ZenCodeType.Setter.class);
+			if (setter != null || (!annotated && method.getName().startsWith("set") && method.getParameterCount() == 1)) {
+				SetterMember member = asSetter(definition, method, setter);
+				definition.addMember(member);
+				compiled.setMethodInfo(member, getMethod(javaClass, method, BasicTypeID.VOID.stored));
+				continue;
+			}
+			
+			ZenCodeType.Operator operator = method.getAnnotation(ZenCodeType.Operator.class);
+			if (operator != null) {
+				OperatorMember member = asOperator(definition, method, operator);
+				definition.addMember(member);
+				compiled.setMethodInfo(member, getMethod(javaClass, method, member.header.getReturnType()));
+				continue;
+			}
+			
+			ZenCodeType.Caster caster = method.getAnnotation(ZenCodeType.Caster.class);
+			if (caster != null) {
+				CasterMember member = asCaster(definition, method, caster);
+				definition.addMember(member);
+				compiled.setMethodInfo(member, getMethod(javaClass, method, member.toType));
+				continue;
+			}
+			
+			if (!annotated) {
+				MethodMember member = asMethod(definition, method, null);
+				definition.addMember(member);
+				compiled.setMethodInfo(member, getMethod(javaClass, method, member.header.getReturnType()));
+			}
+		}
+		
+		return definition;
+	}
+	
+	private boolean isGetterName(String name) {
+		return name.startsWith("get") || name.startsWith("is") || name.startsWith("has");
+	}
+	
+	private String translateGetterName(String name) {
+		if (name.startsWith("get"))
+			return name.substring(3, 4).toLowerCase() + name.substring(4);
+		
+		return name;
+	}
+	
+	private String translateSetterName(String name) {
+		if (name.startsWith("set"))
+			return name.substring(3, 4).toLowerCase() + name.substring(4);
+		
+		return name;
+	}
+	
+	private ConstructorMember asConstructor(HighLevelDefinition definition, Method method) {
+		FunctionHeader header = getHeader(method);
+		return new ConstructorMember(
+				CodePosition.NATIVE,
+				definition,
+				getMethodModifiers(method),
+				header,
+				null);
+	}
+	
+	private MethodMember asMethod(HighLevelDefinition definition, Method method, ZenCodeType.Method annotation) {
+		String name = annotation != null && !annotation.value().isEmpty() ? annotation.value() : method.getName();
+		FunctionHeader header = getHeader(method);
+		return new MethodMember(
+				CodePosition.NATIVE,
+				definition,
+				getMethodModifiers(method),
+				name,
+				header,
+				null);
+	}
+	
+	private OperatorMember asOperator(HighLevelDefinition definition, Method method, ZenCodeType.Operator annotation) {
+		FunctionHeader header = getHeader(method);
+		if (isStatic(method.getModifiers()))
+			throw new IllegalArgumentException("operator method cannot be static");
+		
+		// TODO: check number of parameters
+		//if (header.parameters.length != annotation.value().parameters)
+		
+		return new OperatorMember(
+				CodePosition.NATIVE,
+				definition,
+				getMethodModifiers(method),
+				OperatorType.valueOf(annotation.value().toString()),
+				header,
+				null);
+	}
+	
+	private GetterMember asGetter(HighLevelDefinition definition, Method method, ZenCodeType.Getter annotation) {
+		StoredType type = loadStoredType(method.getAnnotatedReturnType());
+		String name = null;
+		if (annotation != null && !annotation.value().isEmpty())
+			name = annotation.value();
+		if (name == null)
+			name = translateGetterName(method.getName());
+		
+		return new GetterMember(CodePosition.NATIVE, definition, getMethodModifiers(method), name, type, null);
+	}
+	
+	private SetterMember asSetter(HighLevelDefinition definition, Method method, ZenCodeType.Setter annotation) {
+		if (method.getParameterCount() != 1)
+			throw new IllegalArgumentException("Illegal setter: must have exactly 1 parameter");
+		
+		StoredType type = loadStoredType(method.getAnnotatedParameterTypes()[0]);
+		String name = null;
+		if (annotation != null && !annotation.value().isEmpty())
+			name = annotation.value();
+		if (name == null)
+			name = translateSetterName(method.getName());
+		
+		return new SetterMember(CodePosition.NATIVE, definition, getMethodModifiers(method), name, type, null);
+	}
+	
+	private CasterMember asCaster(HighLevelDefinition definition, Method method, ZenCodeType.Caster annotation) {
+		boolean implicit = annotation != null && annotation.implicit();
+		int modifiers = Modifiers.PUBLIC;
+		if (implicit)
+			modifiers |= Modifiers.IMPLICIT;
+		
+		StoredType toType = loadStoredType(method.getAnnotatedReturnType());
+		return new CasterMember(CodePosition.NATIVE, definition, modifiers, toType, null);
+	}
+	
+	private FunctionHeader getHeader(Method method) {
+		StoredType returnType = loadStoredType(method.getAnnotatedReturnType());
+		
+		FunctionParameter[] parameters = new FunctionParameter[method.getParameterCount()];
+		AnnotatedType[] parameterTypes = method.getAnnotatedParameterTypes();
+		for (int i = 0; i < parameters.length; i++) {
+			parameters[i] = new FunctionParameter(loadStoredType(parameterTypes[i]));
+		}
+		
+		TypeVariable<Method>[] javaTypeParameters = method.getTypeParameters();
+		TypeParameter[] typeParameters = new TypeParameter[javaTypeParameters.length];
+		for (int i = 0; i < javaTypeParameters.length; i++) {
+			TypeVariable<Method> javaTypeParameter = javaTypeParameters[i];
+			typeParameters[i] = new TypeParameter(CodePosition.UNKNOWN, javaTypeParameter.getName());
+			
+			for (AnnotatedType bound : javaTypeParameter.getAnnotatedBounds())
+				typeParameters[i].addBound(new ParameterTypeBound(CodePosition.NATIVE, loadType(bound)));
+		}
+		
+		AnnotatedType[] exceptionTypes = method.getAnnotatedExceptionTypes();
+		if (exceptionTypes.length > 1)
+			throw new IllegalArgumentException("A method can only throw a single exception type!");
+		
+		StoredType thrownType = exceptionTypes.length == 0 ? null : loadStoredType(exceptionTypes[0]);
+		return new FunctionHeader(typeParameters, returnType, thrownType, AutoStorageTag.INSTANCE, parameters);
+	}
+	
+	private StoredType loadStoredType(AnnotatedType annotatedType) {
+		TypeID baseType = loadType(annotatedType);
+		return baseType.stored();
+	}
+	
+	private TypeID loadType(AnnotatedType annotatedType) {
+		if (annotatedType.isAnnotationPresent(ZenCodeType.USize.class))
+			return BasicTypeID.USIZE;
+		else if (annotatedType.isAnnotationPresent(ZenCodeType.NullableUSize.class))
+			return registry.getOptional(BasicTypeID.USIZE);
+		
+		boolean nullable = annotatedType.isAnnotationPresent(ZenCodeType.Nullable.class);
+		boolean unsigned = annotatedType.isAnnotationPresent(ZenCodeType.Unsigned.class);
+		
+		Type type = annotatedType.getType();
+		return loadType(type, nullable, unsigned);
+	}
+	
+	private TypeID loadType(Type type, boolean nullable, boolean unsigned) {
+		if (type instanceof Class) {
+			Class<?> classType = (Class<?>)type;
+			if (unsigned) {
+				if (unsignedByClass.containsKey(classType))
+					return unsignedByClass.get(classType);
+				else
+					throw new IllegalArgumentException("This class cannot be used as unsigned: " + classType);
+			}
+			
+			if (typeByClass.containsKey(classType))
+				return typeByClass.get(classType);
+			
+			HighLevelDefinition definition = addClass(classType);
+			return registry.getForDefinition(definition);
+		} else if (type instanceof ParameterizedType) {
+			ParameterizedType parameterizedType = (ParameterizedType)type;
+			Class<?> rawType = (Class)parameterizedType.getRawType();
+			
+			HighLevelDefinition definition = addClass(rawType);
+			Type[] parameters = parameterizedType.getActualTypeArguments();
+			StoredType[] codeParameters = new StoredType[parameters.length];
+			for (int i = 0; i < parameters.length; i++)
+				codeParameters[i] = loadType(parameters[i], false, false).stored();
+			
+			return registry.getForDefinition(definition, codeParameters);
+		} else {
+			throw new IllegalArgumentException("Could not analyze type: " + type);
+		}
+	}
+	
+	private int getMethodModifiers(Method method) {
+		int result = Modifiers.PUBLIC;
+		if (isStatic(method.getModifiers()))
+			result |= Modifiers.STATIC;
+		if (isFinal(method.getModifiers()))
+			result |= Modifiers.FINAL;
+		
+		return result;
+	}
+	
+	private static boolean isPublic(int modifiers) {
+		return (modifiers & Modifier.PUBLIC) > 0;
+	}
+	
+	private static boolean isStatic(int modifiers) {
+		return (modifiers & Modifier.STATIC) > 0;
+	}
+	
+	private static boolean isFinal(int modifiers) {
+		return (modifiers & Modifier.FINAL) > 0;
+	}
+	
+	private static String getInternalName(Class<?> cls) {
+		return org.objectweb.asm.Type.getInternalName(cls);
+	}
+	
+	private static String getDescriptor(Class<?> cls) {
+		return org.objectweb.asm.Type.getDescriptor(cls);
+	}
+	
+	private static String getMethodDescriptor(Method method) {
+		return org.objectweb.asm.Type.getMethodDescriptor(method);
+	}
+	
+	private static JavaMethod getMethod(JavaClass cls, Method method, StoredType result) {
+		JavaMethod.Kind kind;
+		if (method.getName().equals("<init>"))
+			kind = JavaMethod.Kind.CONSTRUCTOR;
+		else if (method.getName().equals("<clinit>"))
+			kind = JavaMethod.Kind.STATICINIT;
+		else if (isStatic(method.getModifiers()))
+			kind = JavaMethod.Kind.STATIC;
+		else
+			kind = JavaMethod.Kind.INSTANCE;
+		
+		return new JavaMethod(cls, kind, method.getName(), false, getMethodDescriptor(method), method.getModifiers(), result.isGeneric());
+	}
+}

JavaIntegration/src/main/java/org/openzen/zencode/java/ScriptingEngine.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.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import org.openzen.zencode.shared.CompileException;
+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.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ISymbol;
+import org.openzen.zenscript.codemodel.type.storage.StorageType;
+import org.openzen.zenscript.compiler.ModuleSpace;
+import org.openzen.zenscript.compiler.SemanticModule;
+import org.openzen.zenscript.javabytecode.JavaBytecodeRunUnit;
+import org.openzen.zenscript.javabytecode.JavaCompiler;
+import org.openzen.zenscript.javashared.SimpleJavaCompileSpace;
+import org.openzen.zenscript.lexer.ParseException;
+import org.openzen.zenscript.parser.BracketExpressionParser;
+import org.openzen.zenscript.parser.ParsedFile;
+import org.openzen.zenscript.parser.ZippedPackage;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ScriptingEngine {
+	private final ZSPackage root = ZSPackage.createRoot();
+	private final ZSPackage stdlib = new ZSPackage(root, "stdlib");
+	public final GlobalTypeRegistry registry = new GlobalTypeRegistry(stdlib);
+	private final ModuleSpace space;
+	
+	private final List<JavaNativeModule> nativeModules = new ArrayList<>();
+	private final List<SemanticModule> compiledModules = new ArrayList<>();
+	
+	public ScriptingEngine() {
+		space = new ModuleSpace(registry, new ArrayList<>(), StorageType.getStandard());
+		
+		try {
+			ZippedPackage stdlibs = new ZippedPackage(ScriptingEngine.class.getResourceAsStream("/StdLibs.zip"));
+			SemanticModule stdlibModule = stdlibs.loadModule(space, "stdlib", null, new SemanticModule[0], stdlib);
+			stdlibModule.validate(error -> System.out.println(error.toString()));
+			space.addModule("stdlib", stdlibModule);
+		} catch (IOException ex) {
+			throw new RuntimeException(ex);
+		} catch (CompileException ex) {
+			throw new RuntimeException(ex);
+		} catch (ParseException ex) {
+			throw new RuntimeException(ex);
+		}
+	}
+	
+	public JavaNativeModule createNativeModule(String name, String basePackage, JavaNativeModule... dependencies) {
+		ZSPackage testPackage = new ZSPackage(space.rootPackage, name);
+		return new JavaNativeModule(testPackage, name, basePackage, registry, false);
+	}
+	
+	public void registerNativeProvided(JavaNativeModule module) throws CompileException {
+		SemanticModule semantic = module.toSemantic(space);
+		if (!semantic.validate(entry -> System.out.println(entry)))
+			return;
+		
+		space.addModule(module.module.name, semantic);
+		nativeModules.add(module);
+		
+		for (Map.Entry<String, ISymbol> globalEntry : module.globals.entrySet())
+			space.addGlobal(globalEntry.getKey(), globalEntry.getValue());
+	}
+	
+	public SemanticModule createScriptedModule(String name, SourceFile[] sources, String... dependencies) throws ParseException {
+		return createScriptedModule(name, sources, null, dependencies);
+	}
+	
+	public SemanticModule createScriptedModule(String name, SourceFile[] sources, BracketExpressionParser bracketParser, String... dependencies) throws ParseException {
+		Module scriptModule = new Module(name);
+		CompilingPackage scriptPackage = new CompilingPackage(new ZSPackage(space.rootPackage, name), scriptModule);
+		
+		ParsedFile[] files = new ParsedFile[sources.length];
+		for (int i = 0; i < sources.length; i++)
+			files[i] = ParsedFile.parse(scriptPackage, bracketParser, sources[i]);
+		
+		SemanticModule[] dependencyModules = new SemanticModule[dependencies.length + 1];
+		dependencyModules[0] = space.getModule("stdlib");
+		for (int i = 0; i < dependencies.length; i++) {
+			dependencyModules[i + 1] = space.getModule(dependencies[i]);
+		}
+		
+		SemanticModule scripts = ParsedFile.compileSyntaxToSemantic(
+				dependencyModules,
+				scriptPackage,
+				files,
+				space,
+				ex -> ex.printStackTrace());
+		if (!scripts.isValid())
+			return scripts;
+		
+		scripts = scripts.normalize();
+		if (!scripts.validate(error -> System.out.println(error.toString())))
+			return scripts;
+		
+		return scripts;
+	}
+	
+	public void registerCompiled(SemanticModule module) {
+		compiledModules.add(module);
+	}
+	
+	public void run() {
+		SimpleJavaCompileSpace javaSpace = new SimpleJavaCompileSpace(registry);
+		for (JavaNativeModule nativeModule : nativeModules)
+			javaSpace.register(nativeModule.getCompiled());
+		
+		JavaCompiler compiler = new JavaCompiler();
+		
+		JavaBytecodeRunUnit runUnit = new JavaBytecodeRunUnit();
+		for (SemanticModule compiled : compiledModules)
+			runUnit.add(compiler.compile(compiled.name, compiled, javaSpace));
+		runUnit.dump(new File("classes"));
+		runUnit.run();
+	}
+}

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

 package org.openzen.zenscript.javashared;
 
 import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public interface JavaCompileSpace {
+	public GlobalTypeRegistry getRegistry();
+	
 	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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 	private final Map<String, JavaSynthesizedRange> ranges = new HashMap<>();
 	private boolean useShared = false;
 	
+	private final JavaCompileSpace space;
 	private final Map<Module, JavaCompiledModule> modules = new HashMap<>();
 	
-	public JavaContext(GlobalTypeRegistry registry) {
-		this.registry = registry;
+	public final ZSPackage modulePackage;
+	public final String basePackage;
+	
+	public JavaContext(JavaCompileSpace space, ZSPackage modulePackage, String basePackage) {
+		this.space = space;
+		this.registry = space.getRegistry();
+		
+		this.modulePackage = modulePackage;
+		this.basePackage = basePackage;
 		
 		{
 			TypeParameter t = new TypeParameter(CodePosition.BUILTIN, "T");
 		}
 	}
 	
+	public String getPackageName(ZSPackage pkg) {
+		if (pkg == null)
+			throw new IllegalArgumentException("Package not part of this module");
+		
+		if (pkg == modulePackage)
+			return basePackage;
+		
+		return getPackageName(pkg.parent) + "/" + pkg.name;
+	}
+	
 	protected abstract JavaSyntheticClassGenerator getTypeGenerator();
 		
 	public abstract String getDescriptor(TypeID type);
 	
 	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));
+	public void addModule(Module module, JavaCompiledModule target) {
+		modules.put(module, target);
 	}
 	
 	public JavaCompiledModule getJavaModule(Module module) {
-		JavaCompiledModule javaModule = modules.get(module);
+		if (modules.containsKey(module))
+			return modules.get(module);
+		
+		JavaCompiledModule javaModule = space.getCompiled(module);
 		if (javaModule == null)
 			throw new IllegalStateException("Module not yet registered: " + module.name);
 		

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

 import java.util.HashMap;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class SimpleJavaCompileSpace implements JavaCompileSpace {
+	private final GlobalTypeRegistry registry;
 	private final Map<Module, JavaCompiledModule> modules = new HashMap<>();
 	
+	public SimpleJavaCompileSpace(GlobalTypeRegistry registry) {
+		this.registry = registry;
+	}
+	
 	public void register(JavaCompiledModule module) {
 		modules.put(module.module, module);
 	}
+
+	@Override
+	public GlobalTypeRegistry getRegistry() {
+		return registry;
+	}
 	
 	@Override
 	public JavaCompiledModule getCompiled(Module module) {

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

 		if (isPrepared(definition))
 			return context.getJavaClass(definition);
 		
-		JavaClass cls = new JavaClass(definition.pkg.fullName, JavaClass.getNameFromFile(filename), JavaClass.Kind.CLASS);
+		JavaClass cls = new JavaClass(context.getPackageName(definition.pkg), JavaClass.getNameFromFile(filename), JavaClass.Kind.CLASS);
 		context.setJavaClass(definition, cls);
 		return cls;
 	}
 			context.setJavaNativeClass(definition, nativeClasses.get(nativeTag.value));
 		}
 		
-		JavaClass cls = new JavaClass(definition.pkg.fullName, JavaClass.getNameFromFile(filename), JavaClass.Kind.CLASS);
+		JavaClass cls = new JavaClass(context.getPackageName(definition.pkg), JavaClass.getNameFromFile(filename), JavaClass.Kind.CLASS);
 		context.setJavaClass(definition, cls);
 		return cls;
 	}
 		if (isPrepared(variant))
 			return context.getJavaClass(variant);
 		
-		JavaClass cls = new JavaClass(variant.pkg.fullName, variant.name, JavaClass.Kind.CLASS);
+		JavaClass cls = new JavaClass(context.getPackageName(variant.pkg), variant.name, JavaClass.Kind.CLASS);
 		context.setJavaClass(variant, cls);
 		
 		for (VariantDefinition.Option option : variant.options) {
 		JavaNativeClass nativeClass = nativeTag == null ? null : nativeClasses.get(nativeTag.value);
 		JavaClass cls;
 		if (nativeClass == null) {
-			cls = outerClass == null ? new JavaClass(definition.pkg.fullName, definition.name, kind) : new JavaClass(outerClass, definition.name, kind);
+			cls = outerClass == null ? new JavaClass(context.getPackageName(definition.pkg), definition.name, kind) : new JavaClass(outerClass, definition.name, kind);
 			cls.destructible = definition.isDestructible();
 			context.setJavaClass(definition, cls);
 		} else {
-			cls = outerClass == null ? new JavaClass(definition.pkg.fullName, definition.name + "Expansion", kind) : new JavaClass(outerClass, definition.name + "Expansion", kind);
+			cls = outerClass == null ? new JavaClass(context.getPackageName(definition.pkg), definition.name + "Expansion", kind) : new JavaClass(outerClass, definition.name + "Expansion", kind);
 			
 			context.setJavaClass(definition, nativeClass.cls);
 			context.setJavaExpansionClass(definition, cls);

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

 import org.openzen.zenscript.javasource.scope.JavaSourceStatementScope;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
-import org.openzen.zenscript.javashared.JavaContext;
 import org.openzen.zenscript.javashared.JavaImplementation;
 
 /**
 	private final JavaSourceFormattingSettings settings;
 	private final List<ExpansionDefinition> expansions;
 	private final StringBuilder output;
-	private final JavaContext context;
+	private final JavaSourceContext context;
 	private final JavaCompiledModule module;
 	private final SemanticModule semanticModule;
 	
 	public JavaDefinitionVisitor(
 			String indent,
 			JavaSourceCompiler compiler,
+			JavaSourceContext context,
 			JavaCompiledModule module,
 			JavaClass cls,
 			JavaSourceFile file,
 		this.settings = compiler.settings;
 		this.output = output;
 		this.expansions = expansions;
-		this.context = compiler.context;
+		this.context = context;
 		this.module = module;
 		this.semanticModule = semanticModule;
 	}
 				semanticModule.expansions,
 				semanticModule.annotations,
 				semanticModule.storageTypes);
-		return new JavaSourceFileScope(file.importer, compiler.helperGenerator, cls, scope, definition instanceof InterfaceDefinition, thisType, compiler.context);
+		return new JavaSourceFileScope(file.importer, context, cls, scope, definition instanceof InterfaceDefinition, thisType);
 	}
 	
 	private List<ImplementationMember> getMergedImplementations(HighLevelDefinition definition) {
 				member.accept(memberCompiler);
 			memberCompiler.finish();
 		} else {
-			JavaMemberCompiler memberCompiler = new JavaMemberCompiler(compiler, module, file, settings, indent + settings.indent, output, scope, scope.isInterface, definition, semanticModule);
+			JavaMemberCompiler memberCompiler = new JavaMemberCompiler(compiler, context, module, file, settings, indent + settings.indent, output, scope, scope.isInterface, definition, semanticModule);
 			for (IDefinitionMember member : definition.members)
 				member.accept(memberCompiler);
 			

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaDirectoryOutput.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.javasource;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaDirectoryOutput {
+	private final File directory;
+	
+	public JavaDirectoryOutput(File directory) {
+		this.directory = directory;
+		
+		if (!directory.exists())
+			directory.mkdirs();
+	}
+	
+	public void add(JavaSourceModule module) {
+		for (JavaSourceModule.SourceFile file : module.sourceFiles) {
+			File target = new File(directory, file.filename);
+			if (!target.getParentFile().exists())
+				target.getParentFile().mkdirs();
+			
+			try (Writer output = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(target), StandardCharsets.UTF_8))) {
+				output.write(file.content);
+			} catch (IOException ex) {
+				ex.printStackTrace();
+			}
+		}
+	}
+}

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

 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
-import org.openzen.zenscript.javashared.JavaContext;
 import org.openzen.zenscript.javashared.JavaImplementation;
 import org.openzen.zenscript.javashared.JavaMethod;
 
 	private final JavaSourceFile file;
 	private final List<FieldMember> fields = new ArrayList<>();
 	private final boolean isInterface;
-	private final JavaContext context;
+	private final JavaSourceContext context;
 	public boolean hasDestructor = false;
 	private final JavaCompiledModule module;
 	private final SemanticModule semanticModule;
 	
 	public JavaMemberCompiler(
 			JavaSourceCompiler compiler,
+			JavaSourceContext context,
 			JavaCompiledModule module,
 			JavaSourceFile file,
 			JavaSourceFormattingSettings settings,
 		this.file = file;
 		this.isInterface = isInterface;
 		this.compiler = compiler;
-		this.context = compiler.context;
+		this.context = context;
 		this.module = module;
 		this.semanticModule = semanticModule;
 	}
 			
 			begin(ElementType.INNERCLASS);
 			output.append("private class ").append(implementationName).append(" implements ").append(scope.type(member.type)).append(" {\n");
-			JavaMemberCompiler memberCompiler = new JavaMemberCompiler(compiler, module, file, settings, indent + settings.indent, output, scope, isInterface, definition, semanticModule);
+			JavaMemberCompiler memberCompiler = new JavaMemberCompiler(compiler, context, module, file, settings, indent + settings.indent, output, scope, isInterface, definition, semanticModule);
 			for (IDefinitionMember m : member.members) {
 				m.accept(memberCompiler);
 			}
 		JavaDefinitionVisitor visitor = new JavaDefinitionVisitor(
 				indent, 
 				compiler,
+				context,
 				module,
 				cls,
 				file,

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

  */
 package org.openzen.zenscript.javasource;
 
-import java.io.File;
-import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.ScriptBlock;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 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;
-import org.openzen.zenscript.javashared.JavaBaseCompiler;
 import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionVisitor;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaCompileSpace;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class JavaSourceCompiler extends JavaBaseCompiler implements ZenCodeCompiler {
+public class JavaSourceCompiler {
 	public final JavaSourceFormattingSettings settings;
-	public final JavaSourceSyntheticHelperGenerator helperGenerator;
+	public final JavaSourceModule helpers;
 	
-	private final File directory;
-	public final JavaSourceContext context;
-	private final List<SourceModule> modules = new ArrayList<>();
-	
-	public JavaSourceCompiler(File directory, GlobalTypeRegistry registry) {
-		if (!directory.exists())
-			directory.mkdirs();
-		
+	public JavaSourceCompiler(GlobalTypeRegistry registry) {
+		helpers = new JavaSourceModule(new Module("helpers"));
 		settings = new JavaSourceFormattingSettings.Builder().build();
-		context = new JavaSourceContext(registry, directory, settings);
-		helperGenerator = new JavaSourceSyntheticHelperGenerator(context, directory, settings);
-		
-		this.directory = directory;
 	}
 	
-	@Override
-	public ZenCodeCompilingModule addModule(SemanticModule module) {
-		context.addModule(module.module);
-		SourceModule result = new SourceModule(module);
-		modules.add(result);
+	public JavaSourceModule compile(SemanticModule module, JavaCompileSpace space, String basePackage) {
+		JavaSourceContext context = new JavaSourceContext(helpers, settings, space, module.modulePackage, basePackage);
+		
+		JavaSourceModule result = new JavaSourceModule(module.module);
+		context.addModule(module.module, result);
+		
+		Map<String, JavaSourceFile> sourceFiles = new HashMap<>();
+		for (HighLevelDefinition definition : module.definitions.getAll()) {
+			String name = getFilename(definition);
+			JavaPrepareDefinitionVisitor prepare = new JavaPrepareDefinitionVisitor(context, context.getJavaModule(module.module), name, null);
+			JavaClass cls = definition.accept(prepare);
+
+			String filename = cls.getName() + ".java";
+			System.out.println("Compiling " + definition.name + " as " + cls.fullName);
+			JavaSourceFile sourceFile = sourceFiles.get(filename);
+			if (sourceFile == null)
+				sourceFiles.put(filename, sourceFile = new JavaSourceFile(JavaSourceCompiler.this, context, cls, module, definition.pkg));
+
+			sourceFile.add(definition);
+		}
+		
+		for (ScriptBlock scriptBlock : module.scripts) {
+			// TODO
+		}
+		
+		for (JavaSourceFile sourceFile : sourceFiles.values()) {
+			sourceFile.prepare(context);
+		}
+
+		String baseDirectory = basePackage.replace('.', '/');
+		for (Map.Entry<String, JavaSourceFile> entry : sourceFiles.entrySet())
+			result.addFile(baseDirectory + "/" + entry.getKey(), entry.getValue().generate());
+		
+		context.helperGenerator.write(); // TODO: move this elsewhere
 		return result;
 	}
 	
-	@Override
-	public void finish() {
-		helperGenerator.write();
-	}
-	
-	@Override
-	public void run() {
-		throw new UnsupportedOperationException("Cannot run this target");
-	}
-	
 	public String getFullName(HighLevelDefinition definition) {
 		return definition.pkg.fullName + "." + definition.name;
 	}
 	
-	private File getDirectory(ZSPackage pkg) {
-		if (pkg == null)
-			return directory;
-		
-		File base = getDirectory(pkg.parent);
-		return new File(base, pkg.name.replace('.', '/'));
-	}
-	
 	private String getFilename(HighLevelDefinition definition) {
 		SourceFile source = definition.getTag(SourceFile.class);
 		if (source != null) {
 			return definition.name == null ? "Expansion" : definition.name;
 		}
 	}
-	
-	private class SourceModule implements ZenCodeCompilingModule {
-		private final Map<File, JavaSourceFile> sourceFiles = new HashMap<>();
-		private final SemanticModule module;
-		
-		public SourceModule(SemanticModule module) {
-			this.module = module;
-		}
-
-		@Override
-		public void addDefinition(HighLevelDefinition definition) {
-			String filename = getFilename(definition);
-			JavaPrepareDefinitionVisitor prepare = new JavaPrepareDefinitionVisitor(context, context.getJavaModule(module.module), filename, null);
-			JavaClass cls = definition.accept(prepare);
-
-			File file = new File(getDirectory(definition.pkg), cls.getName() + ".java");
-			System.out.println("Compiling " + definition.name + " as " + cls.fullName);
-			JavaSourceFile sourceFile = sourceFiles.get(file);
-			if (sourceFile == null)
-				sourceFiles.put(file, sourceFile = new JavaSourceFile(JavaSourceCompiler.this, file, cls, module, definition.pkg));
-
-			sourceFile.add(definition);
-		}
-
-		@Override
-		public void addScriptBlock(ScriptBlock script) {
-			// TODO: implement this too
-		}
-
-		@Override
-		public void finish() {
-			for (JavaSourceFile sourceFile : sourceFiles.values()) {
-				sourceFile.prepare(context);
-			}
-
-			for (JavaSourceFile sourceFile : sourceFiles.values())
-				sourceFile.write();
-
-		}
-		
-	}
 }

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

  */
 package org.openzen.zenscript.javasource;
 
-import java.io.File;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+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.javashared.JavaCompileSpace;
 import org.openzen.zenscript.javashared.JavaContext;
 import org.openzen.zenscript.javashared.JavaSyntheticClassGenerator;
 import org.openzen.zenscript.javashared.JavaTypeDescriptorVisitor;
 public class JavaSourceContext extends JavaContext {
 	private final JavaTypeDescriptorVisitor typeDescriptorVisitor;
 	private final JavaSyntheticClassGenerator generator;
+	public final JavaSourceSyntheticHelperGenerator helperGenerator;
 	
-	public JavaSourceContext(GlobalTypeRegistry registry, File directory, JavaSourceFormattingSettings settings) {
-		super(registry);
+	public JavaSourceContext(JavaSourceModule helpers, JavaSourceFormattingSettings settings, JavaCompileSpace space, ZSPackage modulePackage, String basePackage) {
+		super(space, modulePackage, basePackage);
 		
 		typeDescriptorVisitor = new JavaTypeDescriptorVisitor(this);
-		this.generator = new JavaSourceSyntheticTypeGenerator(directory, settings, this);
+		this.generator = new JavaSourceSyntheticTypeGenerator(helpers, settings, this);
+		helperGenerator = new JavaSourceSyntheticHelperGenerator(helpers, this, settings);
 	}
 	
 	@Override

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

 package org.openzen.zenscript.javasource;
 
 import org.openzen.zenscript.javashared.JavaContext;
-import java.io.BufferedOutputStream;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.OutputStreamWriter;
-import java.io.Writer;
-import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 public class JavaSourceFile {
 	public final JavaSourceImporter importer;
 	private final JavaSourceCompiler compiler;
-	private final File file;
+	private final JavaSourceContext context;
 	private final JavaClass cls;
 	private final StringBuilder contents = new StringBuilder();
 	private final ZSPackage pkg;
 	private HighLevelDefinition mainDefinition;
 	private final List<ExpansionDefinition> expansions = new ArrayList<>();
 	
-	public JavaSourceFile(JavaSourceCompiler compiler, File file, JavaClass cls, SemanticModule module, ZSPackage pkg) {
+	public JavaSourceFile(JavaSourceCompiler compiler, JavaSourceContext context, JavaClass cls, SemanticModule module, ZSPackage pkg) {
 		this.compiler = compiler;
+		this.context = context;
 		this.pkg = pkg;
 		this.cls = cls;
 		this.module = module;
-		this.file = file;
 		
-		importer = new JavaSourceImporter(compiler.context, cls);
+		importer = new JavaSourceImporter(context, cls);
 	}
 	
 	public String getName() {
 		if (definition instanceof ExpansionDefinition) {
 			expansions.add((ExpansionDefinition)definition);
 		} else if (mainDefinition != null) {
-			throw new IllegalStateException("Multiple main definitions in " + file + "!");
+			throw new IllegalStateException("Multiple main definitions in " + cls.internalName + "!");
 		} else {
 			mainDefinition = definition;
 		}
 	}
 	
 	private boolean isEmpty(HighLevelDefinition definition) {
-		JavaClass cls = compiler.context.getJavaClass(definition);
+		JavaClass cls = context.getJavaClass(definition);
 		if (!cls.empty)
 			return false;
 		
 		return true;
 	}
 	
-	public void write() {
-		System.out.println("Calling write on " + file.getName());
-		
+	public String generate() {
 		if (mainDefinition == null || isEmpty(mainDefinition)) {
 			if (expansions.isEmpty())
-				return;
+				return null;
 			
 			mainDefinition = expansions.remove(0);
 		}
 		JavaDefinitionVisitor visitor = new JavaDefinitionVisitor(
 				"",
 				compiler,
-				compiler.context.getJavaModule(module.module),
+				context,
+				context.getJavaModule(module.module),
 				cls,
 				this,
 				contents,
 				module);
 		definition.accept(visitor);
 		
-		if (!file.getParentFile().exists())
-			file.getParentFile().mkdirs();
-		
-		try (Writer writer = new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(file, false)), StandardCharsets.UTF_8)) {
-			writer.write("package ");
-			writer.write(pkg.fullName);
-			writer.write(";\n\n");
+		StringBuilder result = new StringBuilder();
+		result.append("package ").append(pkg.fullName).append(";\n\n");
 			
-			boolean hasImports = false;
-			for (JavaClass import_ : importer.getUsedImports()) {
-				if (import_.pkg.equals("java.lang"))
-					continue;
-
-				writer.write("import ");
-				writer.write(import_.fullName);
-				writer.write(";\n");
-				hasImports = true;
-			}
-
-			if (hasImports)
-				writer.write("\n");
+		boolean hasImports = false;
+		for (JavaClass import_ : importer.getUsedImports()) {
+			if (import_.pkg.equals("java.lang"))
+				continue;
 			
-			writer.write(contents.toString());
-		} catch (IOException ex) {
-			ex.printStackTrace();
+			result.append("import ").append(import_.fullName).append(";\n");
+			hasImports = true;
 		}
+		
+		if (hasImports)
+			result.append("\n");
+		
+		result.append(contents.toString());
+		return result.toString();
 	}
 }

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceModule.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.javasource;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.javashared.JavaCompiledModule;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSourceModule extends JavaCompiledModule {
+	public final List<SourceFile> sourceFiles = new ArrayList<>();
+	
+	public JavaSourceModule(Module module) {
+		super(module);
+	}
+	
+	public void addFile(String filename, String content) {
+		if (content == null)
+			return;
+		
+		sourceFiles.add(new SourceFile(filename, content));
+	}
+	
+	public static class SourceFile {
+		public final String filename;
+		public final String content;
+		
+		public SourceFile(String filename, String content) {
+			this.filename = filename;
+			this.content = content;
+		}
+	}
+}

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

  */
 package org.openzen.zenscript.javasource;
 
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.OutputStreamWriter;
-import java.io.Writer;
-import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
  */
 public class JavaSourceSyntheticHelperGenerator {
 	private final JavaContext context;
-	private final File directory;
 	private final JavaSourceFormattingSettings settings;
 	private final Map<String, List<String>> members = new HashMap<>();
 	private final JavaClass arrayHelpers = new JavaClass("zsynthetic", "ArrayHelpers", JavaClass.Kind.CLASS);
 	private final Map<ArrayKind, JavaMethod> existingContains = new HashMap<>();
 	private final Map<ArrayKind, JavaMethod> existingIndexOf = new HashMap<>();
+	private final JavaSourceModule helpers;
 	
-	public JavaSourceSyntheticHelperGenerator(JavaContext context, File directory, JavaSourceFormattingSettings settings) {
+	public JavaSourceSyntheticHelperGenerator(JavaSourceModule helpers, JavaContext context, JavaSourceFormattingSettings settings) {
+		this.helpers = helpers;
 		this.context = context;
-		this.directory = new File(directory, "zsynthetic");
 		this.settings = settings;
 	}
 	
 			}
 			contents.append("}\n");
 			
-			File target = new File(directory, filename + ".java");
-			
-			try (Writer output = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(target), StandardCharsets.UTF_8))) {
-				output.write(contents.toString());
-			} catch (IOException ex) {
-				ex.printStackTrace();
-			}
+			String target = "zsynthetic/" + filename + ".java";
+			helpers.addFile(target, contents.toString());
 		}
 	}
 	

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

  */
 package org.openzen.zenscript.javasource;
 
-import java.io.BufferedOutputStream;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.OutputStreamWriter;
-import java.io.Writer;
-import java.nio.charset.StandardCharsets;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaSynthesizedFunction;
  * @author Hoofdgebruiker
  */
 public class JavaSourceSyntheticTypeGenerator implements JavaSyntheticClassGenerator {
-	private final File directory;
+	private final JavaSourceModule helpers;
 	private final JavaSourceFormattingSettings settings;
 	private final JavaSourceContext context;
 	
-	public JavaSourceSyntheticTypeGenerator(File directory, JavaSourceFormattingSettings settings, JavaSourceContext context) {
-		this.directory = new File(directory, "zsynthetic");
+	public JavaSourceSyntheticTypeGenerator(JavaSourceModule helpers, JavaSourceFormattingSettings settings, JavaSourceContext context) {
+		this.helpers = helpers;
 		this.settings = settings;
 		this.context = context;
 	}
 	}
 	
 	private void writeFile(JavaClass cls, JavaSourceImporter importer, StringBuilder contents) {
-		if (!directory.exists())
-			directory.mkdirs();
-		
-		File file = new File(directory, cls.getName() + ".java");
-		try (Writer writer = new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(file)), StandardCharsets.UTF_8)) {
-			writer.write("package zsynthetic;\n");
-			
-			JavaClass[] imports = importer.getUsedImports();
-			if (imports.length > 0) {
-				for (JavaClass import_ : imports) {
-					if (import_.pkg.equals("java.lang"))
-						continue;
-					
-					writer.write("import ");
-					writer.write(import_.fullName);
-					writer.write(";\n");
-				}
+		StringBuilder output = new StringBuilder();
+		output.append("package zsynthetic;\n");
+
+		JavaClass[] imports = importer.getUsedImports();
+		if (imports.length > 0) {
+			for (JavaClass import_ : imports) {
+				if (import_.pkg.equals("java.lang"))
+					continue;
 
-				writer.write("\n");
+				output.append("import ");
+				output.append(import_.fullName);
+				output.append(";\n");
 			}
-			
-			writer.write('\n');
-			writer.write(contents.toString());
-		} catch (IOException ex) {
-			ex.printStackTrace();
+
+			output.append("\n");
 		}
+
+		output.append('\n');
+		output.append(contents.toString());
+		
+		String target = "zsynthetic/" + cls.getName() + ".java";
+		helpers.addFile(target, output.toString());
 	}
 }

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceTarget.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.javasource;
-
-import java.io.File;
-import org.json.JSONObject;
-import org.openzen.zenscript.compiler.SemanticModule;
-import org.openzen.zenscript.compiler.Target;
-import org.openzen.zenscript.compiler.ZenCodeCompiler;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class JavaSourceTarget implements Target {
-	private final String module;
-	private final String name;
-	private final File output;
-	
-	public JavaSourceTarget(File projectDir, JSONObject definition) {
-		module = definition.getString("module");
-		name = definition.optString("name", "Java Source: " + module);
-		output = new File(projectDir, definition.getString("output"));
-	}
-
-	@Override
-	public ZenCodeCompiler createCompiler(SemanticModule module) {
-		return new JavaSourceCompiler(output, module.registry);
-	}
-
-	@Override
-	public String getModule() {
-		return module;
-	}
-
-	@Override
-	public String getName() {
-		return name;
-	}
-
-	@Override
-	public boolean canRun() {
-		return false;
-	}
-
-	@Override
-	public boolean canBuild() {
-		return true;
-	}
-}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceTargetType.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.javasource;
-
-import java.io.File;
-import org.json.JSONObject;
-import org.openzen.zenscript.compiler.Target;
-import org.openzen.zenscript.compiler.TargetType;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class JavaSourceTargetType implements TargetType {
-	public static final JavaSourceTargetType INSTANCE = new JavaSourceTargetType();
-	
-	private JavaSourceTargetType() {}
-
-	@Override
-	public Target create(File projectDir, JSONObject definition) {
-		return new JavaSourceTarget(projectDir, definition);
-	}
-}

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

 	public final JavaSourceContext context;
 	
 	public JavaSourceFileScope(
-			JavaSourceImporter importer, 
-			JavaSourceSyntheticHelperGenerator helperGenerator,
+			JavaSourceImporter importer,
+			JavaSourceContext context,
 			JavaClass cls,
 			TypeScope semanticScope,
 			boolean isInterface,
-			TypeID thisType,
-			JavaSourceContext context)
+			TypeID thisType)
 	{
 		this.importer = importer;
-		this.helperGenerator = helperGenerator;
+		this.helperGenerator = context.helperGenerator;
 		this.cls = cls;
 		this.semanticScope = semanticScope;
 		this.isInterface = isInterface;

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

 
 	@Override
 	public void compile(BaseScope scope) {
-		FunctionScope innerScope = new FunctionScope(scope, compiled.header);
+		FunctionScope innerScope = new FunctionScope(position, scope, compiled.header);
 		compiled.setCode(body.compile(innerScope, compiled.header));
 		
 		if (compiled.header.getReturnType().isBasic(BasicTypeID.UNDETERMINED))

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

 	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
 		Expression cLeft = left.compile(scope).eval();
 		TypeMemberGroup members = scope.getTypeMembers(cLeft.type).getOrCreateGroup(this.operator);
-		ExpressionScope innerScope = scope.withHints(members.predictCallTypes(scope, scope.getResultTypeHints(), 1)[0]);
+		ExpressionScope innerScope = scope.withHints(members.predictCallTypes(position, scope, scope.getResultTypeHints(), 1)[0]);
 		
 		Expression cRight = right.compile(innerScope).eval();
 		CallArguments arguments = new CallArguments(cRight);

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

 		}
 		
 		StoredType functionType = scope.getTypeRegistry()
-				.getFunction(genericHeader.withGenericArguments(new GenericMapper(scope.getTypeRegistry(), scope.genericInferenceMap)))
+				.getFunction(genericHeader.withGenericArguments(new GenericMapper(position, scope.getTypeRegistry(), scope.genericInferenceMap)))
 				.stored(storage);
 		return new FunctionExpression(position, functionType, closure, header, statements);
 	}

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

 		@Override
 		public Expression eval() throws CompileException {
 			TypeMemberGroup members = scope.getTypeMembers(target.type).getOrCreateGroup(OperatorType.INDEXGET);
-			List<StoredType>[] predictedTypes = members.predictCallTypes(scope, scope.hints, indexes.size());
+			List<StoredType>[] predictedTypes = members.predictCallTypes(position, scope, scope.hints, indexes.size());
 			Expression[] arguments = new Expression[indexes.size()];
 			for (int i = 0; i < arguments.length; i++)
 				arguments[i] = indexes.get(i).compile(scope.createInner(predictedTypes[i], this::getLength)).eval();
 		}
 
 		@Override
-		public List<StoredType>[] predictCallTypes(TypeScope scope, List<StoredType> hints, int arguments) throws CompileException {
-			return eval().predictCallTypes(scope, hints, arguments);
+		public List<StoredType>[] predictCallTypes(CodePosition position, TypeScope scope, List<StoredType> hints, int arguments) throws CompileException {
+			return eval().predictCallTypes(position, scope, hints, arguments);
 		}
 		
 		@Override
 		@Override
 		public Expression assign(CodePosition position, TypeScope scope, Expression value) throws CompileException {
 			TypeMemberGroup members = scope.getTypeMembers(target.type).getOrCreateGroup(OperatorType.INDEXSET);
-			List<StoredType>[] predictedTypes = members.predictCallTypes(scope, this.scope.hints, indexes.size() + 1);
+			List<StoredType>[] predictedTypes = members.predictCallTypes(position, scope, this.scope.hints, indexes.size() + 1);
 			
 			Expression[] arguments = new Expression[indexes.size() + 1];
 			for (int i = 0; i < arguments.length - 1; i++)
 		@Override
 		public List<StoredType> getAssignHints() {
 			TypeMemberGroup members = scope.getTypeMembers(target.type).getOrCreateGroup(OperatorType.INDEXSET);
-			List<StoredType>[] predictedTypes = members.predictCallTypes(scope, scope.hints, indexes.size() + 1);
+			List<StoredType>[] predictedTypes = members.predictCallTypes(position, scope, scope.hints, indexes.size() + 1);
 			return predictedTypes[indexes.size()];
 		}
 		

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

 		TypeMemberGroup members = typeMembers.getOrCreateGroup(operator);
 		if (members.getMethodMembers().isEmpty()) {
 			members = typeMembers.getOrCreateGroup(operator.assignOperatorFor);
-			Expression cRight = right.compile(scope.withHints(members.predictCallTypes(scope, scope.hints, 1)[0])).eval();
+			Expression cRight = right.compile(scope.withHints(members.predictCallTypes(position, scope, scope.hints, 1)[0])).eval();
 			Expression value = members.call(position, scope, cLeft, new CallArguments(cRight), false);
 			return cLeft.assign(position, scope, value);
 		} else {
-			Expression cRight = right.compile(scope.withHints(members.predictCallTypes(scope, scope.hints, 1)[0])).eval();
+			Expression cRight = right.compile(scope.withHints(members.predictCallTypes(position, scope, scope.hints, 1)[0])).eval();
 			return members.call(position, scope, cLeft, new CallArguments(cRight), false);
 		}
 	}

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

 import org.openzen.zenscript.codemodel.type.member.TypeMemberGroup;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.member.BuiltinID;
-import org.openzen.zenscript.codemodel.type.member.TypeMember;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.parser.type.IParsedType;
 
 					System.out.println("X");
 			}*/
 
-			List<StoredType>[] predictedTypes = constructors.predictCallTypes(scope, scope.hints, arguments.arguments.size());
+			List<StoredType>[] predictedTypes = constructors.predictCallTypes(position, scope, scope.hints, arguments.arguments.size());
 			CallArguments compiledArguments = arguments.compileCall(position, scope, null, constructors);
 			FunctionalMemberRef member = constructors.selectMethod(position, scope, compiledArguments, true, true);
 			if (member == null)
 					type,
 					member,
 					compiledArguments,
-					member.getHeader().fillGenericArguments(scope, compiledArguments.typeArguments));
+					member.getHeader().fillGenericArguments(position, scope, compiledArguments.typeArguments));
 		} catch (CompileException ex) {
 			return new InvalidExpression(type, ex);
 		}

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

 		
 		inferHeaders(scope);
 		
-		FunctionScope innerScope = new FunctionScope(scope, getCompiled().header);
+		FunctionScope innerScope = new FunctionScope(position, scope, getCompiled().header);
 		getCompiled().annotations = ParsedAnnotation.compileForMember(annotations, getCompiled(), scope);
 		getCompiled().setBody(body.compile(innerScope, getCompiled().header));
 		

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

 		inferHeaders(scope);
 		
 		FunctionHeader header = new FunctionHeader(compiled.getType());
-		FunctionScope innerScope = new FunctionScope(scope, header);
+		FunctionScope innerScope = new FunctionScope(position, scope, header);
 		compiled.annotations = ParsedAnnotation.compileForMember(annotations, getCompiled(), scope);
 		compiled.setBody(body.compile(innerScope, header));
 	}

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

 	@Override
 	public void compile(BaseScope scope) {
 		FunctionHeader header = new FunctionHeader(scope.getTypeRegistry().getIterator(compiled.getLoopVariableTypes()).stored(UniqueStorageTag.INSTANCE));
-		StatementScope innerScope = new FunctionScope(scope, header);
+		StatementScope innerScope = new FunctionScope(position, scope, header);
 		compiled.annotations = ParsedAnnotation.compileForMember(annotations, compiled, scope);
 		compiled.setContent(body.compile(innerScope, header));
 	}

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

 		
 		FunctionHeader header = new FunctionHeader(compiled.getType());
 		FunctionScope innerScope = new FunctionScope(
+				position,
 				scope,
 				header,
 				position -> new GetFunctionParameterExpression(position, compiled.parameter));

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

 	@Override
 	public void compile(BaseScope scope) {
 		compiled.annotations = ParsedAnnotation.compileForMember(annotations, compiled, scope);
-		compiled.body = body.compile(new FunctionScope(scope, new FunctionHeader(BasicTypeID.VOID)));
+		compiled.body = body.compile(new FunctionScope(compiled.position, scope, new FunctionHeader(BasicTypeID.VOID)));
 	}
 }

ScriptingExample/build.gradle

 	compile project(':JavaBytecodeCompiler')
 	compile project(':JavaShared')
 	compile project(':CodeFormatter')
-    //compile project(':ScriptingHost')
+    compile project(':JavaIntegration')
 }

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/FileContents.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.scriptingexample;
-
-import java.util.ArrayList;
-import java.util.List;
-import org.openzen.zencode.shared.SourceFile;
-import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.ScriptBlock;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class FileContents {
-	public final SourceFile file;
-	public ScriptBlock script;
-	public final List<HighLevelDefinition> definitions = new ArrayList<>();
-	
-	public FileContents(SourceFile file) {
-		this.file = file;
-	}
-}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/GlobalRegistry.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.scriptingexample;
-
-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.FunctionHeader;
-import org.openzen.zenscript.codemodel.FunctionParameter;
-import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.Modifiers;
-import org.openzen.zenscript.codemodel.Module;
-import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
-import org.openzen.zenscript.codemodel.definition.ClassDefinition;
-import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
-import org.openzen.zenscript.codemodel.member.GetterMember;
-import org.openzen.zenscript.codemodel.member.MethodMember;
-import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
-import org.openzen.zenscript.codemodel.partial.IPartialExpression;
-import org.openzen.zenscript.codemodel.partial.PartialMemberGroupExpression;
-import org.openzen.zenscript.codemodel.scope.BaseScope;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ISymbol;
-import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.StringTypeID;
-import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
-import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javashared.JavaField;
-import org.openzen.zenscript.javashared.JavaMethod;
-import org.openzen.zenscript.codemodel.type.TypeID;
-import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
-import org.openzen.zenscript.codemodel.type.storage.StaticExpressionStorageTag;
-import org.openzen.zenscript.javashared.JavaCompiledModule;
-import org.openzen.zenscript.javashared.JavaContext;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class GlobalRegistry {
-	public final ZSPackage globals = new ZSPackage(null, "");
-	private final ZSPackage rootPackage = new ZSPackage(null, "");
-	private final ZSPackage javaIo = rootPackage.getOrCreatePackage("java").getOrCreatePackage("io");
-	private final ZSPackage javaLang = rootPackage.getOrCreatePackage("java").getOrCreatePackage("lang");
-	
-	private final Module MODULE = new Module("scriptingExample");
-	private final ClassDefinition PRINTSTREAM = new ClassDefinition(CodePosition.NATIVE, MODULE, javaIo, "PrintStream", Modifiers.PUBLIC);
-	private final ClassDefinition SYSTEM = new ClassDefinition(CodePosition.NATIVE, MODULE, javaLang, "System", Modifiers.PUBLIC);
-	private final MethodMember PRINTSTREAM_PRINTLN;
-	private final GetterMember SYSTEM_OUT;
-	
-	public GlobalRegistry(GlobalTypeRegistry registry, ZSPackage globals) {
-		PRINTSTREAM_PRINTLN = new MethodMember(
-			CodePosition.NATIVE,
-			PRINTSTREAM,
-			Modifiers.PUBLIC,
-			"println",
-			new FunctionHeader(BasicTypeID.VOID, new FunctionParameter(StringTypeID.BORROW)),
-			null);
-		
-		SYSTEM_OUT = new GetterMember(
-			CodePosition.NATIVE,
-			SYSTEM,
-			Modifiers.PUBLIC | Modifiers.FINAL | Modifiers.STATIC,
-			"out",
-			DefinitionTypeID.forType(registry, SYSTEM).stored(AutoStorageTag.INSTANCE),
-			null);
-	}
-	
-	public void register(JavaContext context) {
-		context.addModule(MODULE);
-		JavaCompiledModule javaModule = context.getJavaModule(MODULE);
-		
-		JavaClass jSystem = new JavaClass("java.lang", "System", JavaClass.Kind.CLASS);
-		javaModule.setFieldInfo(SYSTEM_OUT, new JavaField(jSystem, "out", "Ljava/io/PrintStream;"));
-		
-		JavaClass jPrintStream = new JavaClass("java.io", "PrintStream", JavaClass.Kind.CLASS);
-		JavaMethod printstreamPrintln = JavaMethod.getNativeVirtual(jPrintStream, "println", "(Ljava/lang/String;)V");
-		javaModule.setMethodInfo(PRINTSTREAM_PRINTLN, printstreamPrintln);
-	}
-	
-	public ZSPackage collectPackages() {
-		// register packages here
-		
-		return rootPackage;
-	}
-	
-	public List<ExpansionDefinition> collectExpansions() {
-		List<ExpansionDefinition> expansions = new ArrayList<>();
-		
-		return expansions;
-	}
-	
-	public Map<String, ISymbol> collectGlobals() {
-		Map<String, ISymbol> globals = new HashMap<>();
-		
-		// for example, let's add a println global so we can call println("Hello world!") from anywhere
-		globals.put("println", new PrintlnSymbol());
-		
-		return globals;
-	}
-	
-	private class PrintlnSymbol implements ISymbol {
-
-		@Override
-		public IPartialExpression getExpression(CodePosition position, BaseScope scope, StoredType[] typeArguments) {
-			return new PartialMemberGroupExpression(
-					position,
-					scope,
-					new StaticGetterExpression(position, new GetterMemberRef(scope.getTypeRegistry().getForMyDefinition(SYSTEM).stored(StaticExpressionStorageTag.INSTANCE), SYSTEM_OUT, GenericMapper.EMPTY)),
-					"println",
-					PRINTSTREAM_PRINTLN.ref(scope.getTypeRegistry().getForDefinition(PRINTSTREAM).stored(BorrowStorageTag.INVOCATION), GenericMapper.EMPTY),
-					null,
-					false);
-		}
-
-		@Override
-		public TypeID getType(CodePosition position, TypeResolutionContext context, StoredType[] typeArguments) {
-			return null; // not a type
-		}
-	}
-}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/Globals.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.scriptingexample;
+
+import org.openzen.zencode.java.ZenCodeGlobals;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class Globals implements ZenCodeGlobals {
+	private Globals() {}
+	
+	@Global
+	public static void println(String message) {
+		System.out.println(message);
+	}
+}

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

 package org.openzen.zenscript.scriptingexample;
 
 import java.io.File;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.io.IOException;
 import java.util.Optional;
+import org.openzen.zencode.java.JavaNativeModule;
+import org.openzen.zencode.java.ScriptingEngine;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.FileSourceFile;
 import org.openzen.zencode.shared.SourceFile;
-import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.Module;
-
-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.SemanticModule;
-import org.openzen.zenscript.formatter.FileFormatter;
-import org.openzen.zenscript.formatter.ScriptFormattingSettings;
-import org.openzen.zenscript.javabytecode.JavaCompiler;
-import org.openzen.zenscript.javabytecode.JavaModule;
-import org.openzen.zenscript.compiler.ModuleSpace;
-import org.openzen.zenscript.compiler.ZenCodeCompilingModule;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.lexer.ZSToken;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.parser.BracketExpressionParser;
-import org.openzen.zenscript.parser.ParsedFile;
 import org.openzen.zenscript.parser.expression.ParsedExpression;
 import org.openzen.zenscript.parser.expression.ParsedExpressionString;
 
 public class Main {
-    /**
-     * @param args the command line arguments
-     */
-    public static void main(String[] args) throws ParseException {
+	public static void main(String[] args) throws CompileException, ParseException, IOException {
+		ScriptingEngine scriptingEngine = new ScriptingEngine();
+		
+		JavaNativeModule module = scriptingEngine.createNativeModule("globals", "org.openzen.zenscript.scriptingexample");
+		module.addGlobals(Globals.class);
+		scriptingEngine.registerNativeProvided(module);
 		
-		System.out.println();
 		File inputDirectory = new File("scripts");
 		File[] inputFiles = Optional.ofNullable(inputDirectory.listFiles((dir, name) -> name.endsWith(".zs"))).orElseGet(() -> new File[0]);
+		SourceFile[] sourceFiles = new SourceFile[inputFiles.length];
+		for (int i = 0; i < inputFiles.length; i++)
+			sourceFiles[i] = new FileSourceFile(inputFiles[i].getName(), inputFiles[i]);
 		
-		ZSPackage pkg = new ZSPackage(null, "");
-		Module module = new Module("scripts");
-		CompilingPackage compilingPkg = new CompilingPackage(pkg, module);
-		ParsedFile[] parsedFiles = parse(compilingPkg, inputFiles);
-		
-		ZSPackage root = ZSPackage.createRoot();
-		ZSPackage stdlib = new ZSPackage(root, "stdlib");
-		GlobalTypeRegistry typeRegistry = new GlobalTypeRegistry(stdlib);
-		
-		ZSPackage global = new ZSPackage(null, "");
-		GlobalRegistry registry = new GlobalRegistry(typeRegistry, global);
-		SemanticModule semantic = compileSyntaxToSemantic(typeRegistry, compilingPkg, parsedFiles, registry);
-		
-		//formatFiles(pkg, module);
-		
-		if (semantic.isValid()) {
-			JavaModule javaModule = compileSemanticToJava(registry, semantic);
-			javaModule.execute();
-		} else {
-			System.out.println("There were compilation errors");
-		}
-    }
-	
-	private static ParsedFile[] parse(CompilingPackage compilingPkg, File[] files) throws ParseException {
-		ParsedFile[] parsedFiles = new ParsedFile[files.length];
-		for (int i = 0; i < files.length; i++) {
-			parsedFiles[i] = ParsedFile.parse(compilingPkg, new TestBracketParser(), files[i]);
-		}
-		return parsedFiles;
-	}
-	
-	private static void formatFiles(ZSPackage pkg, SemanticModule module) {
-		Map<String, FileContents> files = new HashMap<>();
-		for (ScriptBlock block : module.scripts) {
-			SourceFile file = block.getTag(SourceFile.class);
-			if (file == null)
-				continue;
-			
-			FileContents contents = new FileContents(file);
-			contents.script = block;
-			files.put(file.getFilename(), contents);
-		}
-		
-		for (HighLevelDefinition definition : module.definitions.getAll()) {
-			SourceFile file = definition.getTag(SourceFile.class);
-			if (file == null)
-				continue;
-			
-			if (!files.containsKey(file.getFilename()))
-				files.put(file.getFilename(), new FileContents(file));
-			
-			files.get(file.getFilename()).definitions.add(definition);
-		}
-		
-		List<String> filenames = new ArrayList<>(files.keySet());
-		Collections.sort(filenames);
-		
-		ScriptFormattingSettings settings = new ScriptFormattingSettings.Builder().build();
-		for (String filename : filenames) {
-			FileContents contents = files.get(filename);
-			FileFormatter formatter = new FileFormatter(settings);
-			System.out.println("== " + filename + " ==");
-			System.out.println(formatter.format(pkg, contents.script, contents.definitions));
-		}
-	}
-	
-	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(
-				new SemanticModule[0],
-				compiling,
-				files,
-				space,
-				exception -> exception.printStackTrace());
-		
-		result = result.normalize();
-		result.validate(entry -> {
-			System.out.println(entry.kind + " " + entry.position.toString() + ": " + entry.message);
-		});
-		return result;
-	}
-	
-	private static JavaModule compileSemanticToJava(GlobalRegistry registry, SemanticModule module) {
-		JavaCompiler compiler = new JavaCompiler(module.registry, false, null);
-		registry.register(compiler.getContext());
-		
-		ZenCodeCompilingModule compiling = compiler.addModule(module);
-		for (HighLevelDefinition definition : module.definitions.getAll()) {
-			compiling.addDefinition(definition);
-		}
-		for (ScriptBlock script : module.scripts) {
-			compiling.addScriptBlock(script);
-		}
-		compiling.finish();
+		SemanticModule scripts = scriptingEngine.createScriptedModule("script", sourceFiles, new TestBracketParser());
+		if (!scripts.isValid())
+			return;
 		
-		return compiler.finishAndGetModule();
+		scriptingEngine.registerCompiled(scripts);
+		scriptingEngine.run();
 	}
 	
 	private static class TestBracketParser implements BracketExpressionParser {