WIP on refactoring code to reuse code between JavaBytecode and JavaSource

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

 
 import java.util.List;
 import org.openzen.zencode.shared.Taggable;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.statement.Statement;
 
 /**
  * @author Hoofdgebruiker
  */
 public class ScriptBlock extends Taggable {
+	public final ZSPackage pkg;
 	public final List<Statement> statements;
 	
-	public ScriptBlock(List<Statement> statements) {
+	public ScriptBlock(ZSPackage pkg, List<Statement> statements) {
+		this.pkg = pkg;
 		this.statements = statements;
 	}
 	
 	public ScriptBlock withStatements(List<Statement> newStatements) {
-		ScriptBlock result = new ScriptBlock(newStatements);
+		ScriptBlock result = new ScriptBlock(pkg, newStatements);
 		result.addAllTagsFrom(this);
 		return result;
 	}

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

 	public FunctionScope(BaseScope outer, FunctionHeader header) {
 		this.outer = outer;
 		this.header = header;
+		
+		if (outer.getLocalTypeParameters() == null)
+			throw new NullPointerException();
+		if (header == null)
+			throw new NullPointerException();
+		
 		typeParameterMap = outer.getLocalTypeParameters().getInner(outer.getTypeRegistry(), header.typeParameters);
 	}
 	

JavaBytecodeCompiler/build.gradle

 	compile 'org.ow2.asm:asm-debug-all:6.0_BETA'
 	compile project(':CodeModel')
 	compile project(':CompilerShared')
+	compile project(':JavaShared')
 }

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

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.javabytecode;
-
-import org.objectweb.asm.Type;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class JavaClassInfo {
-	public static JavaClassInfo get(Class<?> cls) {
-		return new JavaClassInfo(Type.getInternalName(cls), cls.isEnum());
-	}
-	
-	public final String internalClassName;
-	public final boolean isEnum;
-	
-	public JavaClassInfo(String internalClassName) {
-		this(internalClassName, false);
-	}
-	
-	public JavaClassInfo(String internalClassName, boolean isEnum) {
-		this.internalClassName = internalClassName;
-		this.isEnum = isEnum;
-	}
-}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javabytecode;
+
+import org.objectweb.asm.Type;
+import org.openzen.zenscript.javashared.JavaClass;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaCompileUtils {
+	private JavaCompileUtils() {}
+	
+	public static JavaClass get(Class<?> cls) {
+		return JavaClass.fromInternalName(
+				Type.getInternalName(cls),
+				cls.isInterface() ? JavaClass.Kind.INTERFACE : (cls.isEnum() ? JavaClass.Kind.ENUM : JavaClass.Kind.CLASS));
+	}
+}

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

 import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
 import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
 import org.openzen.zenscript.compiler.ZenCodeCompiler;
+import org.openzen.zenscript.javashared.JavaClass;
 
 /**
  *
 		// convert scripts into methods (add them to a Scripts class?)
 		// (TODO: can we break very long scripts into smaller methods? for the extreme scripts)
 		final JavaClassWriter visitor = scriptFile.classWriter;
-		JavaMethodInfo method = new JavaMethodInfo(new JavaClassInfo(className), methodName, "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+		JavaMethodInfo method = new JavaMethodInfo(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(new JavaWriter(visitor, method, null, null, null));
 			throw new IllegalStateException("Already finished!");
 		finished = true;
 		
-		JavaMethodInfo runMethod = new JavaMethodInfo(new JavaClassInfo("Scripts"), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+		JavaMethodInfo runMethod = new JavaMethodInfo(new JavaClass("script", "Scripts", JavaClass.Kind.CLASS), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 		final JavaWriter runWriter = new JavaWriter(scriptsClassWriter, runMethod, null, null, null);
 		runWriter.start();
 		for (Map.Entry<String, JavaScriptFile> entry : scriptBlocks.entrySet()) {

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

  */
 package org.openzen.zenscript.javabytecode;
 
+import org.openzen.zenscript.javashared.JavaClass;
+
 /**
  *
  * @author Hoofdgebruiker
  */
 public class JavaFieldInfo {
-	public final JavaClassInfo javaClass;
+	public final JavaClass javaClass;
 	public final String name;
 	public final String signature;
 	
-	public JavaFieldInfo(JavaClassInfo javaClass, String name, String signature) {
+	public JavaFieldInfo(JavaClass javaClass, String name, String signature) {
 		this.javaClass = javaClass;
 		this.name = name;
 		this.signature = signature;

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

 
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
+import org.openzen.zenscript.javashared.JavaClass;
 
 /**
  *
         }
         descriptor.append(')');
         descriptor.append(result == null ? 'V' : Type.getDescriptor(result));
-		return new JavaMethodInfo(new JavaClassInfo(Type.getInternalName(owner)), name, descriptor.toString(), modifiers);
+		return new JavaMethodInfo(JavaCompileUtils.get(owner), name, descriptor.toString(), modifiers);
     }
 	
-	public final JavaClassInfo javaClass;
+	public final JavaClass javaClass;
 	public final String name;
 	public final String descriptor;
 	public final int modifiers;
 	
-	public JavaMethodInfo(JavaClassInfo javaClass, String name, String signature, int modifiers) {
+	public JavaMethodInfo(JavaClass javaClass, String name, String signature, int modifiers) {
 		this.javaClass = javaClass;
 		this.name = name;
 		this.descriptor = signature;

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

 
 import java.io.FileOutputStream;
 import java.io.IOException;
+import org.openzen.zenscript.javashared.JavaClass;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 	private static final int PUBLIC = Opcodes.ACC_PUBLIC;
 	private static final int STATIC = Opcodes.ACC_STATIC;
 	private static final int PUBLIC_STATIC = PUBLIC | STATIC;
 
-	private static final JavaClassInfo BOOLEAN = JavaClassInfo.get(Boolean.class);
+	private static final JavaClass BOOLEAN = JavaCompileUtils.get(Boolean.class);
 	private static final JavaMethodInfo BOOLEAN_PARSE = new JavaMethodInfo(BOOLEAN, "parseBoolean", "(Ljava/lang/String;)Z", PUBLIC_STATIC);
 	private static final JavaMethodInfo BOOLEAN_TO_STRING = new JavaMethodInfo(BOOLEAN, "toString", "(Z)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaClassInfo BYTE = JavaClassInfo.get(Byte.class);
+	private static final JavaClass BYTE = JavaCompileUtils.get(Byte.class);
 	private static final JavaMethodInfo BYTE_PARSE = new JavaMethodInfo(BYTE, "parseByte", "(Ljava/lang/String;)B", PUBLIC_STATIC);
 	private static final JavaMethodInfo BYTE_PARSE_WITH_BASE = new JavaMethodInfo(BYTE, "parseByte", "(Ljava/lang/String;I)B", PUBLIC_STATIC);
 	private static final JavaFieldInfo BYTE_MIN_VALUE = new JavaFieldInfo(BYTE, "MIN_VALUE", "B");
 	private static final JavaFieldInfo BYTE_MAX_VALUE = new JavaFieldInfo(BYTE, "MAX_VALUE", "B");
 	private static final JavaMethodInfo BYTE_TO_STRING = new JavaMethodInfo(BYTE, "toString", "(B)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaClassInfo SHORT = JavaClassInfo.get(Short.class);
+	private static final JavaClass SHORT = JavaCompileUtils.get(Short.class);
 	private static final JavaMethodInfo SHORT_PARSE = new JavaMethodInfo(SHORT, "parseShort", "(Ljava/lang/String;)S", PUBLIC_STATIC);
 	private static final JavaMethodInfo SHORT_PARSE_WITH_BASE = new JavaMethodInfo(SHORT, "parseShort", "(Ljava/lang/String;I)S", PUBLIC_STATIC);
 	private static final JavaFieldInfo SHORT_MIN_VALUE = new JavaFieldInfo(SHORT, "MIN_VALUE", "S");
 	private static final JavaFieldInfo SHORT_MAX_VALUE = new JavaFieldInfo(SHORT, "MAX_VALUE", "S");
 	private static final JavaMethodInfo SHORT_TO_STRING = new JavaMethodInfo(SHORT, "toString", "(S)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaClassInfo INTEGER = JavaClassInfo.get(Integer.class);
+	private static final JavaClass INTEGER = JavaCompileUtils.get(Integer.class);
 	private static final JavaMethodInfo INTEGER_COMPARE_UNSIGNED = new JavaMethodInfo(INTEGER, "compareUnsigned", "(II)I", PUBLIC_STATIC);
 	private static final JavaMethodInfo INTEGER_DIVIDE_UNSIGNED = new JavaMethodInfo(INTEGER, "divideUnsigned", "(II)I", PUBLIC_STATIC);
 	private static final JavaMethodInfo INTEGER_REMAINDER_UNSIGNED = new JavaMethodInfo(INTEGER, "remainderUnsigned", "(II)I", PUBLIC_STATIC);
 	private static final JavaFieldInfo INTEGER_MAX_VALUE = new JavaFieldInfo(INTEGER, "MAX_VALUE", "I");
 	private static final JavaMethodInfo INTEGER_TO_STRING = new JavaMethodInfo(INTEGER, "toString", "(I)Ljava/lang/String;", PUBLIC_STATIC);
 	private static final JavaMethodInfo INTEGER_TO_UNSIGNED_STRING = new JavaMethodInfo(INTEGER, "toUnsignedString", "(I)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaClassInfo LONG = new JavaClassInfo(Type.getInternalName(Long.class));
+	private static final JavaClass LONG = JavaCompileUtils.get(Long.class);
 	private static final JavaMethodInfo LONG_COMPARE = new JavaMethodInfo(LONG, "compare", "(JJ)I", PUBLIC_STATIC);
 	private static final JavaMethodInfo LONG_COMPARE_UNSIGNED = new JavaMethodInfo(LONG, "compareUnsigned", "(JJ)I", PUBLIC_STATIC);
 	private static final JavaMethodInfo LONG_DIVIDE_UNSIGNED = new JavaMethodInfo(LONG, "divideUnsigned", "(JJ)J", PUBLIC_STATIC);
 	private static final JavaFieldInfo LONG_MAX_VALUE = new JavaFieldInfo(LONG, "MAX_VALUE", "J");
 	private static final JavaMethodInfo LONG_TO_STRING = new JavaMethodInfo(LONG, "toString", "(J)Ljava/lang/String;", PUBLIC_STATIC);
 	private static final JavaMethodInfo LONG_TO_UNSIGNED_STRING = new JavaMethodInfo(LONG, "toUnsignedString", "(J)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaClassInfo FLOAT = new JavaClassInfo(Type.getInternalName(Float.class));
+	private static final JavaClass FLOAT = JavaCompileUtils.get(Float.class);
 	private static final JavaMethodInfo FLOAT_COMPARE = new JavaMethodInfo(FLOAT, "compare", "(FF)I", PUBLIC_STATIC);
 	private static final JavaMethodInfo FLOAT_PARSE = new JavaMethodInfo(FLOAT, "parseFloat", "(Ljava/lang/String;)F", PUBLIC_STATIC);
 	private static final JavaMethodInfo FLOAT_FROM_BITS = new JavaMethodInfo(FLOAT, "intBitsToFloat", "(I)F", PUBLIC_STATIC);
 	private static final JavaFieldInfo FLOAT_MIN_VALUE = new JavaFieldInfo(FLOAT, "MIN_VALUE", "F");
 	private static final JavaFieldInfo FLOAT_MAX_VALUE = new JavaFieldInfo(FLOAT, "MAX_VALUE", "F");
 	private static final JavaMethodInfo FLOAT_TO_STRING = new JavaMethodInfo(FLOAT, "toString", "(F)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaClassInfo DOUBLE = new JavaClassInfo(Type.getInternalName(Double.class));
+	private static final JavaClass DOUBLE = JavaCompileUtils.get(Double.class);
 	private static final JavaMethodInfo DOUBLE_COMPARE = new JavaMethodInfo(DOUBLE, "compare", "(DD)I", PUBLIC_STATIC);
 	private static final JavaMethodInfo DOUBLE_PARSE = new JavaMethodInfo(DOUBLE, "parseDouble", "(Ljava/lang/String;)D", PUBLIC_STATIC);
 	private static final JavaMethodInfo DOUBLE_FROM_BITS = new JavaMethodInfo(DOUBLE, "longBitsToDouble", "(J)D", PUBLIC_STATIC);
 	private static final JavaFieldInfo DOUBLE_MIN_VALUE = new JavaFieldInfo(DOUBLE, "MIN_VALUE", "D");
 	private static final JavaFieldInfo DOUBLE_MAX_VALUE = new JavaFieldInfo(DOUBLE, "MAX_VALUE", "D");
 	private static final JavaMethodInfo DOUBLE_TO_STRING = new JavaMethodInfo(DOUBLE, "toString", "(D)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaClassInfo CHARACTER = new JavaClassInfo(Type.getInternalName(Character.class));
+	private static final JavaClass CHARACTER = JavaCompileUtils.get(Character.class);
 	private static final JavaMethodInfo CHARACTER_TO_LOWER_CASE = new JavaMethodInfo(CHARACTER, "toLowerCase", "()C", PUBLIC);
 	private static final JavaMethodInfo CHARACTER_TO_UPPER_CASE = new JavaMethodInfo(CHARACTER, "toUpperCase", "()C", PUBLIC);
 	private static final JavaFieldInfo CHARACTER_MIN_VALUE = new JavaFieldInfo(CHARACTER, "MIN_VALUE", "C");
 	private static final JavaFieldInfo CHARACTER_MAX_VALUE = new JavaFieldInfo(CHARACTER, "MAX_VALUE", "C");
 	private static final JavaMethodInfo CHARACTER_TO_STRING = new JavaMethodInfo(CHARACTER, "toString", "(C)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaClassInfo STRING = new JavaClassInfo(Type.getInternalName(String.class));
+	private static final JavaClass STRING = JavaCompileUtils.get(String.class);
 	private static final JavaMethodInfo STRING_COMPARETO = new JavaMethodInfo(STRING, "compareTo", "(Ljava/lang/String;)I", PUBLIC);
 	private static final JavaMethodInfo STRING_CONCAT = new JavaMethodInfo(STRING, "concat", "(Ljava/lang/String;)Ljava/lang/String;", PUBLIC);
 	private static final JavaMethodInfo STRING_CHAR_AT = new JavaMethodInfo(STRING, "charAt", "(I)C", PUBLIC);
 	private static final JavaMethodInfo STRING_LENGTH = new JavaMethodInfo(STRING, "length", "()I", PUBLIC);
 	private static final JavaMethodInfo STRING_CHARACTERS = new JavaMethodInfo(STRING, "toCharArray", "()[C", PUBLIC);
 	private static final JavaMethodInfo STRING_ISEMPTY = new JavaMethodInfo(STRING, "isEmpty", "()Z", PUBLIC);
-	private static final JavaClassInfo ENUM = new JavaClassInfo(Type.getInternalName(Enum.class));
+	private static final JavaClass ENUM = JavaCompileUtils.get(Enum.class);
 	private static final JavaMethodInfo ENUM_COMPARETO = new JavaMethodInfo(STRING, "compareTo", "(Ljava/lang/Enum;)I", PUBLIC);
 	private static final JavaMethodInfo ENUM_NAME = new JavaMethodInfo(STRING, "name", "()Ljava/lang/String;", PUBLIC);
 	private static final JavaMethodInfo ENUM_ORDINAL = new JavaMethodInfo(STRING, "ordinal", "()I", PUBLIC);
-	private static final JavaClassInfo MAP = new JavaClassInfo(Type.getInternalName(Map.class));
+	private static final JavaClass MAP = JavaCompileUtils.get(Map.class);
 	private static final JavaMethodInfo MAP_GET = new JavaMethodInfo(MAP, "get", "(Ljava/lang/Object;)Ljava/lang/Object;", PUBLIC);
 	private static final JavaMethodInfo MAP_PUT = new JavaMethodInfo(MAP, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", PUBLIC);
 	private static final JavaMethodInfo MAP_CONTAINS_KEY = new JavaMethodInfo(MAP, "containsKey", "(Ljava/lang/Object;)Z", PUBLIC);
 	private static final JavaMethodInfo MAP_ISEMPTY = new JavaMethodInfo(MAP, "isEmpty", "()Z", PUBLIC);
 	private static final JavaMethodInfo MAP_KEYS = new JavaMethodInfo(MAP, "keys", "()Ljava/lang/Object;", PUBLIC);
 	private static final JavaMethodInfo MAP_VALUES = new JavaMethodInfo(MAP, "values", "()Ljava/lang/Object;", PUBLIC);
-	private static final JavaClassInfo ARRAYS = new JavaClassInfo(Type.getInternalName(Arrays.class));
+	private static final JavaClass ARRAYS = JavaCompileUtils.get(Arrays.class);
 	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_OBJECTS = new JavaMethodInfo(ARRAYS, "copyOfRange", "([Ljava/lang/Object;II)[Ljava/lang/Object;", PUBLIC_STATIC);
 	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_BOOLS = new JavaMethodInfo(ARRAYS, "copyOfRange", "([ZII)[Z", PUBLIC_STATIC);
 	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_BYTES = new JavaMethodInfo(ARRAYS, "copyOfRange", "([BII)[B", PUBLIC_STATIC);
 	private static final JavaMethodInfo ARRAYS_HASHCODE_FLOATS = new JavaMethodInfo(ARRAYS, "hashCode", "([F)I", PUBLIC_STATIC);
 	private static final JavaMethodInfo ARRAYS_HASHCODE_DOUBLES = new JavaMethodInfo(ARRAYS, "hashCode", "([D)I", PUBLIC_STATIC);
 	private static final JavaMethodInfo ARRAYS_HASHCODE_CHARS = new JavaMethodInfo(ARRAYS, "hashCode", "([C)I", PUBLIC_STATIC);
-	private static final JavaClassInfo OBJECT = JavaClassInfo.get(Object.class);
+	private static final JavaClass OBJECT = JavaCompileUtils.get(Object.class);
 	private static final JavaMethodInfo OBJECT_HASHCODE = new JavaMethodInfo(OBJECT, "hashCode", "()I", PUBLIC);
-	private static final JavaClassInfo COLLECTION = JavaClassInfo.get(Collection.class);
+	private static final JavaClass COLLECTION = JavaCompileUtils.get(Collection.class);
 	private static final JavaMethodInfo COLLECTION_SIZE = new JavaMethodInfo(COLLECTION, "size", "()I", PUBLIC);
 	private static final JavaMethodInfo COLLECTION_TOARRAY = new JavaMethodInfo(COLLECTION, "toArray", "([Ljava/lang/Object;)[Ljava/lang/Object;", PUBLIC);
 
 				break;
 			}
 			case FUNCTION_CALL:
-				//expression.target.accept(this);
-				//for (Expression argument : expression.arguments.arguments) {
-				//	argument.accept(this);
-				//}
-				javaWriter.invokeInterface(new JavaMethodInfo(new JavaClassInfo(expression.target.type.accept(JavaTypeVisitor.INSTANCE).getInternalName()), "accept", CompilerUtils.calcSign(expression.instancedHeader, false), Opcodes.ACC_PUBLIC));
+				javaWriter.invokeInterface(
+						new JavaMethodInfo(
+								JavaClass.fromInternalName(expression.target.type.accept(JavaTypeVisitor.INSTANCE).getInternalName(), JavaClass.Kind.INTERFACE),
+								"accept",
+								CompilerUtils.calcSign(expression.instancedHeader, false),
+								Opcodes.ACC_PUBLIC));
 				break;
-				//throw new UnsupportedOperationException("Not yet supported!");
 			case AUTOOP_NOTEQUALS:
 				throw new UnsupportedOperationException("Not yet supported!");
 			default:
 				break;
 			case ENUM_VALUES: {
 				DefinitionTypeID type = (DefinitionTypeID) expression.type;
-				JavaClassInfo cls = type.definition.getTag(JavaClassInfo.class);
-				javaWriter.invokeStatic(new JavaMethodInfo(cls, "values", "()[L" + cls.internalClassName + ";", PUBLIC_STATIC));
+				JavaClass cls = type.definition.getTag(JavaClass.class);
+				javaWriter.invokeStatic(new JavaMethodInfo(cls, "values", "()[L" + cls.internalName + ";", PUBLIC_STATIC));
 				break;
 			}
 			default:
 		}
 
         javaWriter.loadObject(0);
-        if (javaWriter.method.javaClass.isEnum) {
+        if (javaWriter.method.javaClass.isEnum()) {
             javaWriter.loadObject(1);
             javaWriter.loadInt(2);
         }
             argument.accept(this);
         }
 		String internalName = type.getInternalName();
-        javaWriter.invokeSpecial(internalName, "<init>", CompilerUtils.calcDesc(expression.constructor.getHeader(), javaWriter.method.javaClass.isEnum));
+        javaWriter.invokeSpecial(internalName, "<init>", CompilerUtils.calcDesc(expression.constructor.getHeader(), javaWriter.method.javaClass.isEnum()));
         return null;
     }
 
         javaWriter.label(start);
         expression.value.accept(this);
         if (expression.value.type == BasicTypeID.STRING)
-            javaWriter.invokeVirtual(new JavaMethodInfo(new JavaClassInfo("java/lang/Object"), "hashCode", "()I", 0));
+            javaWriter.invokeVirtual(new JavaMethodInfo(OBJECT, "hashCode", "()I", 0));
 
         final boolean hasNoDefault = hasNoDefault(expression);
 
 				break;
 			case ENUM_VALUES: {
 				DefinitionTypeID type = (DefinitionTypeID) expression.type;
-				JavaClassInfo cls = type.definition.getTag(JavaClassInfo.class);
-				javaWriter.invokeStatic(new JavaMethodInfo(cls, "values", "()[L" + cls.internalClassName + ";", PUBLIC_STATIC));
+				JavaClass cls = type.definition.getTag(JavaClass.class);
+				javaWriter.invokeStatic(new JavaMethodInfo(cls, "values", "()[L" + cls.internalName + ";", PUBLIC_STATIC));
 				break;
 			}
 			default:

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

 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.statement.*;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 
 import java.util.Arrays;
 import java.util.List;
+import org.openzen.zenscript.javashared.JavaClass;
 
 public class JavaStatementVisitor implements StatementVisitor<Boolean> {
     private final JavaWriter javaWriter;
         javaWriter.label(start);
         statement.value.accept(expressionVisitor);
         if (statement.value.type == BasicTypeID.STRING)
-            javaWriter.invokeVirtual(new JavaMethodInfo(new JavaClassInfo("java/lang/Object"), "hashCode", "()I", 0));
+            javaWriter.invokeVirtual(new JavaMethodInfo(JavaClass.OBJECT, "hashCode", "()I", 0));
         boolean out = false;
 
         final boolean hasNoDefault = hasNoDefault(statement);

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

 package org.openzen.zenscript.javabytecode.compiler;
 
 import org.objectweb.asm.*;
-import org.objectweb.asm.commons.LocalVariablesSorter;
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.javabytecode.*;
 
 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import org.objectweb.asm.*;
 import static org.objectweb.asm.Opcodes.*;
 import org.objectweb.asm.commons.LocalVariablesSorter;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaFieldInfo;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 import org.openzen.zenscript.javabytecode.JavaParameterInfo;
+import org.openzen.zenscript.javashared.JavaClass;
 
 public class JavaWriter {
-    private static final JavaClassInfo T_STRING = new JavaClassInfo("java/lang/String");
     private static final JavaMethodInfo STRING_CONCAT = new JavaMethodInfo(
-            T_STRING,
+            JavaClass.STRING,
             "concat",
             "(Ljava/lang/String;)Ljava/lang/String;",
             Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 	public void invokeStatic(JavaMethodInfo method) {
 		visitor.visitMethodInsn(
 				INVOKESTATIC,
-				method.javaClass.internalClassName,
+				method.javaClass.internalName,
 				method.name,
 				method.descriptor,
 				false);
 
     public void invokeVirtual(JavaMethodInfo method) {
         if (debug)
-            System.out.println("invokeVirtual " + method.javaClass.internalClassName + '.' + method.name + method.descriptor);
+            System.out.println("invokeVirtual " + method.javaClass.internalName + '.' + method.name + method.descriptor);
 
-        visitor.visitMethodInsn(INVOKEVIRTUAL, method.javaClass.internalClassName, method.name, method.descriptor, false);
+        visitor.visitMethodInsn(INVOKEVIRTUAL, method.javaClass.internalName, method.name, method.descriptor, false);
     }
 
     public void invokeInterface(JavaMethodInfo method) {
         if (debug)
-            System.out.println("invokeInterface " + method.javaClass.internalClassName + '.' + method.name + method.descriptor);
+            System.out.println("invokeInterface " + method.javaClass.internalName + '.' + method.name + method.descriptor);
 
-        visitor.visitMethodInsn(INVOKEINTERFACE, method.javaClass.internalClassName, method.name, method.descriptor, true);
+        visitor.visitMethodInsn(INVOKEINTERFACE, method.javaClass.internalName, method.name, method.descriptor, true);
     }
 
     public void newObject(Class type) {
 	
 	public void getField(JavaFieldInfo field) {
         if (debug)
-            System.out.println("getField " + field.javaClass.internalClassName + '.' + field.name + ":" + field.signature);
+            System.out.println("getField " + field.javaClass.internalName + '.' + field.name + ":" + field.signature);
 		
-		visitor.visitFieldInsn(GETFIELD, field.javaClass.internalClassName, field.name, field.signature);
+		visitor.visitFieldInsn(GETFIELD, field.javaClass.internalName, field.name, field.signature);
 	}
 
     public void putField(String owner, String name, String descriptor) {
 	
 	public void putField(JavaFieldInfo field) {
         if (debug)
-            System.out.println("putField " + field.javaClass.internalClassName + '.' + field.name + ":" + field.signature);
+            System.out.println("putField " + field.javaClass.internalName + '.' + field.name + ":" + field.signature);
 		
-		visitor.visitFieldInsn(PUTFIELD, field.javaClass.internalClassName, field.name, field.signature);
+		visitor.visitFieldInsn(PUTFIELD, field.javaClass.internalName, field.name, field.signature);
 	}
 
     public void getStaticField(String owner, String name, String descriptor) {
 	
 	public void getStaticField(JavaFieldInfo field) {
         if (debug)
-            System.out.println("getStaticField " + field.javaClass.internalClassName + '.' + field.name + ":" + field.signature);
+            System.out.println("getStaticField " + field.javaClass.internalName + '.' + field.name + ":" + field.signature);
 		
-		visitor.visitFieldInsn(GETSTATIC, field.javaClass.internalClassName, field.name, field.signature);
+		visitor.visitFieldInsn(GETSTATIC, field.javaClass.internalName, field.name, field.signature);
 	}
 
     public void putStaticField(String owner, String name, String descriptor) {
 	
 	public void putStaticField(JavaFieldInfo field) {
         if (debug)
-            System.out.println("putStaticField " + field.javaClass.internalClassName + '.' + field.name + ":" + field.signature);
+            System.out.println("putStaticField " + field.javaClass.internalName + '.' + field.name + ":" + field.signature);
 		
-		visitor.visitFieldInsn(PUTSTATIC, field.javaClass.internalClassName, field.name, field.signature);
+		visitor.visitFieldInsn(PUTSTATIC, field.javaClass.internalName, field.name, field.signature);
 	}
 
     public void aThrow() {

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

 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 import org.openzen.zenscript.javabytecode.JavaModule;
 import org.openzen.zenscript.javabytecode.compiler.*;
+import org.openzen.zenscript.javashared.JavaClass;
 
 
 public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
-	private static final JavaClassInfo T_CLASS = new JavaClassInfo("java/lang/Class");
 	private static final JavaMethodInfo CLASS_FORNAME = new JavaMethodInfo(
-			T_CLASS,
+			JavaClass.CLASS,
 			"forName",
 			"(Ljava/lang/String;)Ljava/lang/Class;",
 			Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
 	
-	private static final JavaClassInfo T_ENUM = new JavaClassInfo("java/lang/Enum");
 	private static final JavaMethodInfo ENUM_VALUEOF = new JavaMethodInfo(
-			T_ENUM,
+			JavaClass.ENUM,
 			"valueOf",
 			"(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;",
 			Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
         else
             superType = Type.getType(definition.getSuperType().accept(JavaTypeClassVisitor.INSTANCE));
 
-		JavaClassInfo toClass = new JavaClassInfo(definition.name);
+		JavaClass toClass = new JavaClass(definition.pkg.fullName, definition.name, JavaClass.Kind.CLASS);
         JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
         //TODO: Calculate signature from generic parameters
         //TODO: Interfaces?
         String signature = null;
-
-
+		
         writer.visit(Opcodes.V1_8, definition.modifiers, definition.name, signature, superType.getInternalName(), null);
 		JavaMemberVisitor memberVisitor = new JavaMemberVisitor(writer, toClass, definition); 
         for (IDefinitionMember member : definition.members) {
 
     @Override
     public byte[] visitInterface(InterfaceDefinition definition) {
-		JavaClassInfo toClass = new JavaClassInfo(definition.name);
+		JavaClass toClass = new JavaClass(definition.pkg.fullName, definition.name, JavaClass.Kind.INTERFACE);
         ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
 
         //TODO: Calculate signature from generic parameters
 
         writer.visit(Opcodes.V1_8, Opcodes.ACC_ENUM | Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER | Opcodes.ACC_FINAL, definition.name, "Ljava/lang/Enum<L" + definition.name + ";>;", superType.getInternalName(), null);
 
-		JavaClassInfo toClass = new JavaClassInfo(definition.name, true);
+		JavaClass toClass = new JavaClass(definition.pkg.fullName, definition.name, JavaClass.Kind.ENUM);
 
         //Enum Stuff(required!)
         writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC, "$VALUES", "[L" + definition.name + ";", null, null).visitEnd();
             member.accept(visitor);
         }
 		
-		JavaClassInfo arrayClass = new JavaClassInfo("[L" + definition.name + ";");
+		JavaClass arrayClass = JavaClass.fromInternalName("[L" + definition.name + ";", JavaClass.Kind.ARRAY);
 		JavaMethodInfo arrayClone = new JavaMethodInfo(arrayClass, "clone", "()Ljava/lang/Object;", Opcodes.ACC_PUBLIC);
 
 		JavaMethodInfo valuesMethodInfo = new JavaMethodInfo(toClass, "values", "()[L" + definition.name + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
 		
         final String signature = CompilerUtils.calcSign(definition.header, false);
 		
-		final JavaClassInfo toClass = new JavaClassInfo(CompilerUtils.calcClasName(definition.position));
+		final JavaClass toClass = new JavaClass(definition.pkg.fullName, CompilerUtils.calcClasName(definition.position), JavaClass.Kind.CLASS);
 		final JavaMethodInfo methodInfo = new JavaMethodInfo(toClass, definition.name, CompilerUtils.calcDesc(definition.header, false), CompilerUtils.calcAccess(definition.modifiers) | Opcodes.ACC_STATIC);
 
 		final JavaWriter writer = new JavaWriter(outerWriter, true, methodInfo, definition, signature, null);

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.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaFieldInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 import org.openzen.zenscript.javabytecode.JavaParameterInfo;
 import org.openzen.zenscript.javabytecode.compiler.*;
 
 import java.util.List;
+import org.openzen.zenscript.javashared.JavaClass;
 
 public class JavaMemberVisitor implements MemberVisitor<Void> {
     private final ClassWriter writer;
-    private final JavaClassInfo toClass;
+    private final JavaClass toClass;
     private final HighLevelDefinition definition;
     private final JavaStatementVisitor clinitStatementVisitor;
     private EnumDefinition enumDefinition = null;
 
-    public JavaMemberVisitor(ClassWriter writer, JavaClassInfo toClass, HighLevelDefinition definition) {
+    public JavaMemberVisitor(ClassWriter writer, JavaClass toClass, HighLevelDefinition definition) {
         this.writer = writer;
         this.toClass = toClass;
         this.definition = definition;

JavaShared/build.gradle

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

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaClass.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.Arrays;
+import stdlib.Strings;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaClass implements Comparable<JavaClass> {
+	public static final JavaClass CLASS = new JavaClass("java.lang", "Class", Kind.CLASS);
+	public static final JavaClass ENUM = new JavaClass("java.lang", "Enum", Kind.CLASS);
+	public static final JavaClass OBJECT = new JavaClass("java.lang", "Object", Kind.CLASS);
+	public static final JavaClass STRING = new JavaClass("java.lang", "String", Kind.CLASS);
+	public static final JavaClass CLOSEABLE = new JavaClass("java.lang", "AutoCloseable", Kind.INTERFACE);
+	public static final JavaClass MAP = new JavaClass("java.util", "Map", JavaClass.Kind.INTERFACE);
+	public static final JavaClass HASHMAP = new JavaClass("java.util", "HashMap", JavaClass.Kind.CLASS);
+	public static final JavaClass ITERATOR = new JavaClass("java.util", "Iterator", JavaClass.Kind.INTERFACE);
+	
+	public static JavaClass fromInternalName(String internalName, Kind kind) {
+		if (kind == Kind.ARRAY)
+			return new JavaClass("", internalName, kind, new String[0]);
+		
+		int lastSlash = internalName.lastIndexOf('/');
+		if (lastSlash < 0)
+			System.out.println(internalName);
+		
+		String pkg = lastSlash < 0 ? "" : internalName.substring(0, lastSlash);
+		String className = lastSlash < 0 ? internalName : internalName.substring(lastSlash + 1);
+		String[] nameParts = Strings.split(className, '$');
+		return new JavaClass(pkg, internalName, kind, nameParts);
+	}
+	
+	public final JavaClass outer;
+	
+	public final String pkg;
+	public final String fullName;
+	public final String internalName;
+	public final Kind kind;
+	
+	public boolean empty = false;
+	public boolean destructible = false;
+	
+	private final String[] classNameParts;
+	
+	private JavaClass(String pkg, String internalName, Kind kind, String[] classNameParts) {
+		if (classNameParts.length > 1) {
+			String[] outerParts = Arrays.copyOf(classNameParts, classNameParts.length - 1);
+			outer = new JavaClass(pkg, internalName.substring(0, internalName.lastIndexOf('$')), kind, outerParts);
+		} else {
+			outer = null;
+		}
+		
+		this.pkg = pkg;
+		this.fullName = String.join(".", classNameParts);
+		this.internalName = internalName;
+		this.kind = kind;
+		this.classNameParts = classNameParts;
+	}
+	
+	public JavaClass(String pkg, String name, Kind kind) {
+		this.pkg = pkg;
+		this.classNameParts = new String[] { name };
+		this.fullName = pkg + '.' + name;
+		this.internalName = pkg.isEmpty() ? name : pkg.replace('.', '/') + '/' + name;
+		this.kind = kind;
+		
+		outer = this;
+	}
+	
+	public JavaClass(JavaClass outer, String name, Kind kind) {
+		this.pkg = outer.pkg;
+		this.classNameParts = Arrays.copyOf(outer.classNameParts, outer.classNameParts.length + 1);
+		this.classNameParts[outer.classNameParts.length] = name;
+		this.fullName = outer.fullName + '.' + name;
+		this.internalName = outer.internalName + '$' + name;
+		this.kind = kind;
+		
+		this.outer = outer.outer;
+	}
+	
+	/**
+	 * Retrieves the name of the class itself, excluding outer class or package
+	 * name.
+	 * 
+	 * @return 
+	 */
+	public String getName() {
+		return classNameParts[classNameParts.length - 1];
+	}
+	
+	/**
+	 * Retrieves the full name of the class, including outer class but excluding 
+	 * package name.
+	 * 
+	 * @return 
+	 */
+	public String getClassName() {
+		return fullName.substring(pkg.length() + 1);
+	}
+	
+	@Override
+	public int compareTo(JavaClass o) {
+		return fullName.compareTo(o.fullName);
+	}
+
+	public boolean isEnum() {
+		return kind == Kind.ENUM;
+	}
+	
+	public enum Kind {
+		CLASS,
+		INTERFACE,
+		ENUM,
+		ARRAY
+	}
+}

JavaSourceCompiler/build.gradle

     compile project(':CodeModel')
 	compile project(':CompilerShared')
 	compile project(':CodeFormatterShared')
+	compile project(':JavaShared')
 }

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

 import org.openzen.zenscript.javasource.prepare.JavaNativeClass;
 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
 import org.openzen.zenscript.javasource.scope.JavaSourceStatementScope;
-import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javashared.JavaClass;
 
 /**
  *
 public class JavaDefinitionVisitor implements DefinitionVisitor<Void> {
 	private final String indent;
 	private final JavaSourceCompiler compiler;
-	private final JavaSourceClass cls;
+	private final JavaClass cls;
 	private final JavaSourceFile file;
 	private final JavaSourceFormattingSettings settings;
 	private final List<ExpansionDefinition> expansions;
 	public JavaDefinitionVisitor(
 			String indent,
 			JavaSourceCompiler compiler,
-			JavaSourceClass cls,
+			JavaClass cls,
 			JavaSourceFile file,
 			StringBuilder output,
 			List<ExpansionDefinition> expansions,
 	@Override
 	public Void visitClass(ClassDefinition definition) {
 		JavaSourceFileScope scope = createScope(definition);
-		JavaSourceClass cls = definition.getTag(JavaSourceClass.class);
+		JavaClass cls = definition.getTag(JavaClass.class);
 		
 		output.append(indent);
 		convertModifiers(definition.modifiers);
 				else
 					output.append(", ");
 				
-				output.append(scope.importer.importType(new JavaSourceClass("java.lang", "AutoCloseable")));
+				output.append(scope.importer.importType(JavaClass.CLOSEABLE));
 			}
 		}
 		
 	@Override
 	public Void visitInterface(InterfaceDefinition definition) {
 		JavaSourceFileScope scope = createScope(definition);
-		JavaSourceClass cls = definition.getTag(JavaSourceClass.class);
+		JavaClass cls = definition.getTag(JavaClass.class);
 		
 		output.append(indent);
 		convertModifiers(definition.modifiers | Modifiers.VIRTUAL); // to prevent 'final'
 		boolean firstExtends = true;
 		if (definition.isDestructible()) {
 			output.append(" extends ");
-			output.append(scope.importer.importType(new JavaSourceClass("java.lang", "AutoCloseable")));
+			output.append(scope.importer.importType(JavaClass.CLOSEABLE));
 			firstExtends = false;
 		}
 		

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

 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
-import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javasource.tags.JavaSourceImplementation;
 import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 
 
 	@Override
 	public Void visitInnerDefinition(InnerDefinitionMember member) {
-		JavaSourceClass cls = member.innerDefinition.getTag(JavaSourceClass.class);
+		JavaClass cls = member.innerDefinition.getTag(JavaClass.class);
 		JavaDefinitionVisitor visitor = new JavaDefinitionVisitor(
 				indent,
 				compiler,

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

 import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.compiler.ZenCodeCompiler;
 import org.openzen.zenscript.javasource.prepare.JavaSourcePrepareDefinitionVisitor;
-import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javashared.JavaClass;
 
 /**
  *
 	public void addDefinition(HighLevelDefinition definition, SemanticModule module) {
 		String filename = getFilename(definition);
 		JavaSourcePrepareDefinitionVisitor prepare = new JavaSourcePrepareDefinitionVisitor(filename, null);
-		JavaSourceClass cls = definition.accept(prepare);
+		JavaClass cls = definition.accept(prepare);
 		if (cls.empty)
 			return;
 		

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

 import org.openzen.zenscript.formattershared.ExpressionString;
 import org.openzen.zenscript.formattershared.StatementFormattingTarget;
 import org.openzen.zenscript.javasource.scope.JavaSourceStatementScope;
-import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javasource.tags.JavaSourceField;
 import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 import org.openzen.zenscript.javasource.tags.JavaSourceVariantOption;
  * @author Hoofdgebruiker
  */
 public class JavaSourceExpressionFormatter implements ExpressionVisitor<ExpressionString> {
-	private static final JavaSourceClass RESULT = new JavaSourceClass("stdlib", "Result");
-	private static final JavaSourceClass RESULT_OK = new JavaSourceClass("stdlib", "Result.Ok");
-	private static final JavaSourceClass RESULT_ERROR = new JavaSourceClass("stdlib", "Result.Error");
+	private static final JavaClass RESULT = new JavaClass("stdlib", "Result", JavaClass.Kind.CLASS);
+	private static final JavaClass RESULT_OK = new JavaClass("stdlib", "Result.Ok", JavaClass.Kind.CLASS);
+	private static final JavaClass RESULT_ERROR = new JavaClass("stdlib", "Result.Error", JavaClass.Kind.CLASS);
 	
 	public final JavaSourceStatementScope scope;
 	public final StatementFormattingTarget target;
 			return visitBuiltinConstant(expression, expression.constant.member.builtin);
 		
 		return new ExpressionString(
-				scope.type(expression.constant.member.definition.getTag(JavaSourceClass.class)) + "." + expression.constant.member.name, 
+				scope.type(expression.constant.member.definition.getTag(JavaClass.class)) + "." + expression.constant.member.name, 
 				JavaOperator.MEMBER);
 	}
 
 	}
 	
 	private String constructThisName(DefinitionTypeID type) {
-		JavaSourceClass cls = type.definition.getTag(JavaSourceClass.class);
+		JavaClass cls = type.definition.getTag(JavaClass.class);
 		return cls.getClassName();
 	}
 
 		if (elementType instanceof GenericTypeID) {
 			// generic array creation
 			GenericTypeID generic = (GenericTypeID)elementType;
-			String array = scope.type(new JavaSourceClass("java.lang.reflect", "Array"));
+			String array = scope.type(new JavaClass("java.lang.reflect", "Array", JavaClass.Kind.CLASS));
 			return new ExpressionString("(" + generic.parameter.name + "[])(" + array + ".newInstance(typeOf" + generic.parameter.name + ", " + length.value + "))", JavaOperator.CAST);
 		} else {
 			return new ExpressionString("new " + scope.type(elementType) + "[" + length.value + "]", JavaOperator.NEW);
 			case STRING_CONSTRUCTOR_CHARACTERS:
 				return callStatic("new String", expression.arguments.arguments[0]);
 			case ASSOC_CONSTRUCTOR: {
-				String typeName = scope.type(new JavaSourceClass("java.util", "HashMap"));
+				String typeName = scope.type(new JavaClass("java.util", "HashMap", JavaClass.Kind.CLASS));
 				AssocTypeID type = (AssocTypeID) expression.type;
 				
 				StringBuilder result = new StringBuilder();
 				return new ExpressionString(result.toString(), JavaOperator.NEW);
 			}
 			case GENERICMAP_CONSTRUCTOR: {
-				String typeName = scope.type(new JavaSourceClass("java.util", "HashMap"));
+				String typeName = scope.type(new JavaClass("java.util", "HashMap", JavaClass.Kind.CLASS));
 				StringBuilder result = new StringBuilder();
 				result.append("new ").append(typeName).append("<Class<?>, Object>()");
 				return new ExpressionString(result.toString(), JavaOperator.NEW);

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

 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.compiler.SemanticModule;
-import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javashared.JavaClass;
 
 /**
  *
 	public final JavaSourceImporter importer;
 	private final JavaSourceCompiler compiler;
 	private final File file;
-	private final JavaSourceClass cls;
+	private final JavaClass cls;
 	private final StringBuilder contents = new StringBuilder();
 	private final ZSPackage pkg;
 	
 	private final Map<HighLevelDefinition, SemanticModule> modules = new HashMap<>();
 	private final Set<String> existing = new HashSet<>();
 	
-	public JavaSourceFile(JavaSourceCompiler compiler, File file, JavaSourceClass cls, ZSPackage pkg) {
+	public JavaSourceFile(JavaSourceCompiler compiler, File file, JavaClass cls, ZSPackage pkg) {
 		this.compiler = compiler;
 		this.pkg = pkg;
 		this.cls = cls;
 			writer.write(pkg.fullName);
 			writer.write(";\n\n");
 			
-			JavaSourceClass[] imports = importer.getUsedImports();
+			JavaClass[] imports = importer.getUsedImports();
 			if (imports.length > 0) {
-				for (JavaSourceClass import_ : imports) {
+				for (JavaClass import_ : imports) {
 					if (import_.pkg.equals("java.lang"))
 						continue;
 					

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

 import java.util.Map;
 import java.util.Set;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javashared.JavaClass;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class JavaSourceImporter {
-	private final JavaSourceClass cls;
-	private final Map<String, JavaSourceClass> imports = new HashMap<>();
-	private final Set<JavaSourceClass> usedImports = new HashSet<>();
+	private final JavaClass cls;
+	private final Map<String, JavaClass> imports = new HashMap<>();
+	private final Set<JavaClass> usedImports = new HashSet<>();
 	
-	public JavaSourceImporter(JavaSourceClass cls) {
+	public JavaSourceImporter(JavaClass cls) {
 		this.cls = cls;
 	}
 	
 	public String importType(HighLevelDefinition definition) {
-		JavaSourceClass cls = definition.getTag(JavaSourceClass.class);
+		JavaClass cls = definition.getTag(JavaClass.class);
 		if (cls == null)
 			throw new IllegalStateException("Missing source class tag on " + definition.name);
 		if (cls.pkg.equals(this.cls.pkg))
 		return importType(cls);
 	}
 	
-	public String importType(JavaSourceClass cls) {
+	public String importType(JavaClass cls) {
 		if (imports.containsKey(cls.outer.getName())) {
-			JavaSourceClass imported = imports.get(cls.outer.getName());
+			JavaClass imported = imports.get(cls.outer.getName());
 			usedImports.add(imported);
 			return imported.fullName.equals(cls.outer.fullName) ? cls.getName() : cls.fullName;
 		}
 		return cls.getClassName();
 	}
 	
-	public JavaSourceClass[] getUsedImports() {
-		JavaSourceClass[] imports = usedImports.toArray(new JavaSourceClass[usedImports.size()]);
+	public JavaClass[] getUsedImports() {
+		JavaClass[] imports = usedImports.toArray(new JavaClass[usedImports.size()]);
 		Arrays.sort(imports);
 		return imports;
 	}

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

 import org.openzen.zenscript.formattershared.StatementFormattingSubBlock;
 import org.openzen.zenscript.formattershared.StatementFormattingTarget;
 import org.openzen.zenscript.javasource.scope.JavaSourceStatementScope;
-import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javashared.JavaClass;
 
 /**
  *
 			
 			DefinitionTypeID variantType = (DefinitionTypeID)statement.value.type;
 			HighLevelDefinition variant = variantType.definition;
-			String variantTypeName = scope.type(variant.getTag(JavaSourceClass.class));
+			String variantTypeName = scope.type(variant.getTag(JavaClass.class));
 			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/JavaSourceSyntheticHelperGenerator.java

 import org.openzen.zenscript.codemodel.type.ITypeVisitor;
 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
-import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 
 /**
 	private final File directory;
 	private final JavaSourceFormattingSettings settings;
 	private final Map<String, List<String>> members = new HashMap<>();
-	private final JavaSourceClass arrayHelpers = new JavaSourceClass("zsynthetic", "ArrayHelpers");
+	private final JavaClass arrayHelpers = new JavaClass("zsynthetic", "ArrayHelpers", JavaClass.Kind.CLASS);
 	private final Map<ArrayKind, JavaSourceMethod> existingContains = new HashMap<>();
 	private final Map<ArrayKind, JavaSourceMethod> existingIndexOf = new HashMap<>();
 	
 		}
 	}
 	
-	private void addMember(JavaSourceClass className, String content) {
+	private void addMember(JavaClass className, String content) {
 		if (!members.containsKey(className.getName()))
 			members.put(className.getName(), new ArrayList<>());
 		

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

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javashared.JavaClass;
 
 /**
  *
 	public JavaSourceSyntheticTypeGenerator(File directory, JavaSourceFormattingSettings settings) {
 		this.directory = new File(directory, "zsynthetic");
 		this.settings = settings;
-		
-		
 	}
 	
 	public JavaSynthesizedClass createFunction(JavaSourceTypeVisitor typeFormatter, FunctionTypeID function) {
 			return functions.get(signature).withTypeParameters(extractTypeParameters(function));
 		
 		String className = "Function" + signature;
-		JavaSourceClass cls = new JavaSourceClass("zsynthetic", className);
+		JavaClass cls = new JavaClass("zsynthetic", className, JavaClass.Kind.INTERFACE);
 		JavaSynthesizedClass result = new JavaSynthesizedClass(cls, extractTypeParameters(function));
 		functions.put(signature, result);
 		
 		try (Writer writer = new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(file)), StandardCharsets.UTF_8)) {
 			writer.write("package zsynthetic;\n");
 			
-			JavaSourceClass[] imports = importer.getUsedImports();
+			JavaClass[] imports = importer.getUsedImports();
 			if (imports.length > 0) {
-				for (JavaSourceClass import_ : imports) {
+				for (JavaClass import_ : imports) {
 					if (import_.pkg.equals("java.lang"))
 						continue;
 					
 		return result;
 	}
 	
-	private String createFunctionClassName(FunctionTypeID function) {
-		StringBuilder className = new StringBuilder();
-		className.append("Function");
-		className.append(functions.size() + 1); // TODO: create more meaningful names
-		return className.toString();
-	}
-	
 	private TypeParameter[] extractTypeParameters(ITypeID type) {
 		List<TypeParameter> result = new ArrayList<>();
 		type.extractTypeParameters(result);

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

  */
 package org.openzen.zenscript.javasource;
 
-import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.GenericParameterBoundVisitor;
 import org.openzen.zenscript.codemodel.generic.ParameterSuperBound;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.ITypeVisitor;
 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
-import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javashared.JavaClass;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class JavaSourceTypeVisitor implements ITypeVisitor<String>, GenericParameterBoundVisitor<String> {
-	private static final JavaSourceClass MAP = new JavaSourceClass("java.util", "Map");
-	private static final JavaSourceClass HASHMAP = new JavaSourceClass("java.util", "HashMap");
-	private static final JavaSourceClass ITERATOR = new JavaSourceClass("java.util", "Iterator");
-	
 	public final JavaSourceImporter importer;
 	public final JavaSourceSyntheticTypeGenerator typeGenerator;
 	public final JavaSourceObjectTypeVisitor objectTypeVisitor;
-	public final JavaSourceClass cls;
+	public final JavaClass cls;
 	
 	public JavaSourceTypeVisitor(JavaSourceImporter importer, JavaSourceSyntheticTypeGenerator typeGenerator) {
 		this(importer, typeGenerator, null);
 	}
 	
-	public JavaSourceTypeVisitor(JavaSourceImporter importer, JavaSourceSyntheticTypeGenerator typeGenerator, JavaSourceClass cls) {
+	public JavaSourceTypeVisitor(JavaSourceImporter importer, JavaSourceSyntheticTypeGenerator typeGenerator, JavaClass cls) {
 		this.importer = importer;
 		this.typeGenerator = typeGenerator;
 		this.cls = cls;
 
 	@Override
 	public String visitAssoc(AssocTypeID assoc) {
-		String map = importer.importType(MAP);
+		String map = importer.importType(JavaClass.MAP);
 		return map + "<" + assoc.keyType.accept(new JavaSourceObjectTypeVisitor(importer, typeGenerator)) + ", " + assoc.valueType.accept(new JavaSourceObjectTypeVisitor(importer, typeGenerator)) + ">";
 	}
 
 	@Override
 	public String visitGenericMap(GenericMapTypeID map) {
-		return importer.importType(MAP) + "<Class<?>, Object>";
+		return importer.importType(JavaClass.MAP) + "<Class<?>, Object>";
 	}
 
 	@Override
 	public String visitIterator(IteratorTypeID iterator) {
 		if (iterator.iteratorTypes.length == 1) {
-			return importer.importType(ITERATOR) + "<" + iterator.iteratorTypes[0].accept(objectTypeVisitor) + '>';
+			return importer.importType(JavaClass.ITERATOR) + "<" + iterator.iteratorTypes[0].accept(objectTypeVisitor) + '>';
 		} else {
 			throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
 		}
 		return result.toString();
 	}
 	
-	private void format(StringBuilder output, DefinitionTypeID type, JavaSourceClass cls, boolean isStatic) {
+	private void format(StringBuilder output, DefinitionTypeID type, JavaClass cls, boolean isStatic) {
 		if (type.outer != null) {
 			format(output, type.outer, null, type.definition.isStatic() || type.definition.isInterface());
 			output.append(".");

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

 package org.openzen.zenscript.javasource;
 
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javashared.JavaClass;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class JavaSynthesizedClass {
-	public final JavaSourceClass cls;
+	public final JavaClass cls;
 	public final TypeParameter[] typeParameters;
 	
-	public JavaSynthesizedClass(JavaSourceClass cls, TypeParameter[] typeParameters) {
+	public JavaSynthesizedClass(JavaClass cls, TypeParameter[] typeParameters) {
 		this.cls = cls;
 		this.typeParameters = typeParameters;
 	}

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

 
 import java.util.HashMap;
 import java.util.Map;
-import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 
 /**
  * @author Hoofdgebruiker
  */
 public class JavaNativeClass {
-	public final JavaSourceClass cls;
+	public final JavaClass cls;
 	private final Map<String, JavaSourceMethod> methods = new HashMap<>();
 	public final boolean nonDestructible;
 	
-	public JavaNativeClass(JavaSourceClass cls) {
+	public JavaNativeClass(JavaClass cls) {
 		this(cls, false);
 	}
 	
-	public JavaNativeClass(JavaSourceClass cls, boolean nonDestructible) {
+	public JavaNativeClass(JavaClass cls, boolean nonDestructible) {
 		this.cls = cls;
 		this.nonDestructible = nonDestructible;
 	}

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

 import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.javasource.JavaSourceTypeNameVisitor;
-import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javasource.tags.JavaSourceField;
 import org.openzen.zenscript.javasource.tags.JavaSourceImplementation;
 import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 	
 	private final JavaSourcePrepareDefinitionVisitor definitionPreparer;
 	private final String filename;
-	private final JavaSourceClass cls;
+	private final JavaClass cls;
 	private final JavaNativeClass nativeClass;
 	
 	public JavaSourcePrepareClassMethodVisitor(
 			JavaSourcePrepareDefinitionVisitor definitionPreparer,
 			String filename,
-			JavaSourceClass cls,
+			JavaClass cls,
 			JavaNativeClass nativeClass,
 			boolean startsEmpty) {
 		this.definitionPreparer = definitionPreparer;
 			
 			cls.empty = false;
 			
-			JavaSourceClass implementationClass = new JavaSourceClass(cls, member.type.accept(new JavaSourceTypeNameVisitor()) + "Implementation");
+			JavaClass implementationClass = new JavaClass(cls, member.type.accept(new JavaSourceTypeNameVisitor()) + "Implementation", JavaClass.Kind.CLASS);
 			member.setTag(JavaSourceImplementation.class, new JavaSourceImplementation(false, implementationClass));
 			
 			JavaSourcePrepareClassMethodVisitor visitor = new JavaSourcePrepareClassMethodVisitor(definitionPreparer, filename, implementationClass, null, true);

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.formattershared.ExpressionString;
 import org.openzen.zenscript.javasource.JavaOperator;
-import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 import org.openzen.zenscript.javasource.tags.JavaSourceVariantOption;
 
  *
  * @author Hoofdgebruiker
  */
-public class JavaSourcePrepareDefinitionVisitor implements DefinitionVisitor<JavaSourceClass> {
+public class JavaSourcePrepareDefinitionVisitor implements DefinitionVisitor<JavaClass> {
 	private static final Map<String, JavaNativeClass> nativeClasses = new HashMap<>();
 	
 	static {
 		{
-			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.lang", "StringBuilder"));
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.lang", "StringBuilder", JavaClass.Kind.CLASS));
 			cls.addConstructor("constructor", "");
 			cls.addConstructor("constructorWithCapacity", "");
 			cls.addConstructor("constructorWithValue", "");
 		}
 		
 		{
-			JavaNativeClass list = new JavaNativeClass(new JavaSourceClass("java.util", "List"));
-			JavaSourceClass arrayList = new JavaSourceClass("java.util", "ArrayList");
+			JavaNativeClass list = new JavaNativeClass(new JavaClass("java.util", "List", JavaClass.Kind.INTERFACE));
+			JavaClass arrayList = new JavaClass("java.util", "ArrayList", JavaClass.Kind.CLASS);
 			list.addMethod("constructor", new JavaSourceMethod(arrayList, JavaSourceMethod.Kind.CONSTRUCTOR, "", false));
 			list.addInstanceMethod("add", "add");
 			list.addInstanceMethod("insert", "add");
 		}
 		
 		{
-			JavaNativeClass iterable = new JavaNativeClass(new JavaSourceClass("java.lang", "Iterable"));
+			JavaNativeClass iterable = new JavaNativeClass(new JavaClass("java.lang", "Iterable", JavaClass.Kind.INTERFACE));
 			iterable.addInstanceMethod("iterate", "iterator");
 			nativeClasses.put("stdlib::Iterable", iterable);
 		}
 		
 		{
-			JavaNativeClass iterator = new JavaNativeClass(new JavaSourceClass("java.lang", "Iterator"));
+			JavaNativeClass iterator = new JavaNativeClass(JavaClass.ITERATOR);
 			iterator.addInstanceMethod("hasNext", "hasNext");
 			iterator.addInstanceMethod("next", "next");
 			nativeClasses.put("stdlib::Iterator", iterator);
 		}
 		
 		{
-			JavaNativeClass comparable = new JavaNativeClass(new JavaSourceClass("java.lang", "Comparable"));
+			JavaNativeClass comparable = new JavaNativeClass(new JavaClass("java.lang", "Comparable", JavaClass.Kind.INTERFACE));
 			comparable.addInstanceMethod("compareTo", "compareTo");
 			nativeClasses.put("stdlib::Comparable", comparable);
 		}
 		
 		{
-			JavaSourceClass integer = new JavaSourceClass("java.lang", "Integer");
-			JavaSourceClass math = new JavaSourceClass("java.lang", "Math");
+			JavaClass integer = new JavaClass("java.lang", "Integer", JavaClass.Kind.CLASS);
+			JavaClass math = new JavaClass("java.lang", "Math", JavaClass.Kind.CLASS);
 			
 			JavaNativeClass cls = new JavaNativeClass(integer);
 			cls.addMethod("min", new JavaSourceMethod(math, JavaSourceMethod.Kind.STATIC, "min", false));
 		}
 		
 		{
-			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.lang", "String"));
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.lang", "String", JavaClass.Kind.CLASS));
 			cls.addMethod("contains", new JavaSourceMethod((formatter, calle) -> {
 				CallExpression call = (CallExpression)calle;
 				ExpressionString str = call.arguments.arguments[0].accept(formatter);
 		}
 		
 		{
-			JavaSourceClass arrays = new JavaSourceClass("java.lang", "Arrays");
+			JavaClass arrays = new JavaClass("java.lang", "Arrays", JavaClass.Kind.CLASS);
 			JavaNativeClass cls = new JavaNativeClass(arrays);
 			cls.addMethod("sort", new JavaSourceMethod(arrays, JavaSourceMethod.Kind.EXPANSION, "sort", false));
 			cls.addMethod("sorted", new JavaSourceMethod((formatter, calle) -> {
 		}
 		
 		{
-			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.lang", "IllegalArgumentException"));
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.lang", "IllegalArgumentException", JavaClass.Kind.CLASS));
 			cls.addConstructor("constructor", "");
 			nativeClasses.put("stdlib::IllegalArgumentException", cls);
 		}
 		
 		{
-			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.lang", "Exception"));
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.lang", "Exception", JavaClass.Kind.CLASS));
 			cls.addConstructor("constructor", "");
 			cls.addConstructor("constructorWithCause", "");
 			nativeClasses.put("stdlib::Exception", cls);
 		}
 		
 		{
-			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.io", "IOException"));
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.io", "IOException", JavaClass.Kind.CLASS));
 			cls.addConstructor("constructor", "");
 			nativeClasses.put("io::IOException", cls);
 		}
 		
 		{
-			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.io", "Reader"));
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.io", "Reader", JavaClass.Kind.INTERFACE));
 			cls.addInstanceMethod("destruct", "close");
 			cls.addInstanceMethod("readCharacter", "read");
 			cls.addInstanceMethod("readArray", "read");
 		}
 		
 		{
-			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.io", "StringReader"), true);
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.io", "StringReader", JavaClass.Kind.CLASS), true);
 			cls.addConstructor("constructor", "");
 			cls.addInstanceMethod("destructor", "close");
 			cls.addInstanceMethod("readCharacter", "read");
 	}
 	
 	private final String filename;
-	private final JavaSourceClass outerClass;
+	private final JavaClass outerClass;
 	
-	public JavaSourcePrepareDefinitionVisitor(String filename, JavaSourceClass outerClass) {
+	public JavaSourcePrepareDefinitionVisitor(String filename, JavaClass outerClass) {
 		this.filename = filename;
 		this.outerClass = outerClass;
 	}
 	
 	private boolean isPrepared(HighLevelDefinition definition) {
-		return definition.hasTag(JavaSourceClass.class);
+		return definition.hasTag(JavaClass.class);
 	}
 	
 	public void prepare(ITypeID type) {
 	}
 	
 	@Override
-	public JavaSourceClass visitClass(ClassDefinition definition) {
+	public JavaClass visitClass(ClassDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaSourceClass.class);
+			return definition.getTag(JavaClass.class);
 		
-		return visitClassCompiled(definition, true);
+		return visitClassCompiled(definition, true, JavaClass.Kind.CLASS);
 	}
 
 	@Override
-	public JavaSourceClass visitInterface(InterfaceDefinition definition) {
+	public JavaClass visitInterface(InterfaceDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaSourceClass.class);
+			return definition.getTag(JavaClass.class);
 		
 		for (ITypeID baseType : definition.baseInterfaces)
 			prepare(baseType);
 		
-		return visitClassCompiled(definition, true);
+		return visitClassCompiled(definition, true, JavaClass.Kind.INTERFACE);
 	}
 
 	@Override
-	public JavaSourceClass visitEnum(EnumDefinition definition) {
+	public JavaClass visitEnum(EnumDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaSourceClass.class);
+			return definition.getTag(JavaClass.class);
 		
-		return visitClassCompiled(definition, false);
+		return visitClassCompiled(definition, false, JavaClass.Kind.ENUM);
 	}
 
 	@Override
-	public JavaSourceClass visitStruct(StructDefinition definition) {
+	public JavaClass visitStruct(StructDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaSourceClass.class);
+			return definition.getTag(JavaClass.class);
 		
-		return visitClassCompiled(definition, true);
+		return visitClassCompiled(definition, true, JavaClass.Kind.CLASS);
 	}
 
 	@Override
-	public JavaSourceClass visitFunction(FunctionDefinition definition) {
+	public JavaClass visitFunction(FunctionDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaSourceClass.class);
+			return definition.getTag(JavaClass.class);
 		
-		JavaSourceClass cls = new JavaSourceClass(definition.pkg.fullName, filename);
-		definition.setTag(JavaSourceClass.class, cls);
+		JavaClass cls = new JavaClass(definition.pkg.fullName, filename, JavaClass.Kind.CLASS);
+		definition.setTag(JavaClass.class, cls);
 		JavaSourceMethod method = new JavaSourceMethod(cls, JavaSourceMethod.Kind.STATIC, definition.name, true);
 		definition.caller.setTag(JavaSourceMethod.class, method);
 		return cls;
 	}
 
 	@Override
-	public JavaSourceClass visitExpansion(ExpansionDefinition definition) {
+	public JavaClass visitExpansion(ExpansionDefinition definition) {
 		if (isPrepared(definition))
-			return definition.getTag(JavaSourceClass.class);
+			return definition.getTag(JavaClass.class);
 		
 		NativeTag nativeTag = definition.getTag(NativeTag.class);
 		JavaNativeClass nativeClass = null;
 			nativeClass = nativeClasses.get(nativeTag.value);
 		}
 		
-		JavaSourceClass cls = new JavaSourceClass(definition.pkg.fullName, filename);
-		definition.setTag(JavaSourceClass.class, cls);
+		JavaClass cls = new JavaClass(definition.pkg.fullName, filename, JavaClass.Kind.CLASS);
+		definition.setTag(JavaClass.class, cls);
 		visitExpansionMembers(definition, cls, nativeClass);
 		return cls;
 	}
 
 	@Override
-	public JavaSourceClass visitAlias(AliasDefinition definition) {
+	public JavaClass visitAlias(AliasDefinition definition) {
 		// nothing to do
 		return null;
 	}
 
 	@Override
-	public JavaSourceClass visitVariant(VariantDefinition variant) {
+	public JavaClass visitVariant(VariantDefinition variant) {
 		if (isPrepared(variant))
-			return variant.getTag(JavaSourceClass.class);
+			return variant.getTag(JavaClass.class);
 		
-		JavaSourceClass cls = new JavaSourceClass(variant.pkg.fullName, variant.name);
-		variant.setTag(JavaSourceClass.class, cls);
+		JavaClass cls = new JavaClass(variant.pkg.fullName, variant.name, JavaClass.Kind.CLASS);
+		variant.setTag(JavaClass.class, cls);
 		
 		for (VariantDefinition.Option option : variant.options) {
-			JavaSourceClass variantCls = new JavaSourceClass(cls.fullName, option.name);
+			JavaClass variantCls = new JavaClass(cls.fullName, option.name, JavaClass.Kind.CLASS);
 			option.setTag(JavaSourceVariantOption.class, new JavaSourceVariantOption(cls, variantCls));
 		}
 		
 		return cls;
 	}
 	
-	private JavaSourceClass visitClassCompiled(HighLevelDefinition definition, boolean startsEmpty) {
+	private JavaClass visitClassCompiled(HighLevelDefinition definition, boolean startsEmpty, JavaClass.Kind kind) {
 		if (definition.getSuperType() != null)
 			prepare(definition.getSuperType());
 		
 		NativeTag nativeTag = definition.getTag(NativeTag.class);
 		JavaNativeClass nativeClass = nativeTag == null ? null : nativeClasses.get(nativeTag.value);
 		if (nativeClass == null) {
-			JavaSourceClass cls = outerClass == null ? new JavaSourceClass(definition.pkg.fullName, definition.name) : new JavaSourceClass(outerClass, definition.name);
+			JavaClass cls = outerClass == null ? new JavaClass(definition.pkg.fullName, definition.name, kind) : new JavaClass(outerClass, definition.name, kind);
 			cls.destructible = definition.isDestructible();
-			definition.setTag(JavaSourceClass.class, cls);
+			definition.setTag(JavaClass.class, cls);
 			visitClassMembers(definition, cls, null, startsEmpty);
 			return cls;
 		} else {
-			JavaSourceClass cls = outerClass == null ? new JavaSourceClass(definition.pkg.fullName, filename) : new JavaSourceClass(outerClass, filename);
-			definition.setTag(JavaSourceClass.class, nativeClass.cls);
+			JavaClass 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);
 			visitExpansionMembers(definition, cls, nativeClass);
 			
 		}
 	}
 	
-	private void visitClassMembers(HighLevelDefinition definition, JavaSourceClass cls, JavaNativeClass nativeClass, boolean startsEmpty) {
+	private void visitClassMembers(HighLevelDefinition definition, JavaClass cls, JavaNativeClass nativeClass, boolean startsEmpty) {
 		JavaSourcePrepareClassMethodVisitor methodVisitor = new JavaSourcePrepareClassMethodVisitor(this, filename, cls, nativeClass, startsEmpty);
 		for (IDefinitionMember member : definition.members) {
 			member.accept(methodVisitor);
 		}
 	}
 	
-	private void visitExpansionMembers(HighLevelDefinition definition, JavaSourceClass cls, JavaNativeClass nativeClass) {
+	private void visitExpansionMembers(HighLevelDefinition definition, JavaClass cls, JavaNativeClass nativeClass) {
 		JavaSourcePrepareExpansionMethodVisitor methodVisitor = new JavaSourcePrepareExpansionMethodVisitor(cls, nativeClass);
 		for (IDefinitionMember member : definition.members) {
 			member.accept(methodVisitor);

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

 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
 import org.openzen.zenscript.javasource.JavaSourceTypeNameVisitor;
-import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javasource.tags.JavaSourceField;
 import org.openzen.zenscript.javasource.tags.JavaSourceImplementation;
 import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 public class JavaSourcePrepareExpansionMethodVisitor implements MemberVisitor<Void> {
 	private static final boolean DEBUG_EMPTY = true;
 	
-	private final JavaSourceClass cls;
+	private final JavaClass cls;
 	private final JavaNativeClass nativeClass;
 	
-	public JavaSourcePrepareExpansionMethodVisitor(JavaSourceClass cls, JavaNativeClass nativeClass) {
+	public JavaSourcePrepareExpansionMethodVisitor(JavaClass cls, JavaNativeClass nativeClass) {
 		this.cls = cls;
 		this.nativeClass = nativeClass;
 		cls.empty = true;
 
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
-		JavaSourceClass implementationClass = new JavaSourceClass(cls, member.type.accept(new JavaSourceTypeNameVisitor()) + "Implementation");
+		JavaClass implementationClass = new JavaClass(cls, member.type.accept(new JavaSourceTypeNameVisitor()) + "Implementation", JavaClass.Kind.CLASS);
 		member.setTag(JavaSourceImplementation.class, new JavaSourceImplementation(false, implementationClass));
 		for (IDefinitionMember implementedMember : member.members)
 			implementedMember.accept(this);

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

 import org.openzen.zenscript.javasource.JavaSourceSyntheticHelperGenerator;
 import org.openzen.zenscript.javasource.JavaSourceSyntheticTypeGenerator;
 import org.openzen.zenscript.javasource.JavaSourceTypeVisitor;
-import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javashared.JavaClass;
 
 /**
  *
 	public final JavaSourceImporter importer;
 	public final JavaSourceSyntheticTypeGenerator typeGenerator;
 	public final JavaSourceSyntheticHelperGenerator helperGenerator;
-	public final JavaSourceClass cls;
+	public final JavaClass cls;
 	public final JavaSourceTypeVisitor typeVisitor;
 	public final JavaSourceObjectTypeVisitor objectTypeVisitor;
 	public final TypeScope semanticScope;
 			JavaSourceImporter importer, 
 			JavaSourceSyntheticTypeGenerator typeGenerator,
 			JavaSourceSyntheticHelperGenerator helperGenerator,
-			JavaSourceClass cls,
+			JavaClass cls,
 			TypeScope semanticScope,
 			boolean isInterface,
 			ITypeID thisType)
 		return type.accept(typeVisitor);
 	}
 	
-	public String type(ITypeID type, JavaSourceClass rename) {
+	public String type(ITypeID type, JavaClass rename) {
 		return type.accept(new JavaSourceTypeVisitor(importer, typeGenerator, rename));
 	}
 }

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

 import org.openzen.zenscript.javasource.JavaSourceFormattingSettings;
 import org.openzen.zenscript.javasource.JavaSourceExpressionFormatter;
 import org.openzen.zenscript.javasource.JavaSourceStatementFormatter;
-import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javashared.JavaClass;
 
 /**
  *
 		return fileScope.type(type);
 	}
 	
-	public String type(ITypeID type, JavaSourceClass renamed) {
+	public String type(ITypeID type, JavaClass renamed) {
 		return fileScope.type(type, renamed);
 	}
 	
-	public String type(JavaSourceClass cls) {
+	public String type(JavaClass cls) {
 		return fileScope.importer.importType(cls);
 	}
 	

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

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.javasource.tags;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class JavaSourceClass implements Comparable<JavaSourceClass> {
-	public final JavaSourceClass outer;
-	
-	public final String pkg;
-	public final String fullName;
-	public final List<String> className;
-	public boolean empty = false;
-	public boolean destructible = false;
-	
-	public JavaSourceClass(String pkg, String name) {
-		this.pkg = pkg;
-		this.className = Collections.singletonList(name);
-		this.fullName = pkg + '.' + name;
-		
-		outer = this;
-	}
-	
-	public JavaSourceClass(JavaSourceClass outer, String name) {
-		this.pkg = outer.pkg;
-		this.className = new ArrayList<>();
-		this.className.addAll(outer.className);
-		this.className.add(name);
-		this.fullName = outer.fullName + '.' + name;
-		
-		this.outer = outer.outer;
-	}
-	
-	public String getName() {
-		return className.get(className.size() - 1);
-	}
-	
-	public String getClassName() {
-		return fullName.substring(pkg.length() + 1);
-	}
-
-	@Override
-	public int compareTo(JavaSourceClass o) {
-		return fullName.compareTo(o.fullName);
-	}
-}

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

  */
 package org.openzen.zenscript.javasource.tags;
 
+import org.openzen.zenscript.javashared.JavaClass;
+
 /**
  *
  * @author Hoofdgebruiker
  */
 public class JavaSourceField {
-	public final JavaSourceClass cls;
+	public final JavaClass cls;
 	public final String name;
 	
-	public JavaSourceField(JavaSourceClass cls, String name) {
+	public JavaSourceField(JavaClass cls, String name) {
 		this.cls = cls;
 		this.name = name;
 	}

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

  */
 package org.openzen.zenscript.javasource.tags;
 
+import org.openzen.zenscript.javashared.JavaClass;
+
 /**
  *
  * @author Hoofdgebruiker
  */
 public class JavaSourceImplementation {
 	public final boolean inline;
-	public final JavaSourceClass implementationClass;
+	public final JavaClass implementationClass;
 	
-	public JavaSourceImplementation(boolean inline, JavaSourceClass implementationClass) {
+	public JavaSourceImplementation(boolean inline, JavaClass implementationClass) {
 		this.inline = inline;
 		this.implementationClass = implementationClass;
 	}

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

  */
 package org.openzen.zenscript.javasource.tags;
 
+import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javasource.JavaCallCompiler;
 
 /**
  * @author Hoofdgebruiker
  */
 public class JavaSourceMethod {
-	public final JavaSourceClass cls;
+	public final JavaClass cls;
 	public final Kind kind;
 	public final String name;
 	public final boolean compile;
 	public final JavaCallCompiler compiler;
 	
-	public JavaSourceMethod(JavaSourceClass cls, Kind kind, String name, boolean compile) {
+	public JavaSourceMethod(JavaClass cls, Kind kind, String name, boolean compile) {
 		this.cls = cls;
 		this.kind = kind;
 		this.name = name;

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

  */
 package org.openzen.zenscript.javasource.tags;
 
+import org.openzen.zenscript.javashared.JavaClass;
+
 /**
  *
  * @author Hoofdgebruiker
  */
 public class JavaSourceVariantOption {
-	public final JavaSourceClass variantClass;
-	public final JavaSourceClass variantOptionClass;
+	public final JavaClass variantClass;
+	public final JavaClass variantOptionClass;
 	
-	public JavaSourceVariantOption(JavaSourceClass variantClass, JavaSourceClass variantOptionClass) {
+	public JavaSourceVariantOption(JavaClass variantClass, JavaClass variantOptionClass) {
 		this.variantClass = variantClass;
 		this.variantOptionClass = variantOptionClass;
 	}

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

 				statements.add(statement.compile(statementScope));
 			}
 			
-			ScriptBlock block = new ScriptBlock(statements);
+			ScriptBlock block = new ScriptBlock(modulePackage.getPackage(), statements);
 			block.setTag(SourceFile.class, file);
 			block.setTag(WhitespacePostComment.class, postComment);
 			scripts.add(block);

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

 
 	@Override
 	public void linkTypes(TypeResolutionContext context) {
-		compiled.setHeader(header.compile(context));
+		if (compiled.header == null)
+			compiled.setHeader(header.compile(context));
 	}
 	
 	@Override
 
 		@Override
 		public HighLevelDefinition load() {
+			linkTypes(context);
 			return compiled;
 		}
 	}

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

  */
 package org.openzen.zenscript.scriptingexample;
 
-import java.io.PrintStream;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
-import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.javabytecode.JavaBytecodeImplementation;
-import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaFieldInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 import org.openzen.zenscript.codemodel.type.ISymbol;
+import org.openzen.zenscript.javashared.JavaClass;
 
 /**
  *
 	private final ZSPackage javaLang = rootPackage.getOrCreatePackage("java").getOrCreatePackage("lang");
 	
 	public GlobalRegistry(ZSPackage globals) {
-		JavaClassInfo jPrintStream = new JavaClassInfo("java/io/PrintStream");
+		JavaClass jPrintStream = new JavaClass("java.io", "PrintStream", JavaClass.Kind.CLASS);
 		JavaMethodInfo printstreamPrintln = new JavaMethodInfo(jPrintStream, "println", "(Ljava/lang/String;)V", Opcodes.ACC_PUBLIC);
 		PRINTSTREAM_PRINTLN.setTag(JavaMethodInfo.class, printstreamPrintln);
 		
-		JavaClassInfo jSystem = new JavaClassInfo("java/lang/System");
+		JavaClass jSystem = new JavaClass("java.lang", "System", JavaClass.Kind.CLASS);
 		SYSTEM_OUT.setTag(JavaFieldInfo.class, new JavaFieldInfo(jSystem, "out", "Ljava/io/PrintStream;"));
 	}
 	
 			// 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("package");
 			ClassDefinition myClassDefinition = new ClassDefinition(CodePosition.NATIVE, packageMyPackage, "MyClass", Modifiers.PUBLIC, null);
-			JavaClassInfo myClassInfo = new JavaClassInfo("my/test/MyClass");
+			JavaClass myClassInfo = new JavaClass("my.test", "MyClass", JavaClass.Kind.CLASS);
 			
 			MethodMember member = new MethodMember(CodePosition.NATIVE, myClassDefinition, Modifiers.PUBLIC, "test", new FunctionHeader(BasicTypeID.STRING), null);
 			member.setTag(JavaMethodInfo.class, new JavaMethodInfo(myClassInfo, "test", "()Ljava/lang/String;", Opcodes.ACC_PUBLIC));

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

 	}
 	
 	private static JavaModule compileSemanticToJava(SemanticModule module) {
-		JavaCompiler compiler = new JavaCompiler(false);
+		JavaCompiler compiler = new JavaCompiler(false, null);
 		for (HighLevelDefinition definition : module.definitions.getAll()) {
 			compiler.addDefinition(definition, module);
 		}