Moved Java compile-time tags to non-global state

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

 
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zencode.shared.Tag;
 import stdlib.Strings;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class WhitespaceInfo {
+public class WhitespaceInfo implements Tag {
 	public static WhitespaceInfo from(String whitespaceBefore, String lineAfter, boolean skipLineBefore) {
 		int numNewLines = 0;
 		for (char c : whitespaceBefore.toCharArray())

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

 
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zencode.shared.Tag;
 import stdlib.Strings;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class WhitespacePostComment {
+public class WhitespacePostComment implements Tag {
 	public static WhitespacePostComment fromWhitespace(String whitespace) {
 		List<String> comments = new ArrayList<>();
 		for (String line : Strings.split(whitespace, '\n')) {

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

  */
 package org.openzen.zenscript.codemodel.annotations;
 
+import org.openzen.zencode.shared.Tag;
+
 /**
  *
  * @author Hoofdgebruiker
  */
-public class NativeTag {
+public class NativeTag implements Tag {
 	public final String value;
 	
 	public NativeTag(String value) {

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

 package org.openzen.zenscript.codemodel.member;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.Tag;
 import org.openzen.zenscript.codemodel.AccessScope;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 	
 	public <C, R> R accept(C context, MemberVisitorWithContext<C, R> visitor);
 	
-	public <T> T getTag(Class<T> tag);
+	public <T extends Tag> T getTag(Class<T> tag);
 	
-	public <T> void setTag(Class<T> tag, T value);
+	public <T extends Tag> void setTag(Class<T> tag, T value);
 
-	<T> boolean hasTag(Class<T> tag);
+	<T extends Tag> boolean hasTag(Class<T> tag);
 	
 	DefinitionMemberRef getOverrides();
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/CasterMemberRef.java

 package org.openzen.zenscript.codemodel.member.ref;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.Tag;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 	}
 
 	@Override
-	public <T> T getTag(Class<T> type) {
+	public <T extends Tag> T getTag(Class<T> type) {
 		return member.getTag(type);
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/DefinitionMemberRef.java

 package org.openzen.zenscript.codemodel.member.ref;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.Tag;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 	
 	String describe();
 	
-	default <T> T getTag(Class<T> type) {
+	default <T extends Tag> T getTag(Class<T> type) {
 		return getTarget().getTag(type);
 	}
 	
-	default boolean hasTag(Class<?> type) {
+	default <T extends Tag> boolean hasTag(Class<T> type) {
 		return getTarget().hasTag(type);
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/FunctionalMemberRef.java

 package org.openzen.zenscript.codemodel.member.ref;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.Tag;
 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 	}
 	
 	@Override
-	public <T> T getTag(Class<T> cls) {
+	public <T extends Tag> T getTag(Class<T> cls) {
 		return target.getTag(cls);
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/ImplementationMemberRef.java

 package org.openzen.zenscript.codemodel.member.ref;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.Tag;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 	}
 
 	@Override
-	public <T> T getTag(Class<T> type) {
+	public <T extends Tag> T getTag(Class<T> type) {
 		return member.getTag(type);
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/IteratorMemberRef.java

 package org.openzen.zenscript.codemodel.member.ref;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.Tag;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.IteratorMember;
 	}
 
 	@Override
-	public <T> T getTag(Class<T> type) {
+	public <T extends Tag> T getTag(Class<T> type) {
 		return target.getTag(type);
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/PropertyRef.java

 package org.openzen.zenscript.codemodel.member.ref;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.Tag;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 	}
 
 	@Override
-	public final <T> T getTag(Class<T> type) {
+	public final <T extends Tag> T getTag(Class<T> type) {
 		return member.getTag(type);
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/VariantOptionRef.java

  */
 package org.openzen.zenscript.codemodel.member.ref;
 
+import org.openzen.zencode.shared.Tag;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.type.StoredType;
 
 		return types[index];
 	}
 	
-	public <T> T getTag(Class<T> type) {
+	public <T extends Tag> T getTag(Class<T> type) {
 		return option.getTag(type);
 	}
 

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

 		this.outer = outer;
 		this.header = header;
 		this.thisType = outer.getThisType() == null || header.storage == null ? outer.getThisType() : outer.getThisType().type.stored(header.storage);
-		if (header.storage != null)
-			System.out.println("Storage is " + header.storage);
 		
 		if (outer.getLocalTypeParameters() == null)
 			throw new NullPointerException();

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);
 		for (HighLevelDefinition definition : definitions.getAll()) {
 			compiler.addDefinition(definition, this);
 		}

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

  * @author Hoofdgebruiker
  */
 public interface ZenCodeCompiler {
+	void addModule(SemanticModule module);
+	
 	void addDefinition(HighLevelDefinition definition, SemanticModule module);
 	
 	void addScriptBlock(ScriptBlock script);

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

 			stdlib.validate(validationLogger);
 			if (!stdlib.isValid())
 				return compiler;
+			
 			stdlib.compile(compiler);
 			compiledModules.add(stdlib.name);
 			

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

 
 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.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.javabytecode.compiler.JavaClassWriter;
 import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
 import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
 import org.openzen.zenscript.javabytecode.compiler.definitions.JavaDefinitionVisitor;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.javashared.JavaBaseCompiler;
 import org.openzen.zenscript.javashared.JavaClass;
+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 implements ZenCodeCompiler {
+public class JavaCompiler extends JavaBaseCompiler implements ZenCodeCompiler {
 	private final JavaModule target;
 	private final Map<String, JavaScriptFile> scriptBlocks = new HashMap<>();
 	private final JavaClassWriter scriptsClassWriter;
 		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 void addModule(SemanticModule module) {
+		context.addModule(module.module);
+	}
 
 	@Override
 	public void addDefinition(HighLevelDefinition definition, SemanticModule module) {
-		JavaPrepareDefinitionVisitor preparer = new JavaPrepareDefinitionVisitor(definition.position.getFilename(), null);
+		JavaPrepareDefinitionVisitor preparer = new JavaPrepareDefinitionVisitor(context, context.getJavaModule(module.module), definition.position.getFilename(), null);
 		definition.accept(preparer);
 		
 		definitions.add(definition);
 		finished = true;
 		
 		for (HighLevelDefinition definition : definitions) {
-			JavaPrepareDefinitionMemberVisitor memberPreparer = new JavaPrepareDefinitionMemberVisitor(context);
+			JavaPrepareDefinitionMemberVisitor memberPreparer = new JavaPrepareDefinitionMemberVisitor(context, context.getJavaModule(definition.module));
 			definition.accept(memberPreparer);
 		}
 		
 			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, new JavaWriter(visitor, method, null, null, null));
+			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);

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

 import org.openzen.zenscript.javashared.JavaParameterInfo;
 
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
+import org.openzen.zenscript.javashared.JavaCompiledModule;
 
 public class CompilerUtils {
 	private CompilerUtils() {}
 		return out;
 	}
 
-    public static void tagMethodParameters(JavaBytecodeContext context, FunctionHeader header, boolean isStatic) {
+    public static void tagMethodParameters(JavaBytecodeContext context, JavaCompiledModule module, FunctionHeader header, boolean isStatic) {
         for (int i = 0; i < header.parameters.length; i++) {
             FunctionParameter parameter = header.parameters[i];
             String parameterType = context.getDescriptor(parameter.type);
-            parameter.setTag(JavaParameterInfo.class, new JavaParameterInfo(isStatic ? i : i + 1, parameterType));
+            module.setParameterInfo(parameter, new JavaParameterInfo(isStatic ? i : i + 1, parameterType));
         }
     }
 
-    public static void tagConstructorParameters(JavaBytecodeContext context, FunctionHeader header, boolean isEnum) {
+    public static void tagConstructorParameters(JavaBytecodeContext context, JavaCompiledModule module, FunctionHeader header, boolean isEnum) {
         for (int i = 0; i < header.parameters.length; i++) {
             FunctionParameter parameter = header.parameters[i];
             String parameterType = context.getDescriptor(parameter.type);
-            parameter.setTag(JavaParameterInfo.class, new JavaParameterInfo(isEnum ? i + 3 : i + 1, parameterType));
+			module.setParameterInfo(parameter, new JavaParameterInfo(isEnum ? i + 3 : i + 1, parameterType));
         }
     }
 
     public static void writeDefaultFieldInitializers(JavaBytecodeContext context, JavaWriter constructorWriter, HighLevelDefinition definition, boolean staticFields) {
-        JavaExpressionVisitor expressionVisitor = new JavaExpressionVisitor(context, constructorWriter);
+        JavaExpressionVisitor expressionVisitor = new JavaExpressionVisitor(context, context.getJavaModule(definition.module), constructorWriter);
         for (final IDefinitionMember definitionMember : definition.members) {
             if (!(definitionMember instanceof FieldMember))
                 continue;

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

 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
-import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 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 org.openzen.zenscript.javashared.JavaTypeUtils;
 	protected final JavaWriter javaWriter;
 	private final JavaCapturedExpressionVisitor capturedExpressionVisitor = new JavaCapturedExpressionVisitor(this);
 	private final JavaBytecodeContext context;
+	private final JavaCompiledModule module;
 
-    public JavaExpressionVisitor(JavaBytecodeContext context, JavaWriter javaWriter) {
+    public JavaExpressionVisitor(JavaBytecodeContext context, JavaCompiledModule module, JavaWriter javaWriter) {
         this.javaWriter = javaWriter;
 		this.context = context;
+		this.module = module;
     }
 
     @Override
 	public Void visitConst(ConstExpression expression) {
 		BuiltinID builtin = expression.constant.member.builtin;
 		if (builtin == null) {
-			if (!checkAndGetFieldInfo(expression.constant, true))
-				throw new IllegalStateException("Call target has no field info!");
-
+			javaWriter.getStaticField(context.getJavaField(expression.constant));
 			return null;
 		}
 
 				break;
 			case ENUM_VALUES: {
 				DefinitionTypeID type = (DefinitionTypeID) expression.type.type;
-				JavaClass cls = type.definition.getTag(JavaClass.class);
+				JavaClass cls = context.getJavaClass(type.definition);
 				javaWriter.invokeStatic(JavaMethod.getNativeStatic(cls, "values", "()[L" + cls.internalName + ";"));
 				break;
 			}
 
 	@Override
 	public Void visitFunction(FunctionExpression expression) {
-		CompilerUtils.tagMethodParameters(context, expression.header, false);
+		CompilerUtils.tagMethodParameters(context, module, expression.header, false);
 
-        if (expression.header.parameters.length == 0 && expression.body instanceof ReturnStatement && expression.body.hasTag(MatchExpression.class) && expression.closure.captures.isEmpty()) {
+        /*if (expression.header.parameters.length == 0 && expression.body instanceof ReturnStatement && expression.body.hasTag(MatchExpression.class) && expression.closure.captures.isEmpty()) {
             ((ReturnStatement) expression.body).value.accept(this);
             return null;
-        }
+        }*/
 		
 		final String descriptor = context.getMethodDescriptor(expression.header);
         final String signature = context.getMethodSignature(expression.header);
         functionWriter.start();
 
 
-		final JavaStatementVisitor CSV = new JavaStatementVisitor(context, new JavaExpressionVisitor(context, functionWriter) {
+		final JavaStatementVisitor CSV = new JavaStatementVisitor(context, new JavaExpressionVisitor(context, module, functionWriter) {
 			@Override
 			public Void visitGetLocalVariable(GetLocalVariableExpression varExpression) {
 				final int position = calculateMemberPosition(varExpression, expression);
 	@Override
 	public Void visitGetField(GetFieldExpression expression) {
 		expression.accept(this);
-		if (!checkAndGetFieldInfo(expression.field, false))
-			throw new IllegalStateException("Missing field info on a field member!");
+		getField(expression.field);
 		return null;
 	}
 
 	@Override
 	public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
-		JavaParameterInfo parameter = expression.parameter.getTag(JavaParameterInfo.class);
+		JavaParameterInfo parameter = module.getParameterInfo(expression.parameter);
 
 		if (parameter == null)
 			throw new RuntimeException(expression.position.toString() + ": Could not resolve lambda parameter" + expression.parameter);
 	@Override
 	public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
 		final Label label = new Label();
-		final JavaLocalVariableInfo tag = expression.variable.variable.getTag(JavaLocalVariableInfo.class);
-		if (tag == null)
-			throw new RuntimeException("Missing tag @ " + expression.position);
+		final JavaLocalVariableInfo tag = javaWriter.getLocalVariable(expression.variable.variable);
 		
 		tag.end = label;
 		javaWriter.load(tag.type, tag.local);
 	public Void visitGetMatchingVariantField(GetMatchingVariantField expression) {
 		javaWriter.loadObject(0);
 		final StoredType type = expression.value.option.getParameterType(expression.index);
-		final JavaVariantOption tag = expression.value.option.getTag(JavaVariantOption.class);
+		final JavaVariantOption tag = context.getJavaVariantOption(expression.value.option);
 		javaWriter.checkCast(tag.variantOptionClass.internalName);
 		javaWriter.getField(new JavaField(tag.variantOptionClass, "field" + expression.index, context.getDescriptor(type)));
 		return null;
 
 	@Override
 	public Void visitGetStaticField(GetStaticFieldExpression expression) {
-		if (!checkAndGetFieldInfo(expression.field, true))
-			throw new IllegalStateException("Missing field info on a field member!");
+		javaWriter.getStaticField(context.getJavaField(expression.field));
 		return null;
 	}
 
 		
 		BuiltinID builtin = expression.getter.member.builtin;
 		if (builtin == null) {
-			if (expression.getter.hasTag(JavaField.class)) {
-				javaWriter.getField(expression.getter.getTag(JavaField.class));
+			if (context.hasJavaField(expression.getter)) {
+				javaWriter.getField(context.getJavaField(expression.getter));
 				return null;
 			}
 			if (!checkAndExecuteMethodInfo(expression.getter, expression.type))
 		for (MatchExpression.Case aCase : expression.cases) {
 			if (aCase.key instanceof VariantOptionSwitchValue) {
 				VariantOptionSwitchValue variantOptionSwitchValue = (VariantOptionSwitchValue) aCase.key;
-				JavaVariantOption option = variantOptionSwitchValue.option.getTag(JavaVariantOption.class);
+				JavaVariantOption option = context.getJavaVariantOption(variantOptionSwitchValue.option);
 				javaWriter.invokeVirtual(JavaMethod.getNativeVirtual(option.variantClass, "getDenominator", "()I"));
 				break;
 			}
     @Override
     public Void visitNew(NewExpression expression) {
 		// TODO: this code is incorrect!
-		JavaMethod method = expression.constructor.getTag(JavaMethod.class);
+		JavaMethod method = context.getJavaMethod(expression.constructor);
 
         final String type;
         if (expression.type.type instanceof DefinitionTypeID)
 	public Void visitSetField(SetFieldExpression expression) {
 		expression.target.accept(this);
 		expression.value.accept(this);
-		if (!checkAndPutFieldInfo(expression.field, false))
-			throw new IllegalStateException("Missing field info on a field member!");
+		putField(expression.field);
 		return null;
 	}
 
     @Override
     public Void visitSetFunctionParameter(SetFunctionParameterExpression expression) {
         expression.value.accept(this);
-        JavaParameterInfo parameter = expression.parameter.getTag(JavaParameterInfo.class);
+        JavaParameterInfo parameter = module.getParameterInfo(expression.parameter);
         javaWriter.store(context.getType(expression.type), parameter.index);
         return null;
     }
 		expression.value.accept(this);
 		Label label = new Label();
 		javaWriter.label(label);
-		final JavaLocalVariableInfo tag = expression.variable.variable.getTag(JavaLocalVariableInfo.class);
+		final JavaLocalVariableInfo tag = javaWriter.getLocalVariable(expression.variable.variable);
 		tag.end = label;
 
 		javaWriter.store(tag.type, tag.local);
 	@Override
 	public Void visitSetStaticField(SetStaticFieldExpression expression) {
 		expression.value.accept(this);
-		
-		if (!checkAndPutFieldInfo(expression.field, true))
-			throw new IllegalStateException("Missing field info on a field member!");
-		
+		javaWriter.putStaticField(context.getJavaField(expression.field));
 		return null;
 	}
 
 	public Void visitStaticGetter(StaticGetterExpression expression) {
 		BuiltinID builtin = expression.getter.member.builtin;
 		if (builtin == null) {
-			if (expression.getter.hasTag(JavaField.class)) {
-				javaWriter.getStaticField(expression.getter.getTag(JavaField.class));
+			if (context.hasJavaField(expression.getter)) {
+				javaWriter.getStaticField(context.getJavaField(expression.getter));
 				return null;
 			}
 			
 				break;
 			case ENUM_VALUES: {
 				DefinitionTypeID type = (DefinitionTypeID) expression.type.type;
-				JavaClass cls = type.definition.getTag(JavaClass.class);
+				JavaClass cls = context.getJavaClass(type.definition);
 				javaWriter.invokeStatic(JavaMethod.getNativeStatic(cls, "values", "()[L" + cls.internalName + ";"));
 				break;
 			}
 
 	@Override
 	public Void visitVariantValue(VariantValueExpression expression) {
-		JavaVariantOption tag = expression.option.getTag(JavaVariantOption.class);
+		JavaVariantOption tag = context.getJavaVariantOption(expression.option);
 		final String internalName = tag.variantOptionClass.internalName;
 		javaWriter.newObject(internalName);
 		javaWriter.dup();
 
     //Will return true if a JavaMethodInfo.class tag exists, and will compile that tag
     private boolean checkAndExecuteMethodInfo(DefinitionMemberRef member, StoredType resultType) {
-        JavaMethod methodInfo = member.getTag(JavaMethod.class);
+        JavaMethod methodInfo = context.getJavaMethod(member);
         if (methodInfo == null)
             return false;
 
     }
 
     //Will return true if a JavaFieldInfo.class tag exists, and will compile that tag
-    public boolean checkAndPutFieldInfo(FieldMemberRef field, boolean isStatic) {
-		JavaField fieldInfo = field.getTag(JavaField.class);
-        if (fieldInfo == null)
-            return false;
-        //TODO Remove isStatic
-        if (field.isStatic() || isStatic) {
+    public void putField(FieldMemberRef field) {
+		JavaField fieldInfo = context.getJavaField(field);
+        if (field.isStatic()) {
             getJavaWriter().putStaticField(fieldInfo);
         } else {
             getJavaWriter().putField(fieldInfo);
-        }
-        return true;
+		}
     }
 
-	public boolean checkAndGetFieldInfo(ConstMemberRef field, boolean isStatic) {
-		final JavaField fieldInfo = field.getTag(JavaField.class);
-		if (fieldInfo == null)
-			return false;
-
-		getJavaWriter().getStaticField(fieldInfo);
-		return true;
-	}
-
-	public boolean checkAndGetFieldInfo(FieldMemberRef field, boolean isStatic) {
-		final JavaField fieldInfo = field.getTag(JavaField.class);
-		if (fieldInfo == null)
-			return false;
-
-		//TODO Remove isStatic
-		if (field.isStatic() || isStatic) {
+	public void getField(FieldMemberRef field) {
+		final JavaField fieldInfo = context.getJavaField(field);
+		if (field.isStatic()) {
 			getJavaWriter().getStaticField(fieldInfo);
 		} else {
 			getJavaWriter().getField(fieldInfo);
 		}
-		return true;
 	}
 }

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

 		javaWriter.swap();
 		javaWriter.getField("zsynthetic/IntRange", "from", "I");
 
-		final int z = variables[0].variable.getTag(JavaLocalVariableInfo.class).local;
+		final int z = javaWriter.getLocalVariable(variables[0].variable).local;
 		javaWriter.storeInt(z);
 		javaWriter.label(startLabel);
 		javaWriter.dup();
 	}
 
 	public void visitArrayValueIterator() {
-		handleArray(javaWriter.local(int.class), variables[0].variable.getTag(JavaLocalVariableInfo.class));
+		handleArray(javaWriter.local(int.class), javaWriter.getLocalVariable(variables[0].variable));
 	}
 
 	public void visitArrayKeyValueIterator() {
-		handleArray(variables[0].variable.getTag(JavaLocalVariableInfo.class).local, variables[1].variable.getTag(JavaLocalVariableInfo.class));
+		handleArray(javaWriter.getLocalVariable(variables[0].variable).local, javaWriter.getLocalVariable(variables[1].variable));
 	}
 
 	public void visitStringCharacterIterator() {
 		//TODO UNTESTED!
 		javaWriter.invokeSpecial("java/lang/String", "toCharArray()", "()[C");
-		handleArray(javaWriter.local(int.class), variables[0].variable.getTag(JavaLocalVariableInfo.class));
+		handleArray(javaWriter.local(int.class), javaWriter.getLocalVariable(variables[0].variable));
 	}
 
 	private void handleArray(final int z, final JavaLocalVariableInfo arrayTypeInfo) {

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

 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
-import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
-import org.openzen.zenscript.javashared.JavaParameterInfo;
+import org.openzen.zenscript.javashared.JavaCompiledModule;
 
 /**
  *
 public class JavaPreDecrementVisitor implements ExpressionVisitor<Void> {
 	private final JavaExpressionVisitor expressionCompiler;
 	private final JavaWriter javaWriter;
+	private final JavaCompiledModule module;
 	private final JavaBytecodeContext context;
 	
-	public JavaPreDecrementVisitor(JavaBytecodeContext context, JavaExpressionVisitor expressionCompiler) {
+	public JavaPreDecrementVisitor(JavaBytecodeContext context, JavaCompiledModule module, JavaExpressionVisitor expressionCompiler) {
 		this.expressionCompiler = expressionCompiler;
 		this.context = context;
+		this.module = module;
 		javaWriter = expressionCompiler.getJavaWriter();
 	}
 
 		javaWriter.dup();
 		javaWriter.store(objectType, local);
 		
-        if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))
-            throw new IllegalStateException("Missing field info on a field member!");
+        expressionCompiler.getField(expression.field);
 		
 		javaWriter.iConst1();
 		javaWriter.iSub();
 		
 		javaWriter.load(objectType, local);
-        if (!expressionCompiler.checkAndPutFieldInfo(expression.field, false))
-            throw new IllegalStateException("Missing field info on a field member!");
-		
+        expressionCompiler.putField(expression.field);
 		return null;
 	}
 
 	@Override
 	public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
-		javaWriter.idec(expression.parameter.getTag(JavaParameterInfo.class).index);
+		javaWriter.idec(module.getParameterInfo(expression.parameter).index);
 		return null;
 	}
 	
 	@Override
 	public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
-		javaWriter.idec(expression.variable.variable.getTag(JavaLocalVariableInfo.class).local);
+		javaWriter.idec(javaWriter.getLocalVariable(expression.variable.variable).local);
 		return null;
 	}
 
 
 	@Override
 	public Void visitGetStaticField(GetStaticFieldExpression expression) {
-		if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))
-            throw new IllegalStateException("Missing field info on a field member!");
-		
+		expressionCompiler.getField(expression.field);
 		javaWriter.iConst1();
 		javaWriter.iAdd();
-		
-		if (!expressionCompiler.checkAndPutFieldInfo(expression.field, false))
-            throw new IllegalStateException("Missing field info on a field member!");
-		
+		expressionCompiler.putField(expression.field);
 		return null;
 	}
 

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

 import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
+import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.JavaParameterInfo;
 
 /**
 public class JavaPreIncrementVisitor implements ExpressionVisitor<Void> {
 	private final JavaExpressionVisitor expressionCompiler;
 	private final JavaBytecodeContext context;
+	private final JavaCompiledModule module;
 	private final JavaWriter javaWriter;
 	
-	public JavaPreIncrementVisitor(JavaBytecodeContext context, JavaExpressionVisitor expressionCompiler) {
+	public JavaPreIncrementVisitor(JavaBytecodeContext context, JavaCompiledModule module, JavaExpressionVisitor expressionCompiler) {
 		this.expressionCompiler = expressionCompiler;
 		this.context = context;
+		this.module = module;
 		javaWriter = expressionCompiler.getJavaWriter();
 	}
 
 		javaWriter.dup();
 		javaWriter.store(objectType, local);
 		
-        if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))
-            throw new IllegalStateException("Missing field info on a field member!");
+        expressionCompiler.getField(expression.field);
 		
 		javaWriter.iConst1();
 		javaWriter.iAdd();
 		
 		javaWriter.load(objectType, local);
 		javaWriter.dupX1();
-        if (!expressionCompiler.checkAndPutFieldInfo(expression.field, false))
-            throw new IllegalStateException("Missing field info on a field member!");
-		
+        expressionCompiler.putField(expression.field);
 		return null;
 	}
 
 	@Override
 	public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
-		JavaParameterInfo parameter = expression.parameter.getTag(JavaParameterInfo.class);
+		JavaParameterInfo parameter = module.getParameterInfo(expression.parameter);
 		javaWriter.iinc(parameter.index);
 		javaWriter.load(parameter);
 		return null;
 
 	@Override
 	public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
-		JavaLocalVariableInfo localVariable = expression.variable.variable.getTag(JavaLocalVariableInfo.class);
+		JavaLocalVariableInfo localVariable = javaWriter.getLocalVariable(expression.variable.variable);
 		javaWriter.iinc(localVariable.local);
 		javaWriter.load(localVariable);
 		return null;
 
 	@Override
 	public Void visitGetStaticField(GetStaticFieldExpression expression) {
-		if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))
-            throw new IllegalStateException("Missing field info on a field member!");
-		
+		expressionCompiler.getField(expression.field);
 		javaWriter.iConst1();
 		javaWriter.iAdd();
 		javaWriter.dup();
-		
-		if (!expressionCompiler.checkAndPutFieldInfo(expression.field, false))
-            throw new IllegalStateException("Missing field info on a field member!");
-		
+		expressionCompiler.putField(expression.field);
 		return null;
 	}
 

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

 import java.util.List;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
+import org.openzen.zenscript.javashared.JavaCompiledModule;
 
 public class JavaStatementVisitor implements StatementVisitor<Boolean> {
     private final JavaWriter javaWriter;
     /**
      * @param javaWriter the method writer that compiles the statement
      */
-    public JavaStatementVisitor(JavaBytecodeContext context, JavaWriter javaWriter) {
+    public JavaStatementVisitor(JavaBytecodeContext context, JavaCompiledModule module, JavaWriter javaWriter) {
         this.javaWriter = javaWriter;
 		this.context = context;
-        this.expressionVisitor = new JavaExpressionVisitor(context, javaWriter);
+        this.expressionVisitor = new JavaExpressionVisitor(context, module, javaWriter);
     }
 
     public JavaStatementVisitor(JavaBytecodeContext context, JavaExpressionVisitor expressionVisitor) {
             final Label variableStart = new Label();
             final JavaLocalVariableInfo info = new JavaLocalVariableInfo(type, javaWriter.local(type), variableStart, variable.name);
             info.end = end;
-            variable.variable.setTag(JavaLocalVariableInfo.class, info);
+			javaWriter.setLocalVariable(variable.variable, info);
             javaWriter.addVariableInfo(info);
         }
 
 		final Label variableStart = new Label();
 		javaWriter.label(variableStart);
 		final JavaLocalVariableInfo info = new JavaLocalVariableInfo(type, local, variableStart, statement.name);
-		statement.variable.setTag(JavaLocalVariableInfo.class, info);
+		javaWriter.setLocalVariable(statement.variable, info);
 		javaWriter.addVariableInfo(info);
 		return false;
 	}

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

 import org.objectweb.asm.commons.LocalVariablesSorter;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.statement.VarStatement;
+import org.openzen.zenscript.codemodel.statement.VariableID;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 import org.openzen.zenscript.javashared.JavaParameterInfo;
 import org.openzen.zenscript.javashared.JavaClass;
     private boolean nameVariables = true;
     private int labelIndex = 1;
     private Map<Label, String> labelNames = new HashMap<>();
-
+	private final Map<VariableID, JavaLocalVariableInfo> localVariables = new HashMap<>();
+	
     public JavaWriter(
             ClassVisitor visitor,
             boolean nameVariables,
     public JavaWriter(ClassVisitor visitor, JavaMethod method, HighLevelDefinition forDefinition, String signature, String[] exceptions, String... annotations) {
         this(visitor, true, method, forDefinition, signature, exceptions, annotations);
     }
+	
+	public void setLocalVariable(VariableID variable, JavaLocalVariableInfo info) {
+		localVariables.put(variable, info);
+	}
+	
+	public JavaLocalVariableInfo getLocalVariable(VariableID variable) {
+		JavaLocalVariableInfo result = localVariables.get(variable);
+		if (result == null)
+			throw new IllegalStateException("Local variable unknown");
+		
+		return result;
+	}
 
     public void enableDebug() {
         debug = true;

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaDefinitionVisitor.java

 	public byte[] visitClass(ClassDefinition definition) {
         final String superTypeInternalName = definition.getSuperType() == null ? "java/lang/Object" : context.getInternalName(definition.getSuperType());
 
-		JavaClass toClass = definition.getTag(JavaClass.class);
+		JavaClass toClass = context.getJavaClass(definition);
 		JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
         //TODO: Calculate signature from generic parameters
 
 	@Override
 	public byte[] visitInterface(InterfaceDefinition definition) {
-		JavaClass toClass = definition.getTag(JavaClass.class);
+		JavaClass toClass = context.getJavaClass(definition);
 		ClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
 		//TODO: Calculate signature from generic parameters
 
 		ClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
-		JavaClass toClass = definition.getTag(JavaClass.class);
+		JavaClass toClass = context.getJavaClass(definition);
 		writer.visit(Opcodes.V1_8, Opcodes.ACC_ENUM | Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER | Opcodes.ACC_FINAL, toClass.internalName, "Ljava/lang/Enum<L" + toClass.internalName + ";>;", superTypeInternalName, null);
 
 		//Enum Stuff(required!)
 
 	@Override
 	public byte[] visitFunction(FunctionDefinition definition) {
-		CompilerUtils.tagMethodParameters(context, definition.header, true);
+		CompilerUtils.tagMethodParameters(context, context.getJavaModule(definition.module), definition.header, true);
 
         final String signature = context.getMethodSignature(definition.header);
-
-		final JavaMethod method = definition.caller.getTag(JavaMethod.class);
+		final JavaMethod method = context.getJavaMethod(definition.caller);
 
 		final JavaWriter writer = new JavaWriter(outerWriter, true, method, definition, signature, null);
-        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, writer);
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, context.getJavaModule(definition.module), writer);
         statementVisitor.start();
 		boolean returns = definition.caller.body.accept(statementVisitor);
 		if (!returns) {
 
 	@Override
 	public byte[] visitVariant(VariantDefinition variant) {
-		final JavaClass toClass = variant.getTag(JavaClass.class);
+		final JavaClass toClass = context.getJavaClass(variant);
 		final JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
 		final String variantName = variant.name;
 		final List<VariantDefinition.Option> options = variant.options;
 		//Each option is one of the possible child classes
 		for (final VariantDefinition.Option option : options) {
-			JavaVariantOption optionTag = option.getTag(JavaVariantOption.class);
+			JavaVariantOption optionTag = context.getJavaVariantOption(option);
 			final JavaClassWriter optionWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 			final String optionClassName = variantName + "$" + option.name;
 			JavaClassWriter.registerSuperClass(optionClassName, variantName);

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaMemberVisitor.java

 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.*;
-import org.openzen.zenscript.javashared.JavaParameterInfo;
 import org.openzen.zenscript.javabytecode.compiler.*;
 
 import java.util.List;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.JavaField;
 import org.openzen.zenscript.javashared.JavaMethod;
 
     private final HighLevelDefinition definition;
     private final JavaStatementVisitor clinitStatementVisitor;
     private EnumDefinition enumDefinition = null;
+	private final JavaCompiledModule javaModule;
 
     public JavaMemberVisitor(JavaBytecodeContext context, ClassWriter writer, JavaClass toClass, HighLevelDefinition definition) {
         this.writer = writer;
         this.toClass = toClass;
         this.definition = definition;
 		this.context = context;
+		javaModule = context.getJavaModule(definition.module);
 
         final JavaWriter javaWriter = new JavaWriter(writer, new JavaMethod(toClass, JavaMethod.Kind.STATICINIT, "<clinit>", true, "()V", 0, false), definition, null, null);
-        this.clinitStatementVisitor = new JavaStatementVisitor(context, javaWriter);
+        this.clinitStatementVisitor = new JavaStatementVisitor(context, javaModule, javaWriter);
         this.clinitStatementVisitor.start();
         CompilerUtils.writeDefaultFieldInitializers(context, javaWriter, definition, true);
     }
 
 	@Override
 	public Void visitConst(ConstMember member) {
-		JavaField field = member.getTag(JavaField.class);
+		JavaField field = context.getJavaField(member);
         writer.visitField(CompilerUtils.calcAccess(member.getEffectiveModifiers()), field.name, field.descriptor, field.signature, null).visitEnd();
         return null;
 	}
 
 	@Override
 	public Void visitField(FieldMember member) {
-		JavaField field = member.getTag(JavaField.class);
+		JavaField field = context.getJavaField(member);
         writer.visitField(CompilerUtils.calcAccess(member.getEffectiveModifiers()), field.name, field.descriptor, field.signature, null).visitEnd();
         return null;
     }
     @Override
     public Void visitConstructor(ConstructorMember member) {
         final boolean isEnum = definition instanceof EnumDefinition;
-        final JavaMethod method = member.getTag(JavaMethod.class);
+        final JavaMethod method = context.getJavaMethod(member);
 
         final Label constructorStart = new Label();
         final Label constructorEnd = new Label();
         final JavaWriter constructorWriter = new JavaWriter(writer, method, definition, context.getMethodSignature(member.header), null);
         constructorWriter.label(constructorStart);
-        CompilerUtils.tagConstructorParameters(context, member.header, isEnum);
+        CompilerUtils.tagConstructorParameters(context, javaModule, member.header, isEnum);
         for (FunctionParameter parameter : member.header.parameters) {
             constructorWriter.nameVariable(
-                    parameter.getTag(JavaParameterInfo.class).index,
+                    javaModule.getParameterInfo(parameter).index,
                     parameter.name,
                     constructorStart,
                     constructorEnd,
                     context.getType(parameter.type));
         }
 
-        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, constructorWriter);
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, constructorWriter);
         statementVisitor.start();
 
 		if (!member.isConstructorForwarded()) {
 		final JavaWriter destructorWriter = new JavaWriter(writer, method, definition, null, null);
 		destructorWriter.label(constructorStart);
 
-        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, destructorWriter);
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, destructorWriter);
         statementVisitor.start();
 		// TODO: destruction of members (to be done when memory tags are implemented)
 		member.body.accept(statementVisitor);
 
     @Override
     public Void visitMethod(MethodMember member) {
-        CompilerUtils.tagMethodParameters(context, member.header, member.isStatic());
+        CompilerUtils.tagMethodParameters(context, javaModule, member.header, member.isStatic());
 
         final boolean isAbstract = member.body == null || Modifiers.isAbstract(member.getEffectiveModifiers());
-        final JavaMethod method = member.getTag(JavaMethod.class);
+        final JavaMethod method = context.getJavaMethod(member);
 
 		final Label methodStart = new Label();
 		final Label methodEnd = new Label();
 		for (final FunctionParameter parameter : member.header.parameters) {
 			methodWriter.nameParameter(0, parameter.name);
 			if (!isAbstract)
-				methodWriter.nameVariable(parameter.getTag(JavaParameterInfo.class).index, parameter.name, methodStart, methodEnd, context.getType(parameter.type));
+				methodWriter.nameVariable(javaModule.getParameterInfo(parameter).index, parameter.name, methodStart, methodEnd, context.getType(parameter.type));
 		}
 
-        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, methodWriter);
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);
 
 		if (!isAbstract) {
 			statementVisitor.start();

JavaShared/build.gradle

 
 dependencies {
 	compile project(':CodeModel')
+	compile project(':CompilerShared')
 }

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

+package org.openzen.zenscript.javashared;
+
+import org.openzen.zenscript.compiler.ZenCodeCompiler;
+
+/*
+ * 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.
+ */
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public abstract class JavaBaseCompiler implements ZenCodeCompiler {
+	
+}

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

 		return kind == Kind.ENUM;
 	}
 	
+	public boolean isInterface() {
+		return kind == Kind.INTERFACE;
+	}
+	
 	public enum Kind {
 		CLASS,
 		INTERFACE,

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javashared;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.ImplementationMember;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaCompiledModule {
+	public final Module module;
+	
+	private final Map<HighLevelDefinition, JavaClass> classes = 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<>();
+	private final Map<IDefinitionMember, JavaMethod> methods = new HashMap<>();
+	private final Map<FunctionParameter, JavaParameterInfo> parameters = new HashMap<>();
+	private final Map<VariantDefinition.Option, JavaVariantOption> variantOptions = new HashMap<>();
+	
+	public JavaCompiledModule(Module module) {
+		this.module = module;
+	}
+	
+	public void setClassInfo(HighLevelDefinition definition, JavaClass cls) {
+		classes.put(definition, cls);
+	}
+	
+	public JavaClass getClassInfo(HighLevelDefinition definition) {
+		JavaClass cls = classes.get(definition);
+		if (cls == null)
+			throw new IllegalStateException("Missing class info for class " + definition.name);
+		
+		return cls;
+	}
+	
+	public JavaClass optClassInfo(HighLevelDefinition definition) {
+		return classes.get(definition);
+	}
+	
+	public boolean hasClassInfo(HighLevelDefinition definition) {
+		return classes.containsKey(definition);
+	}
+	
+	public void setNativeClassInfo(HighLevelDefinition definition, JavaNativeClass cls) {
+		nativeClasses.put(definition, cls);
+	}
+	
+	public JavaNativeClass getNativeClassInfo(HighLevelDefinition definition) {
+		return nativeClasses.get(definition);
+	}
+	
+	public void setVariantOption(VariantDefinition.Option option, JavaVariantOption value) {
+		variantOptions.put(option, value);
+	}
+	
+	public JavaVariantOption getVariantOption(VariantDefinition.Option option) {
+		JavaVariantOption result = variantOptions.get(option);
+		if (result == null)
+			throw new IllegalStateException("Variant option unknown: " + option.name);
+		
+		return result;
+	}
+	
+	public void setImplementationInfo(ImplementationMember member, JavaImplementation implementation) {
+		implementations.put(member, implementation);
+	}
+	
+	public JavaImplementation getImplementationInfo(ImplementationMember member) {
+		JavaImplementation implementation = implementations.get(member);
+		if (implementation == null)
+			throw new IllegalStateException("Implementation unknown: " + member.type);
+		
+		return implementation;
+	}
+	
+	public void setFieldInfo(IDefinitionMember member, JavaField field) {
+		fields.put(member, field);
+	}
+	
+	public JavaField optFieldInfo(IDefinitionMember member) {
+		return fields.get(member);
+	}
+	
+	public JavaField getFieldInfo(IDefinitionMember member) {
+		JavaField field = fields.get(member);
+		if (field == null)
+			throw new IllegalStateException("Missing field info for field " + member.getDefinition().name + "." + member.describe());
+		
+		return field;
+	}
+	
+	public void setMethodInfo(IDefinitionMember member, JavaMethod method) {
+		methods.put(member, method);
+	}
+	
+	public JavaMethod getMethodInfo(DefinitionMemberRef member) {
+		return getMethodInfo(member.getTarget());
+	}
+	
+	public JavaMethod getMethodInfo(IDefinitionMember member) {
+		JavaMethod method = methods.get(member);
+		if (method == null)
+			throw new IllegalStateException("Missing field info for field " + member.getDefinition().name + "." + member.describe());
+		
+		return method;
+	}
+	
+	public void setParameterInfo(FunctionParameter parameter, JavaParameterInfo info) {
+		parameters.put(parameter, info);
+	}
+	
+	public JavaParameterInfo getParameterInfo(FunctionParameter parameter) {
+		JavaParameterInfo info = parameters.get(parameter);
+		if (info == null)
+			throw new IllegalStateException("Missing parameter info for parameter " + parameter.name);
+		
+		return info;
+	}
+}

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 	private final Map<String, JavaSynthesizedRange> ranges = new HashMap<>();
 	private boolean useShared = false;
 	
+	private final Map<Module, JavaCompiledModule> modules = new HashMap<>();
+	
 	public JavaContext(GlobalTypeRegistry registry) {
 		this.registry = registry;
 		
 	}
 	
 	protected abstract JavaSyntheticClassGenerator getTypeGenerator();
-			
+		
 	public abstract String getDescriptor(TypeID type);
 	
 	public abstract String getDescriptor(StoredType type);
 	
+	public void addModule(Module module) {
+		modules.put(module, new JavaCompiledModule(module));
+	}
+	
+	public JavaCompiledModule getJavaModule(Module module) {
+		JavaCompiledModule javaModule = modules.get(module);
+		if (javaModule == null)
+			throw new IllegalStateException("Module not yet registered: " + module.name);
+		
+		return javaModule;
+	}
+	
+	public JavaClass getJavaClass(HighLevelDefinition definition) {
+		return getJavaModule(definition.module).getClassInfo(definition);
+	}
+	
+	public JavaClass optJavaClass(HighLevelDefinition definition) {
+		return getJavaModule(definition.module).optClassInfo(definition);
+	}
+	
+	public JavaNativeClass getJavaNativeClass(HighLevelDefinition definition) {
+		return getJavaModule(definition.module).getNativeClassInfo(definition);
+	}
+	
+	public boolean hasJavaClass(HighLevelDefinition definition) {
+		return getJavaModule(definition.module).hasClassInfo(definition);
+	}
+	
+	public void setJavaClass(HighLevelDefinition definition, JavaClass cls) {
+		getJavaModule(definition.module).setClassInfo(definition, cls);
+	}
+	
+	public void setJavaNativeClass(HighLevelDefinition definition, JavaNativeClass cls) {
+		getJavaModule(definition.module).setNativeClassInfo(definition, cls);
+	}
+	
+	public boolean hasJavaField(DefinitionMemberRef member) {
+		HighLevelDefinition definition = member.getTarget().getDefinition();
+		return getJavaModule(definition.module).optFieldInfo(member.getTarget()) != null;
+	}
+	
+	public JavaField getJavaField(IDefinitionMember member) {
+		HighLevelDefinition definition = member.getDefinition();
+		return getJavaModule(definition.module).getFieldInfo(member);
+	}
+	
+	public JavaField getJavaField(DefinitionMemberRef member) {
+		return getJavaField(member.getTarget());
+	}
+	
+	public JavaMethod getJavaMethod(IDefinitionMember member) {
+		HighLevelDefinition definition = member.getDefinition();
+		return getJavaModule(definition.module).getMethodInfo(member);
+	}
+	
+	public JavaMethod getJavaMethod(DefinitionMemberRef member) {
+		return getJavaMethod(member.getTarget());
+	}
+	
+	public JavaVariantOption getJavaVariantOption(VariantDefinition.Option option) {
+		HighLevelDefinition definition = option.variant;
+		return getJavaModule(definition.module).getVariantOption(option);
+	}
+	
+	public JavaVariantOption getJavaVariantOption(VariantOptionRef member) {
+		return getJavaVariantOption(member.getOption());
+	}
+	
 	public void useShared() {
 		if (useShared)
 			return;

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

 
     @Override
     public String visitDefinition(DefinitionTypeID definition) {
-		JavaClass cls = definition.definition.getTag(JavaClass.class);
-		if (cls == null)
-			throw new IllegalStateException("Class not yet initialized: " + definition.definition.name);
-		
+		JavaClass cls = context.getJavaClass(definition.definition);
 		return "L" + cls.internalName + ";";
     }
 

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

 
     @Override
     public String visitDefinition(StoredType context, DefinitionTypeID definition) {
-		return definition.definition.getTag(JavaClass.class).internalName;
+		return this.context.getJavaClass(definition.definition).internalName;
     }
 
     @Override

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

 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.javashared.JavaTypeNameVisitor;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.JavaField;
 import org.openzen.zenscript.javashared.JavaContext;
 import org.openzen.zenscript.javashared.JavaImplementation;
 	private static final boolean DEBUG_EMPTY = true;
 	
 	private final JavaContext context;
+	private final JavaCompiledModule module;
 	private final JavaClass cls;
 	private final JavaNativeClass nativeClass;
 	private final JavaPrepareDefinitionMemberVisitor memberPreparer;
 	
 	public JavaPrepareClassMethodVisitor(
 			JavaContext context,
+			JavaCompiledModule module,
 			JavaClass cls,
 			JavaNativeClass nativeClass,
 			JavaPrepareDefinitionMemberVisitor memberPreparer,
 			boolean startsEmpty) {
 		this.context = context;
+		this.module = module;
 		this.cls = cls;
 		this.nativeClass = nativeClass;
 		this.memberPreparer = memberPreparer;
 			System.out.println("Class " + cls.fullName + " not empty because of const " + member.name);
 		
 		cls.empty = false;
-		member.setTag(JavaField.class, new JavaField(cls, member.name, context.getDescriptor(member.type)));
+		module.setFieldInfo(member, new JavaField(cls, member.name, context.getDescriptor(member.type)));
 		return null;
 	}
 	
 	@Override
 	public Void visitField(FieldMember member) {
 		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.type));
-		member.setTag(JavaField.class, field);
+		module.setFieldInfo(member, field);
 		if (member.hasAutoGetter()) {
 			visitGetter(member.autoGetter);
-			member.autoGetter.setTag(JavaField.class, field);
+			module.setFieldInfo(member.autoGetter, field);
 		}
 		if (member.hasAutoSetter()) {
 			visitSetter(member.autoSetter);
+			module.setFieldInfo(member.autoSetter, field);
 		}
 		
 		return null;
 		memberPreparer.prepare(member.type);
 		
 		if (canMergeImplementation(member)) {
-			member.setTag(JavaImplementation.class, new JavaImplementation(true, cls));
+			module.setImplementationInfo(member, new JavaImplementation(true, cls));
 			for (IDefinitionMember m : member.members)
 				m.accept(this);
 		} else {
 			cls.empty = false;
 			
 			JavaClass implementationClass = new JavaClass(cls, JavaTypeNameVisitor.INSTANCE.process(member.type) + "Implementation", JavaClass.Kind.CLASS);
-			member.setTag(JavaImplementation.class, new JavaImplementation(false, implementationClass));
+			module.setImplementationInfo(member, new JavaImplementation(false, implementationClass));
 			
-			JavaPrepareClassMethodVisitor visitor = new JavaPrepareClassMethodVisitor(context, implementationClass, null, memberPreparer, true);
+			JavaPrepareClassMethodVisitor visitor = new JavaPrepareClassMethodVisitor(context, module, implementationClass, null, memberPreparer, true);
 			for (IDefinitionMember m : member.members)
 				m.accept(visitor);
 		}
 
 	@Override
 	public Void visitInnerDefinition(InnerDefinitionMember member) {
-		JavaPrepareDefinitionMemberVisitor innerDefinitionPrepare = new JavaPrepareDefinitionMemberVisitor(context);
+		JavaPrepareDefinitionMemberVisitor innerDefinitionPrepare = new JavaPrepareDefinitionMemberVisitor(context, module);
 		member.innerDefinition.accept(innerDefinitionPrepare);
 		
 		if (DEBUG_EMPTY && cls.empty)
 		
 		if (member.getOverrides() != null) {
 			DefinitionMemberRef base = member.getOverrides();
-			JavaMethod baseMethod = base.getTarget().getTag(JavaMethod.class);
-			if (baseMethod == null)
-				throw new IllegalStateException("Base method not yet prepared!");
-			
+			JavaMethod baseMethod = context.getJavaMethod(base.getTarget());
 			method = new JavaMethod(
 					cls,
 					baseMethod.kind,
 			cls.empty = false;
 		}
 		
-		member.setTag(JavaMethod.class, method);
+		module.setMethodInfo(member, method);
 	}
 }

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

 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.JavaContext;
 import org.openzen.zenscript.javashared.JavaMethod;
 import org.openzen.zenscript.javashared.JavaModifiers;
  */
 public class JavaPrepareDefinitionMemberVisitor implements DefinitionVisitor<JavaClass> {
 	private final JavaContext context;
+	private final JavaCompiledModule module;
 	
-	public JavaPrepareDefinitionMemberVisitor(JavaContext context) {
+	public JavaPrepareDefinitionMemberVisitor(JavaContext context, JavaCompiledModule module) {
 		this.context = context;
+		this.module = module;
 	}
 	
 	private boolean isPrepared(HighLevelDefinition definition) {
-		return definition.getTag(JavaClass.class).membersPrepared;
+		return context.getJavaClass(definition).membersPrepared;
 	}
 	
 	public void prepare(TypeID type) {
 	@Override
 	public JavaClass visitClass(ClassDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaClass.class);
+			return context.getJavaClass(definition);
 		
 		return visitClassCompiled(definition, true, JavaClass.Kind.CLASS);
 	}
 	@Override
 	public JavaClass visitInterface(InterfaceDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaClass.class);
+			return context.getJavaClass(definition);
 		
 		for (TypeID baseType : definition.baseInterfaces)
 			prepare(baseType);
 	@Override
 	public JavaClass visitEnum(EnumDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaClass.class);
+			return context.getJavaClass(definition);
 		
 		return visitClassCompiled(definition, false, JavaClass.Kind.ENUM);
 	}
 	@Override
 	public JavaClass visitStruct(StructDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaClass.class);
+			return context.getJavaClass(definition);
 		
 		return visitClassCompiled(definition, true, JavaClass.Kind.CLASS);
 	}
 	@Override
 	public JavaClass visitFunction(FunctionDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaClass.class);
+			return context.getJavaClass(definition);
 		
-		JavaClass cls = definition.getTag(JavaClass.class);
+		JavaClass cls = context.getJavaClass(definition);
 		JavaMethod method = JavaMethod.getStatic(cls, definition.name, context.getMethodDescriptor(definition.header), JavaModifiers.getJavaModifiers(definition.modifiers));
-		definition.caller.setTag(JavaMethod.class, method);
+		module.setMethodInfo(definition.caller, method);
 		return cls;
 	}
 
 	@Override
 	public JavaClass visitExpansion(ExpansionDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaClass.class);
+			return context.getJavaClass(definition);
 		
-		JavaNativeClass nativeClass = definition.getTag(JavaNativeClass.class);
-		JavaClass cls = definition.getTag(JavaClass.class);
+		JavaNativeClass nativeClass = context.getJavaNativeClass(definition);
+		JavaClass cls = context.getJavaClass(definition);
 		visitExpansionMembers(definition, cls, nativeClass);
 		return cls;
 	}
 
 	@Override
 	public JavaClass visitVariant(VariantDefinition variant) {
-		if (isPrepared(variant))
-			return variant.getTag(JavaClass.class);
+		JavaClass cls = context.getJavaClass(variant);
+		if (cls.membersPrepared)
+			return cls;
 		
-		JavaClass cls = variant.getTag(JavaClass.class);
 		visitClassMembers(variant, cls, null, false);
 		return cls;
 	}
 		if (definition.getSuperType() != null)
 			prepare(definition.getSuperType());
 		
-		JavaNativeClass nativeClass = definition.getTag(JavaNativeClass.class);
-		JavaClass cls = definition.getTag(JavaClass.class);
+		JavaNativeClass nativeClass = context.getJavaNativeClass(definition);
+		JavaClass cls = context.getJavaClass(definition);
 		if (nativeClass == null) {
 			visitClassMembers(definition, cls, null, startsEmpty);
 		} else {
 	
 	private void visitClassMembers(HighLevelDefinition definition, JavaClass cls, JavaNativeClass nativeClass, boolean startsEmpty) {
 		System.out.println("Preparing " + cls.internalName);
-		JavaPrepareClassMethodVisitor methodVisitor = new JavaPrepareClassMethodVisitor(context, cls, nativeClass, this, startsEmpty);
+		JavaPrepareClassMethodVisitor methodVisitor = new JavaPrepareClassMethodVisitor(context, module, cls, nativeClass, this, startsEmpty);
 		for (IDefinitionMember member : definition.members) {
 			member.accept(methodVisitor);
 		}
 	
 	private void visitExpansionMembers(HighLevelDefinition definition, JavaClass cls, JavaNativeClass nativeClass) {
 		System.out.println("Preparing " + cls.internalName);
-		JavaPrepareExpansionMethodVisitor methodVisitor = new JavaPrepareExpansionMethodVisitor(context, cls, nativeClass);
+		JavaPrepareExpansionMethodVisitor methodVisitor = new JavaPrepareExpansionMethodVisitor(context, module, cls, nativeClass);
 		for (IDefinitionMember member : definition.members) {
 			member.accept(methodVisitor);
 		}

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

 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaCompiledModule;
+import org.openzen.zenscript.javashared.JavaContext;
 import org.openzen.zenscript.javashared.JavaMethod;
 import org.openzen.zenscript.javashared.JavaVariantOption;
 
 		}
 	}
 	
+	private final JavaContext context;
 	private final String filename;
 	private final JavaClass outerClass;
+	private final JavaCompiledModule module;
 	
-	public JavaPrepareDefinitionVisitor(String filename, JavaClass outerClass) {
+	public JavaPrepareDefinitionVisitor(JavaContext context, JavaCompiledModule module, String filename, JavaClass outerClass) {
+		this.context = context;
 		this.filename = filename;
 		this.outerClass = outerClass;
+		this.module = module;
 	}
 	
 	private boolean isPrepared(HighLevelDefinition definition) {
-		return definition.hasTag(JavaClass.class);
+		return context.hasJavaClass(definition);
 	}
 	
 	public void prepare(TypeID type) {
 	@Override
 	public JavaClass visitClass(ClassDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaClass.class);
+			return context.getJavaClass(definition);
 		
 		return visitClassCompiled(definition, true, JavaClass.Kind.CLASS);
 	}
 	@Override
 	public JavaClass visitInterface(InterfaceDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaClass.class);
+			return context.getJavaClass(definition);
 		
 		for (TypeID baseType : definition.baseInterfaces)
 			prepare(baseType);
 	@Override
 	public JavaClass visitEnum(EnumDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaClass.class);
+			return context.getJavaClass(definition);
 		
 		return visitClassCompiled(definition, false, JavaClass.Kind.ENUM);
 	}
 	@Override
 	public JavaClass visitStruct(StructDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaClass.class);
+			return context.getJavaClass(definition);
 		
 		return visitClassCompiled(definition, true, JavaClass.Kind.CLASS);
 	}
 	@Override
 	public JavaClass visitFunction(FunctionDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaClass.class);
+			return context.getJavaClass(definition);
 		
 		JavaClass cls = new JavaClass(definition.pkg.fullName, JavaClass.getNameFromFile(filename), JavaClass.Kind.CLASS);
-		definition.setTag(JavaClass.class, cls);
+		context.setJavaClass(definition, cls);
 		return cls;
 	}
 
 	@Override
 	public JavaClass visitExpansion(ExpansionDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaClass.class);
+			return context.getJavaClass(definition);
 		
 		NativeTag nativeTag = definition.getTag(NativeTag.class);
 		if (nativeTag != null) {
-			definition.setTag(JavaNativeClass.class, nativeClasses.get(nativeTag.value));
+			context.setJavaNativeClass(definition, nativeClasses.get(nativeTag.value));
 		}
 		
 		JavaClass cls = new JavaClass(definition.pkg.fullName, JavaClass.getNameFromFile(filename), JavaClass.Kind.CLASS);
-		definition.setTag(JavaClass.class, cls);
+		context.setJavaClass(definition, cls);
 		return cls;
 	}
 
 	@Override
 	public JavaClass visitVariant(VariantDefinition variant) {
 		if (isPrepared(variant))
-			return variant.getTag(JavaClass.class);
+			return context.getJavaClass(variant);
 		
 		JavaClass cls = new JavaClass(variant.pkg.fullName, variant.name, JavaClass.Kind.CLASS);
-		variant.setTag(JavaClass.class, cls);
+		context.setJavaClass(variant, cls);
 		
 		for (VariantDefinition.Option option : variant.options) {
 			JavaClass variantCls = new JavaClass(cls, option.name, JavaClass.Kind.CLASS);
-			option.setTag(JavaVariantOption.class, new JavaVariantOption(cls, variantCls));
+			module.setVariantOption(option, new JavaVariantOption(cls, variantCls));
 		}
 		
 		return cls;
 		if (nativeClass == null) {
 			cls = outerClass == null ? new JavaClass(definition.pkg.fullName, definition.name, kind) : new JavaClass(outerClass, definition.name, kind);
 			cls.destructible = definition.isDestructible();
-			definition.setTag(JavaClass.class, cls);
+			context.setJavaClass(definition, cls);
 		} else {
 			cls = outerClass == null ? new JavaClass(definition.pkg.fullName, filename, kind) : new JavaClass(outerClass, filename, kind);
-			definition.setTag(JavaClass.class, nativeClass.cls);
-			definition.setTag(JavaNativeClass.class, nativeClass);
+			
+			context.setJavaClass(definition, nativeClass.cls);
+			context.setJavaNativeClass(definition, nativeClass);
 			
 			if (nativeClass.nonDestructible)
 				cls.destructible = false;
 		
 		for (IDefinitionMember member : definition.members) {
 			if (member instanceof InnerDefinitionMember) {
-				((InnerDefinitionMember) member).innerDefinition.accept(new JavaPrepareDefinitionVisitor(filename, cls));
+				((InnerDefinitionMember) member).innerDefinition.accept(new JavaPrepareDefinitionVisitor(context, module, filename, cls));
 			}
 		}
 		

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

 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.javashared.JavaTypeNameVisitor;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.JavaField;
 import org.openzen.zenscript.javashared.JavaContext;
 import org.openzen.zenscript.javashared.JavaImplementation;
 	private static final boolean DEBUG_EMPTY = true;
 	
 	private final JavaContext context;
+	private final JavaCompiledModule module;
 	private final JavaClass cls;
 	private final JavaNativeClass nativeClass;
 	
-	public JavaPrepareExpansionMethodVisitor(JavaContext context, JavaClass cls, JavaNativeClass nativeClass) {
+	public JavaPrepareExpansionMethodVisitor(JavaContext context, JavaCompiledModule module, JavaClass cls, JavaNativeClass nativeClass) {
+		this.module = module;
 		this.cls = cls;
 		this.nativeClass = nativeClass;
 		this.context = context;
 	
 	@Override
 	public Void visitConst(ConstMember member) {
-		member.setTag(JavaField.class, new JavaField(cls, member.name, context.getDescriptor(member.type)));
+		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.type));
+		module.setFieldInfo(member, field);
 		
 		if (DEBUG_EMPTY && cls.empty)
 			System.out.println("Class " + cls.fullName + " not empty because of const");
 	@Override
 	public Void visitField(FieldMember member) {
 		// TODO: expansion fields
-		member.setTag(JavaField.class, new JavaField(cls, member.name, context.getDescriptor(member.type)));
+		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.type));
+		module.setFieldInfo(member, field);
+		
 		if (member.hasAutoGetter() || member.hasAutoSetter())
 			cls.empty = false;
 		return null;
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
 		JavaClass implementationClass = new JavaClass(cls, JavaTypeNameVisitor.INSTANCE.process(member.type) + "Implementation", JavaClass.Kind.CLASS);
-		member.setTag(JavaImplementation.class, new JavaImplementation(false, implementationClass));
+		module.setImplementationInfo(member, new JavaImplementation(false, implementationClass));
 		for (IDefinitionMember implementedMember : member.members)
 			implementedMember.accept(this);
 		
 			cls.empty = false;
 		}
 		
-		member.setTag(JavaMethod.class, method);
+		module.setMethodInfo(member, method);
 	}
 	
 	private JavaMethod.Kind getKind(DefinitionMember member) {

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

 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
 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 List<ExpansionDefinition> expansions;
 	private final StringBuilder output;
 	private final Map<HighLevelDefinition, SemanticModule> modules;
+	private final JavaContext context;
+	private final JavaCompiledModule module;
 	
 	public JavaDefinitionVisitor(
 			String indent,
 			JavaSourceCompiler compiler,
+			JavaCompiledModule module,
 			JavaClass cls,
 			JavaSourceFile file,
 			StringBuilder output,
 		this.output = output;
 		this.expansions = expansions;
 		this.modules = modules;
+		this.context = compiler.context;
+		this.module = module;
 	}
 	
 	private JavaSourceFileScope createScope(HighLevelDefinition definition) {
 		CompileScope scope = new CompileScope(module.compilationUnit.globalTypeRegistry, module.expansions, module.annotations, module.storageTypes);
 		return new JavaSourceFileScope(file.importer, compiler.helperGenerator, cls, scope, definition instanceof InterfaceDefinition, thisType, compiler.context);
 	}
+	
+	private List<ImplementationMember> getMergedImplementations(HighLevelDefinition definition) {
+		List<ImplementationMember> result = new ArrayList<>();
+		for (IDefinitionMember member : definition.members) {
+			if (member instanceof ImplementationMember) {
+				JavaImplementation implementation = module.getImplementationInfo((ImplementationMember) member);
+				if (implementation.inline)
+					result.add((ImplementationMember)member);
+			}
+		}
+		return result;
+	}
 
 	@Override
 	public Void visitClass(ClassDefinition definition) {
 		JavaSourceFileScope scope = createScope(definition);
-		JavaClass cls = definition.getTag(JavaClass.class);
+		JavaClass cls = context.getJavaClass(definition);
 		
 		output.append(indent);
 		convertModifiers(definition.modifiers);
 			output.append(" extends ");
 			output.append(scope.type(definition.getSuperType()));
 		}
-		List<ImplementationMember> mergedImplementations = new ArrayList<>();
-		for (IDefinitionMember member : definition.members) {
-			if (member instanceof ImplementationMember) {
-				JavaImplementation implementation = ((ImplementationMember) member).getTag(JavaImplementation.class);
-				if (implementation.inline)
-					mergedImplementations.add((ImplementationMember)member);
-			}
-		}
 		
+		List<ImplementationMember> mergedImplementations = getMergedImplementations(definition);
 		if (mergedImplementations.size() > 0 || cls.destructible) {
 			output.append(" implements ");
 			boolean first = true;
 	@Override
 	public Void visitInterface(InterfaceDefinition definition) {
 		JavaSourceFileScope scope = createScope(definition);
-		JavaClass cls = definition.getTag(JavaClass.class);
+		JavaClass cls = context.getJavaClass(definition);
 		
 		output.append(indent);
 		convertModifiers(definition.modifiers | Modifiers.VIRTUAL); // to prevent 'final'
 			output.append(scope.type(base));
 		}
 		
+		List<ImplementationMember> mergedImplementations = getMergedImplementations(definition);
+		for (ImplementationMember member : mergedImplementations) {
+			if (firstExtends) {
+				firstExtends = false;
+				output.append(" extends ");
+			} else {
+				output.append(", ");
+			}
+			output.append(scope.type(member.type));
+		}
+		
 		output.append(" {\n");
 		compileMembers(scope, definition);
 		compileExpansions();
 	}
 	
 	private void compileMembers(JavaSourceFileScope scope, HighLevelDefinition definition) {
-		if (definition.hasTag(JavaNativeClass.class)) {
+		if (context.getJavaNativeClass(definition) != null) {
 			StoredType[] typeParameters = new StoredType[definition.getNumberOfGenericParameters()];
 			for (int i = 0; i < typeParameters.length; i++)
 				typeParameters[i] = scope.semanticScope.getTypeRegistry().getGeneric(definition.typeParameters[i]).stored(definition.typeParameters[i].storage);
 				member.accept(memberCompiler);
 			memberCompiler.finish();
 		} else {
-			JavaMemberCompiler memberCompiler = new JavaMemberCompiler(compiler, 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, modules);
 			for (IDefinitionMember member : definition.members)
 				member.accept(memberCompiler);
 			

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

 	}
 	
 	private void compileMethod(DefinitionMember member, FunctionHeader header, Statement body) {
-		JavaMethod method = member.getTag(JavaMethod.class);
-		if (method == null)
-			throw new AssertionError();
+		JavaMethod method = scope.context.getJavaMethod(member);
 		if (!method.compile)
 			return;
 		

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

 import org.openzen.zenscript.compiler.SemanticModule;
 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 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;
 	
 	public JavaMemberCompiler(
 			JavaSourceCompiler compiler,
+			JavaCompiledModule module,
 			JavaSourceFile file,
 			JavaSourceFormattingSettings settings,
 			String indent,
 		this.isInterface = isInterface;
 		this.compiler = compiler;
 		this.modules = modules;
+		this.context = compiler.context;
+		this.module = module;
 	}
 	
 	private void compileMethod(DefinitionMember member, FunctionHeader header, Statement body) {
-		JavaMethod method = member.getTag(JavaMethod.class);
-		if (method == null)
-			throw new AssertionError();
+		JavaMethod method = module.getMethodInfo(member);
 		if (!method.compile)
 			return;
 		
 
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
-		JavaImplementation implementation = member.getTag(JavaImplementation.class);
+		JavaImplementation implementation = module.getImplementationInfo(member);
 		if (implementation.inline) {
 			for (IDefinitionMember m : member.members) {
 				m.accept(this);
 			
 			begin(ElementType.INNERCLASS);
 			output.append("private class ").append(implementationName).append(" implements ").append(scope.type(member.type)).append(" {\n");
-			JavaMemberCompiler memberCompiler = new JavaMemberCompiler(compiler, 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, modules);
 			for (IDefinitionMember m : member.members) {
 				m.accept(memberCompiler);
 			}
 
 	@Override
 	public Void visitInnerDefinition(InnerDefinitionMember member) {
-		JavaClass cls = member.innerDefinition.getTag(JavaClass.class);
+		JavaClass cls = context.optJavaClass(member.innerDefinition);
+		if (cls == null)
+			return null;
+		
 		JavaDefinitionVisitor visitor = new JavaDefinitionVisitor(
-				indent,
+				indent, 
 				compiler,
+				module,
 				cls,
 				file,
 				output,

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

 import org.openzen.zenscript.compiler.CompilationUnit;
 import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.compiler.ZenCodeCompiler;
+import org.openzen.zenscript.javashared.JavaBaseCompiler;
 import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionVisitor;
 import org.openzen.zenscript.javashared.JavaClass;
 
  *
  * @author Hoofdgebruiker
  */
-public class JavaSourceCompiler implements ZenCodeCompiler {
+public class JavaSourceCompiler extends JavaBaseCompiler implements ZenCodeCompiler {
 	public final JavaSourceFormattingSettings settings;
 	public final JavaSourceSyntheticHelperGenerator helperGenerator;
 	
 		this.directory = directory;
 	}
 	
+	@Override
+	public void addModule(SemanticModule module) {
+		context.addModule(module.module);
+	}
+	
 	@Override
 	public void addDefinition(HighLevelDefinition definition, SemanticModule module) {
 		String filename = getFilename(definition);
-		JavaPrepareDefinitionVisitor prepare = new JavaPrepareDefinitionVisitor(filename, null);
+		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, definition.pkg));
+			sourceFiles.put(file, sourceFile = new JavaSourceFile(this, file, cls, module.module, definition.pkg));
 		
 		sourceFile.add(definition, module);
 	}

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

 import org.openzen.zenscript.formattershared.StatementFormattingTarget;
 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.JavaField;
 import org.openzen.zenscript.javashared.JavaNativeTranslator;
 import org.openzen.zenscript.javashared.JavaMethod;
 	
 	public final JavaSourceStatementScope scope;
 	public final StatementFormattingTarget target;
+	private final JavaContext context;
 	
 	public JavaSourceExpressionFormatter(StatementFormattingTarget target, JavaSourceStatementScope scope) {
 		this.target = target;
 		this.scope = scope;
+		context = scope.context;
 	}
 
 	@Override
 		if (expression.member.getBuiltin() != null) {
 			return visitBuiltinCall(expression, expression.member.getBuiltin());
 		} else {
-			JavaMethod method = expression.member.getTag(JavaMethod.class);
-			if (method == null)
-				throw new IllegalStateException("No source method tag for " + expression.member.getCanonicalName() + "!");
-			
+			JavaMethod method = context.getJavaMethod(expression.member);
 			if (method.kind == JavaMethod.Kind.COMPILED) {
 				return (ExpressionString) method.translation.translate(expression, this);
 			} else {
 		if (expression.member.getBuiltin() != null)
 			return visitBuiltinCallStatic(expression, expression.member.getBuiltin());
 		
-		JavaMethod method = expression.member.getTag(JavaMethod.class);
+		JavaMethod method = context.getJavaMethod(expression.member);
 		if (method == null)
 			throw new IllegalStateException("No source method tag for " + expression.member.getCanonicalName() + "!");
 		
 			}
 		}
 		
-		JavaMethod method = expression.member.getTag(JavaMethod.class);
+		JavaMethod method = context.getJavaMethod(expression.member);
 		if (method == null)
 			throw new RuntimeException(expression.position + ": No tag for caster");
 		
 			return visitBuiltinConstant(expression, expression.constant.member.builtin);
 		
 		return new ExpressionString(
-				scope.type(expression.constant.member.definition.getTag(JavaClass.class)) + "." + expression.constant.member.name, 
+				scope.type(expression.constant.member.definition) + "." + expression.constant.member.name, 
 				JavaOperator.MEMBER);
 	}
 
 
 	@Override
 	public ExpressionString visitGetStaticField(GetStaticFieldExpression expression) {
-		JavaField field = expression.field.getTag(JavaField.class);
+		JavaField field = context.getJavaField(expression.field);
 		if (field == null)
 			throw new RuntimeException(expression.position + ": Missing field tag");
 		
 			return visitBuiltinGetter(expression, expression.getter.member.builtin);
 		
 		ExpressionString target = expression.target.accept(this);
-		if (expression.getter.member.hasTag(JavaField.class)) {
-			JavaField field = expression.getter.member.getTag(JavaField.class);
+		if (context.hasJavaField(expression.getter)) {
+			JavaField field = context.getJavaField(expression.getter);
 			if (target.value.equals("this") && !scope.hasLocalVariable(field.name))
 				return new ExpressionString(field.name, JavaOperator.PRIMARY);
 			
 			return target.unaryPostfix(JavaOperator.MEMBER, "." + field.name);
 		}
 		
-		JavaMethod method = expression.getter.getTag(JavaMethod.class);
+		JavaMethod method = context.getJavaMethod(expression.getter);
 		StringBuilder result = new StringBuilder();
 		if (!target.value.equals("this") || scope.hasLocalVariable(method.name)) {
 			result.append(target.value);
 			}
 		}
 		
-		JavaMethod method = expression.constructor.getTag(JavaMethod.class);
+		JavaMethod method = context.getJavaMethod(expression.constructor);
 		switch (method.kind) {
 			case EXPANSION: {
 				StringBuilder output = new StringBuilder();
 
 	@Override
 	public ExpressionString visitSetStaticField(SetStaticFieldExpression expression) {
-		JavaField field = expression.field.getTag(JavaField.class);
+		JavaField field = context.getJavaField(expression.field);
 		if (field == null)
 			throw new RuntimeException(expression.position + ": Missing field tag");
 		
 	}
 	
 	private String constructThisName(DefinitionTypeID type) {
-		JavaClass cls = type.definition.getTag(JavaClass.class);
+		JavaClass cls = context.getJavaClass(type.definition);
 		return cls.getClassName();
 	}
 
 	
 	@Override
 	public ExpressionString visitVariantValue(VariantValueExpression expression) {
-		JavaVariantOption option = expression.option.getTag(JavaVariantOption.class);
+		JavaVariantOption option = context.getJavaVariantOption(expression.option);
 		
 		StringBuilder result = new StringBuilder();
 		result.append("new ").append(scope.type(option.variantOptionClass));

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

+
 /*
  * To change this license header, choose License Headers in Project Properties.
  * To change this template file, choose Tools | Templates
 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;
 import org.openzen.zenscript.compiler.SemanticModule;
 	private final JavaClass cls;
 	private final StringBuilder contents = new StringBuilder();
 	private final ZSPackage pkg;
+	private final Module 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, ZSPackage pkg) {
+	public JavaSourceFile(JavaSourceCompiler compiler, File file, JavaClass cls, Module module, ZSPackage pkg) {
 		this.compiler = compiler;
 		this.pkg = pkg;
 		this.cls = cls;
+		this.module = module;
 		this.file = file;
 		
-		importer = new JavaSourceImporter(cls);
+		importer = new JavaSourceImporter(compiler.context, cls);
 	}
 	
 	public String getName() {
 	}
 	
 	public void prepare(JavaContext context) {
-		JavaPrepareDefinitionMemberVisitor visitor = new JavaPrepareDefinitionMemberVisitor(context);
+		JavaPrepareDefinitionMemberVisitor visitor = new JavaPrepareDefinitionMemberVisitor(context, context.getJavaModule(module));
 		
 		if (mainDefinition != null)
 			mainDefinition.accept(visitor);
 			expansion.accept(visitor);
 	}
 	
+	private boolean isEmpty(HighLevelDefinition definition) {
+		JavaClass cls = compiler.context.getJavaClass(definition);
+		if (!cls.empty)
+			return false;
+		
+		if (cls.isInterface() && definition.getTag(NativeTag.class) == null)
+			return false;
+		
+		return true;
+	}
+	
 	public void write() {
 		System.out.println("Calling write on " + file.getName());
 		
-		if (mainDefinition == null || mainDefinition.getTag(JavaClass.class).empty) {
+		if (mainDefinition == null || isEmpty(mainDefinition)) {
 			if (expansions.isEmpty())
 				return;
 			
 		JavaDefinitionVisitor visitor = new JavaDefinitionVisitor(
 				"",
 				compiler,
+				compiler.context.getJavaModule(module),
 				cls,
 				this,
 				contents,

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

 import java.util.Set;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaContext;
 
 /**
  *
 	private final JavaClass cls;
 	private final Map<String, JavaClass> imports = new HashMap<>();
 	private final Set<JavaClass> usedImports = new HashSet<>();
+	private final JavaContext context;
 	
-	public JavaSourceImporter(JavaClass cls) {
+	public JavaSourceImporter(JavaContext context, JavaClass cls) {
 		this.cls = cls;
+		this.context = context;
 	}
 	
 	public String importType(HighLevelDefinition definition) {
-		JavaClass cls = definition.getTag(JavaClass.class);
-		if (cls == null)
-			throw new IllegalStateException("Missing source class tag on " + definition.name);
-		
-		return importType(cls);
+		return importType(context.getJavaClass(definition));
 	}
 	
 	public String importType(JavaClass cls) {

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

 			
 			DefinitionTypeID variantType = statement.value.type.asDefinition();
 			HighLevelDefinition variant = variantType.definition;
-			String variantTypeName = scope.type(variant.getTag(JavaClass.class));
+			String variantTypeName = scope.type(variant);
 			for (SwitchCase switchCase : statement.cases) {
 				VariantOptionSwitchValue switchValue = (VariantOptionSwitchValue)switchCase.value;
 				String header = switchValue == null ? "default:" : "case " + switchValue.option.getName() + ":";

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

 	
 	@Override
 	public void synthesizeFunction(JavaSynthesizedFunction function) {
-		JavaSourceImporter importer = new JavaSourceImporter(function.cls);
+		JavaSourceImporter importer = new JavaSourceImporter(context, function.cls);
 		JavaSourceTypeVisitor typeVisitor = new JavaSourceTypeVisitor(importer, context);
 		
 		StringBuilder contents = new StringBuilder();
 	
 	@Override
 	public void synthesizeRange(JavaSynthesizedRange range) {
-		JavaSourceImporter importer = new JavaSourceImporter(range.cls);
+		JavaSourceImporter importer = new JavaSourceImporter(context, range.cls);
 		JavaSourceTypeVisitor typeVisitor = new JavaSourceTypeVisitor(importer, context);
 		
 		StringBuilder contents = new StringBuilder();
 	
 	@Override
 	public void synthesizeShared() {
-		JavaSourceImporter importer = new JavaSourceImporter(JavaClass.SHARED);
+		JavaSourceImporter importer = new JavaSourceImporter(context, JavaClass.SHARED);
 		
 		StringBuilder contents = new StringBuilder();
 		contents.append("public final class Shared<T extends AutoCloseable> {\n");

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

 import java.util.Set;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 		return fileScope.importer.importType(cls);
 	}
 	
+	public String type(HighLevelDefinition definition) {
+		return type(context.getJavaClass(definition));
+	}
+	
 	public void addLocalVariable(String localVariable) {
 		localVariables.add(localVariable);
 	}

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

 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;
 
 /**
  *
 	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,
 			"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");
-		PRINTSTREAM_PRINTLN.setTag(JavaMethod.class, printstreamPrintln);
-		
-		JavaClass jSystem = new JavaClass("java.lang", "System", JavaClass.Kind.CLASS);
-		SYSTEM_OUT.setTag(JavaField.class, new JavaField(jSystem, "out", "Ljava/io/PrintStream;"));
+		javaModule.setMethodInfo(PRINTSTREAM_PRINTLN, printstreamPrintln);
 	}
 	
 	public ZSPackage collectPackages() {
 		// register packages here
 		
-		{
-			// eg. package my.package with a class MyClass with a single native method test() returning a string
-			// the visitors can then during compilation check if a method is an instance of NativeMethodMember and treat it accordingly
-			ZSPackage packageMyPackage = rootPackage.getOrCreatePackage("my").getOrCreatePackage("test");
-			ClassDefinition myClassDefinition = new ClassDefinition(CodePosition.NATIVE, MODULE, packageMyPackage, "MyClass", Modifiers.PUBLIC, null);
-			JavaClass myClassInfo = new JavaClass("my.test", "MyClass", JavaClass.Kind.CLASS);
-			
-			MethodMember member = new MethodMember(CodePosition.NATIVE, myClassDefinition, Modifiers.PUBLIC, "test", new FunctionHeader(StringTypeID.UNIQUE), null);
-			member.setTag(JavaMethod.class, JavaMethod.getNativeVirtual(myClassInfo, "test", "()Ljava/lang/String;"));
-			myClassDefinition.addMember(member);
-			
-			packageMyPackage.register(myClassDefinition);
-		}
-		
 		return rootPackage;
 	}
 	
 		return globals;
 	}
 	
-	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;
-	
 	private class PrintlnSymbol implements ISymbol {
 
 		@Override

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

 		//formatFiles(pkg, module);
 		
 		if (semantic.isValid()) {
-			JavaModule javaModule = compileSemanticToJava(semantic);
+			JavaModule javaModule = compileSemanticToJava(registry, semantic);
 			javaModule.execute();
 		} else {
 			System.out.println("There were compilation errors");
 		return result;
 	}
 	
-	private static JavaModule compileSemanticToJava(SemanticModule module) {
+	private static JavaModule compileSemanticToJava(GlobalRegistry registry, SemanticModule module) {
 		JavaCompiler compiler = new JavaCompiler(module.compilationUnit.globalTypeRegistry, false, null);
+		registry.register(compiler.getContext());
+		
+		compiler.getContext().addModule(module.module);
+		
 		for (HighLevelDefinition definition : module.definitions.getAll()) {
 			compiler.addDefinition(definition, module);
 		}

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

 import java.io.IOException;
 import java.io.Reader;
 
-public interface SourceFile {
+public interface SourceFile extends Tag {
     String getFilename();
     
     Reader open() throws IOException;

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

+package org.openzen.zencode.shared;
+
+public interface Tag {
+}

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

 public class Taggable {
     private final Map<Class<?>, Object> tags = new HashMap<Class<?>, Object>();
     
-    public <T> void setTag(Class<T> typeOfT, T tag) {
+    public <T extends Tag> void setTag(Class<T> typeOfT, T tag) {
         tags.put(typeOfT, tag);
     }
     
-    public <T> T getTag(Class<T> typeOfT) {
+    public <T extends Tag> T getTag(Class<T> typeOfT) {
         return (T)(tags.get(typeOfT));
     }
     
-    public <T> boolean hasTag(Class<T> typeOfT) {
+    public <T extends Tag> boolean hasTag(Class<T> typeOfT) {
         return tags.containsKey(typeOfT);
     }