- Fix various bugs in the new system

- Slightly improved the way modules are compiled

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

 		
 		minParameters = 0;
 		maxParameters = 0;
-		hasUnknowns = returnType == BasicTypeID.UNDETERMINED.stored;
+		hasUnknowns = returnType.type == BasicTypeID.UNDETERMINED;
 	}
 	
 	public FunctionHeader(BasicTypeID returnType) {
 	}
 	
 	public boolean isDenormalized() {
-		if (returnType.getNormalized() != returnType)
+		if (!returnType.getNormalized().equals(returnType))
 			return true;
 		for (FunctionParameter parameter : parameters)
 			if (parameter.type.getNormalized() != parameter.type)
 		
 		FunctionParameter[] normalizedParameters = new FunctionParameter[parameters.length];
 		for (int i = 0; i < normalizedParameters.length; i++)
-			normalizedParameters[i] = parameters[i].normalized(registry);
+			normalizedParameters[i] = parameters[i].normalize(registry);
 		return new FunctionHeader(typeParameters, returnType.getNormalized(), thrownType == null ? null : thrownType.getNormalized(), storage, normalizedParameters);
 	}
 	
 		return false;
 	}
 	
-	public FunctionHeader withReturnType(StoredType returnType) {
-		return new FunctionHeader(typeParameters, returnType, thrownType, storage, parameters);
-	}
-	
 	public FunctionHeader inferFromOverride(GlobalTypeRegistry registry, FunctionHeader overridden) {
 		TypeParameter[] resultTypeParameters = typeParameters;
 		StoredType resultReturnType = this.returnType;
 		if (arguments.arguments.length < minParameters || arguments.arguments.length > maxParameters)
 			return false;
 		
-		FunctionHeader header = fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
+		FunctionHeader header = fillGenericArguments(scope, arguments.typeArguments);
 		for (int i = 0; i < header.parameters.length; i++) {
 			if (!arguments.arguments[i].type.equals(header.parameters[i].type))
 				return false;
 		if (arguments.arguments.length < minParameters || arguments.arguments.length > maxParameters)
 			return false;
 		
-		FunctionHeader header = fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
+		FunctionHeader header = fillGenericArguments(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;
 			}
 			result.append('>');
 		}
+		if (storage != null)
+			result.append(storage);
 		result.append('(');
 		for (int i = 0; i < parameters.length; i++) {
 			if (i > 0)
 		return new FunctionHeader(typeParameters, returnType, thrownType == null ? null : thrownType.instance(mapper), storage, parameters);
 	}
 	
-	public FunctionHeader fillGenericArguments(GlobalTypeRegistry registry, StoredType[] arguments, GenericMapper typeParameterMapping) {
+	public FunctionHeader fillGenericArguments(TypeScope scope, StoredType[] arguments) {
 		if (arguments == null || arguments.length == 0)
 			return this;
 		
 		Map<TypeParameter, StoredType> typeArguments = StoredType.getMapping(typeParameters, arguments);
-		GenericMapper mapper = typeParameterMapping.getInner(registry, typeArguments);
+		GenericMapper mapper = scope.getLocalTypeParameters().getInner(scope.getTypeRegistry(), typeArguments);
 		
 		StoredType returnType = this.returnType.instance(mapper);
 		FunctionParameter[] parameters = new FunctionParameter[this.parameters.length];

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

 		this.variadic = variadic;
 	}
 	
-	public FunctionParameter normalized(GlobalTypeRegistry registry) {
+	public FunctionParameter normalize(GlobalTypeRegistry registry) {
 		FunctionParameter result = new FunctionParameter(type.getNormalized(), name, defaultValue, variadic);
 		result.annotations = this.annotations;
 		return result;

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

  */
 package org.openzen.zenscript.codemodel;
 
-import org.openzen.zencode.shared.Taggable;
-
 /**
  *
  * @author Hoofdgebruiker
  */
-public class Module extends Taggable {
+public class Module {
 	public static final Module BUILTIN = new Module("builtin");
 	
 	public final String name;
 	public Module(String name) {
 		this.name = name;
 	}
+	
+	@Override
+	public String toString() {
+		return name;
+	}
 }

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

 				type,
 				member,
 				compiledArguments,
-				compiledArguments.getNumberOfTypeArguments() == 0 ? member.getHeader() : member.getHeader().fillGenericArguments(scope.getTypeRegistry(), compiledArguments.typeArguments, scope.getLocalTypeParameters()));
+				compiledArguments.getNumberOfTypeArguments() == 0 ? member.getHeader() : member.getHeader().fillGenericArguments(scope, compiledArguments.typeArguments));
 	}
 	
 	public Expression not(Expression value) throws CompileException {

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

 		return annotations;
 	}
 	
+	@Override
+	public String toString() {
+		return describe();
+	}
+	
 	public boolean isStatic() {
 		return Modifiers.isStatic(getEffectiveModifiers());
 	}

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

 	
 	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.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
+		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(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.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
+		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(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.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
+		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope, arguments.typeArguments);
 		return method.callStatic(position, target, instancedHeader, arguments, scope);
 	}
 	

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

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

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

  */
 package org.openzen.zenscript.compiler;
 
-import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.ScriptBlock;
-
 /**
  *
  * @author Hoofdgebruiker
  */
 public interface ZenCodeCompiler {
-	void addModule(SemanticModule module);
-	
-	void addDefinition(HighLevelDefinition definition, SemanticModule module);
-	
-	void addScriptBlock(ScriptBlock script);
+	ZenCodeCompilingModule addModule(SemanticModule module);
 	
 	void finish();
 	

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.compiler;
+
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.ScriptBlock;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface ZenCodeCompilingModule {
+	void addDefinition(HighLevelDefinition definition);
+	
+	void addScriptBlock(ScriptBlock script);
+	
+	void finish();
+}

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

 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;
 	}
 	
 	@Override
-	public void addModule(SemanticModule module) {
+	public ZenCodeCompilingModule addModule(SemanticModule module) {
 		context.addModule(module.module);
-	}
-
-	@Override
-	public void addDefinition(HighLevelDefinition definition, SemanticModule module) {
-		JavaPrepareDefinitionVisitor preparer = new JavaPrepareDefinitionVisitor(context, context.getJavaModule(module.module), definition.position.getFilename(), null);
-		definition.accept(preparer);
 		
-		definitions.add(definition);
-	}
+		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);
 
-	@Override
-	public void addScriptBlock(ScriptBlock script) {
-		scripts.add(script);
+				definitions.add(definition);
+			}
+
+			@Override
+			public void addScriptBlock(ScriptBlock script) {
+				scripts.add(script);
+			}
+
+			@Override
+			public void finish() {
+				
+			}
+		};
 	}
 
 	private String getClassName(String filename) {

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

 	public final Module module;
 	
 	private final Map<HighLevelDefinition, JavaClass> classes = new HashMap<>();
+	private final Map<HighLevelDefinition, JavaClass> expansionClasses = new HashMap<>();
 	private final Map<HighLevelDefinition, JavaNativeClass> nativeClasses = new HashMap<>();
 	private final Map<ImplementationMember, JavaImplementation> implementations = new HashMap<>();
 	private final Map<IDefinitionMember, JavaField> fields = new HashMap<>();
 		classes.put(definition, cls);
 	}
 	
+	public void setExpansionClassInfo(HighLevelDefinition definition, JavaClass cls) {
+		expansionClasses.put(definition, cls);
+	}
+	
 	public JavaClass getClassInfo(HighLevelDefinition definition) {
 		JavaClass cls = classes.get(definition);
 		if (cls == null)
 		return cls;
 	}
 	
+	public JavaClass getExpansionClassInfo(HighLevelDefinition definition) {
+		JavaClass cls = expansionClasses.get(definition);
+		if (cls == null)
+			return getClassInfo(definition);
+		
+		return cls;
+	}
+	
 	public JavaClass optClassInfo(HighLevelDefinition definition) {
 		return classes.get(definition);
 	}

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

 		return getJavaModule(definition.module).getClassInfo(definition);
 	}
 	
+	public JavaClass getJavaExpansionClass(HighLevelDefinition definition) {
+		return getJavaModule(definition.module).getExpansionClassInfo(definition);
+	}
+	
 	public JavaClass optJavaClass(HighLevelDefinition definition) {
 		return getJavaModule(definition.module).optClassInfo(definition);
 	}
 		getJavaModule(definition.module).setClassInfo(definition, cls);
 	}
 	
+	public void setJavaExpansionClass(HighLevelDefinition definition, JavaClass cls) {
+		getJavaModule(definition.module).setExpansionClassInfo(definition, cls);
+	}
+	
 	public void setJavaNativeClass(HighLevelDefinition definition, JavaNativeClass cls) {
 		getJavaModule(definition.module).setNativeClassInfo(definition, cls);
 	}

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

 import org.openzen.zenscript.javashared.JavaNativeClass;
 import org.openzen.zencode.shared.StringExpansion;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.annotations.NativeTag;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 		
 		if (member.getOverrides() != null) {
 			DefinitionMemberRef base = member.getOverrides();
+			
 			JavaMethod baseMethod = context.getJavaMethod(base.getTarget());
 			method = new JavaMethod(
 					cls,

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

 	public void prepare(TypeID type) {
 		if (!(type instanceof DefinitionTypeID))
 			return;
-			
+		
 		HighLevelDefinition definition = ((DefinitionTypeID)type).definition;
-		System.out.println("Preparing " + definition.name);
+		prepare(definition);
+	}
+	
+	public void prepare(HighLevelDefinition definition) {
+		if (isPrepared(definition))
+			return;
+		if (definition.module != module.module)
+			throw new IllegalArgumentException("Definition is not in the same module as the current module!");
+		
+		System.out.println("~~ Preparing " + definition.name);
 		definition.accept(this);
 	}
 	
 			return context.getJavaClass(definition);
 		
 		JavaNativeClass nativeClass = context.getJavaNativeClass(definition);
-		JavaClass cls = context.getJavaClass(definition);
+		JavaClass cls = context.getJavaExpansionClass(definition);
 		visitExpansionMembers(definition, cls, nativeClass);
 		return cls;
 	}
 		if (nativeClass == null) {
 			visitClassMembers(definition, cls, null, startsEmpty);
 		} else {
-			visitExpansionMembers(definition, cls, nativeClass);
+			cls.membersPrepared = true;
+			JavaClass expansionCls = context.getJavaExpansionClass(definition);
+			visitExpansionMembers(definition, expansionCls, nativeClass);
+			cls.empty = expansionCls.empty;
 		}
 		return cls;
 	}

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

 			cls.destructible = definition.isDestructible();
 			context.setJavaClass(definition, cls);
 		} else {
-			cls = outerClass == null ? new JavaClass(definition.pkg.fullName, filename, kind) : new JavaClass(outerClass, filename, kind);
+			cls = outerClass == null ? new JavaClass(definition.pkg.fullName, definition.name + "Expansion", kind) : new JavaClass(outerClass, definition.name + "Expansion", kind);
 			
 			context.setJavaClass(definition, nativeClass.cls);
+			context.setJavaExpansionClass(definition, cls);
 			context.setJavaNativeClass(definition, nativeClass);
 			
 			if (nativeClass.nonDestructible)

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

 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.compiler.CompileScope;
 import org.openzen.zenscript.compiler.SemanticModule;
-import org.openzen.zenscript.javashared.JavaNativeClass;
 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
 import org.openzen.zenscript.javasource.scope.JavaSourceStatementScope;
 import org.openzen.zenscript.javashared.JavaClass;
 	private final JavaSourceFormattingSettings settings;
 	private final List<ExpansionDefinition> expansions;
 	private final StringBuilder output;
-	private final Map<HighLevelDefinition, SemanticModule> modules;
 	private final JavaContext context;
 	private final JavaCompiledModule module;
+	private final SemanticModule semanticModule;
 	
 	public JavaDefinitionVisitor(
 			String indent,
 			JavaSourceFile file,
 			StringBuilder output,
 			List<ExpansionDefinition> expansions,
-			Map<HighLevelDefinition, SemanticModule> modules)
+			SemanticModule semanticModule)
 	{
 		this.indent = indent;
 		this.compiler = compiler;
 		this.settings = compiler.settings;
 		this.output = output;
 		this.expansions = expansions;
-		this.modules = modules;
 		this.context = compiler.context;
 		this.module = module;
+		this.semanticModule = semanticModule;
 	}
 	
 	private JavaSourceFileScope createScope(HighLevelDefinition definition) {
-		SemanticModule module = modules.get(definition.getOutermost());
-		GlobalTypeRegistry typeRegistry = module.compilationUnit.globalTypeRegistry;
+		GlobalTypeRegistry typeRegistry = semanticModule.compilationUnit.globalTypeRegistry;
 		DefinitionTypeID thisType = typeRegistry.getForMyDefinition(definition);
 		
-		CompileScope scope = new CompileScope(module.compilationUnit.globalTypeRegistry, module.expansions, module.annotations, module.storageTypes);
+		CompileScope scope = new CompileScope(semanticModule.compilationUnit.globalTypeRegistry, semanticModule.expansions, semanticModule.annotations, semanticModule.storageTypes);
 		return new JavaSourceFileScope(file.importer, compiler.helperGenerator, cls, scope, definition instanceof InterfaceDefinition, thisType, compiler.context);
 	}
 	
 	@Override
 	public Void visitClass(ClassDefinition definition) {
 		JavaSourceFileScope scope = createScope(definition);
-		JavaClass cls = context.getJavaClass(definition);
+		JavaClass cls = context.getJavaExpansionClass(definition);
 		
 		output.append(indent);
 		convertModifiers(definition.modifiers);
 				member.accept(memberCompiler);
 			memberCompiler.finish();
 		} else {
-			JavaMemberCompiler memberCompiler = new JavaMemberCompiler(compiler, module, file, settings, indent + settings.indent, output, scope, scope.isInterface, definition, modules);
+			JavaMemberCompiler memberCompiler = new JavaMemberCompiler(compiler, 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/JavaMemberCompiler.java

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
-import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 	private final JavaSourceFile file;
 	private final List<FieldMember> fields = new ArrayList<>();
 	private final boolean isInterface;
-	private final Map<HighLevelDefinition, SemanticModule> modules;
 	private final JavaContext context;
 	public boolean hasDestructor = false;
 	private final JavaCompiledModule module;
+	private final SemanticModule semanticModule;
 	
 	public JavaMemberCompiler(
 			JavaSourceCompiler compiler,
 			JavaSourceFileScope scope,
 			boolean isInterface,
 			HighLevelDefinition definition,
-			Map<HighLevelDefinition, SemanticModule> modules)
+			SemanticModule semanticModule)
 	{
 		super(settings, indent, output, scope, null, definition);
 		
 		this.file = file;
 		this.isInterface = isInterface;
 		this.compiler = compiler;
-		this.modules = modules;
 		this.context = compiler.context;
 		this.module = module;
+		this.semanticModule = semanticModule;
 	}
 	
 	private void compileMethod(DefinitionMember member, FunctionHeader header, Statement body) {
 			
 			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, modules);
+			JavaMemberCompiler memberCompiler = new JavaMemberCompiler(compiler, module, file, settings, indent + settings.indent, output, scope, isInterface, definition, semanticModule);
 			for (IDefinitionMember m : member.members) {
 				m.accept(memberCompiler);
 			}
 				file,
 				output,
 				Collections.emptyList(),
-				modules);
+				semanticModule);
 		member.innerDefinition.accept(visitor);
 		return null;
 	}

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.compiler.CompilationUnit;
 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;
 	public final JavaSourceSyntheticHelperGenerator helperGenerator;
 	
 	private final File directory;
-	private final Map<File, JavaSourceFile> sourceFiles = new HashMap<>();
 	public final JavaSourceContext context;
+	private final List<SourceModule> modules = new ArrayList<>();
 	
 	public JavaSourceCompiler(File directory, CompilationUnit compilationUnit) {
 		if (!directory.exists())
 	}
 	
 	@Override
-	public void addModule(SemanticModule module) {
+	public ZenCodeCompilingModule addModule(SemanticModule module) {
 		context.addModule(module.module);
-	}
-	
-	@Override
-	public void addDefinition(HighLevelDefinition definition, SemanticModule module) {
-		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(this, file, cls, module.module, definition.pkg));
-		
-		sourceFile.add(definition, module);
-	}
-	
-	@Override
-	public void addScriptBlock(ScriptBlock script) {
-		
+		SourceModule result = new SourceModule(module);
+		modules.add(result);
+		return result;
 	}
 	
 	@Override
 	public void finish() {
-		for (JavaSourceFile sourceFile : sourceFiles.values()) {
-			sourceFile.prepare(context);
-		}
-		
-		for (JavaSourceFile sourceFile : sourceFiles.values())
-			sourceFile.write();
-		
 		helperGenerator.write();
 	}
 	
 			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/JavaSourceFile.java

 import java.io.Writer;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.annotations.NativeTag;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 	private final JavaClass cls;
 	private final StringBuilder contents = new StringBuilder();
 	private final ZSPackage pkg;
-	private final Module module;
+	private final SemanticModule module;
 	
 	private HighLevelDefinition mainDefinition;
 	private final List<ExpansionDefinition> expansions = new ArrayList<>();
 	
-	private final Map<HighLevelDefinition, SemanticModule> modules = new HashMap<>();
-	private final Set<String> existing = new HashSet<>();
-	
-	public JavaSourceFile(JavaSourceCompiler compiler, File file, JavaClass cls, Module module, ZSPackage pkg) {
+	public JavaSourceFile(JavaSourceCompiler compiler, File file, JavaClass cls, SemanticModule module, ZSPackage pkg) {
 		this.compiler = compiler;
 		this.pkg = pkg;
 		this.cls = cls;
 		return cls.getName();
 	}
 	
-	public void add(HighLevelDefinition definition, SemanticModule module) {
+	public void add(HighLevelDefinition definition) {
 		if (definition instanceof ExpansionDefinition) {
 			expansions.add((ExpansionDefinition)definition);
 		} else if (mainDefinition != null) {
 		} else {
 			mainDefinition = definition;
 		}
-		
-		modules.put(definition, module);
 	}
 	
 	public void prepare(JavaContext context) {
-		JavaPrepareDefinitionMemberVisitor visitor = new JavaPrepareDefinitionMemberVisitor(context, context.getJavaModule(module));
+		JavaPrepareDefinitionMemberVisitor visitor = new JavaPrepareDefinitionMemberVisitor(context, context.getJavaModule(module.module));
 		
 		if (mainDefinition != null)
 			mainDefinition.accept(visitor);
 		JavaDefinitionVisitor visitor = new JavaDefinitionVisitor(
 				"",
 				compiler,
-				compiler.context.getJavaModule(module),
+				compiler.context.getJavaModule(module.module),
 				cls,
 				this,
 				contents,
 				expansions,
-				modules);
+				module);
 		definition.accept(visitor);
 		
 		if (!file.getParentFile().exists())

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

 					type,
 					member,
 					compiledArguments,
-					member.getHeader().fillGenericArguments(scope.getTypeRegistry(), compiledArguments.typeArguments, scope.getLocalTypeParameters()));
+					member.getHeader().fillGenericArguments(scope, compiledArguments.typeArguments));
 		} catch (CompileException ex) {
 			return new InvalidExpression(type, ex);
 		}

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

 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;
 		JavaCompiler compiler = new JavaCompiler(module.compilationUnit.globalTypeRegistry, false, null);
 		registry.register(compiler.getContext());
 		
-		compiler.getContext().addModule(module.module);
-		
+		ZenCodeCompilingModule compiling = compiler.addModule(module);
 		for (HighLevelDefinition definition : module.definitions.getAll()) {
-			compiler.addDefinition(definition, module);
+			compiling.addDefinition(definition);
 		}
 		for (ScriptBlock script : module.scripts) {
-			compiler.addScriptBlock(script);
+			compiling.addScriptBlock(script);
 		}
+		compiling.finish();
+		
 		return compiler.finishAndGetModule();
 	}