WIP on new tags, refactoring & tag preparation system.

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

 	}
 	
 	private SourcePackage loadPackage(String name, File directory) {
+		if (!directory.exists())
+			throw new IllegalArgumentException("Directory does not exist: " + directory.getAbsolutePath());
+		
 		SourcePackage pkg = new SourcePackage(directory, name);
 		
 		for (File file : directory.listFiles()) {

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

 	private final JavaClassWriter scriptsClassWriter;
 	private int generatedScriptBlockCounter = 0;
 	private boolean finished = false;
-	private JavaModule compiled = null;
 	private final File jarFile;
+	private final JavaContext context;
 	
 	public JavaCompiler(File jarFile) {
 		this(false, jarFile);
 	public JavaCompiler(boolean debug, File jarFile) {
 		target = new JavaModule();
 		this.jarFile = jarFile;
+		this.context = new JavaContext(target);
 		
 		scriptsClassWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 		scriptsClassWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Scripts", null, "java/lang/Object", null);
 	public void addDefinition(HighLevelDefinition definition, SemanticModule module) {
 		String className = getClassName(definition.position.getFilename());
 		JavaScriptFile scriptFile = getScriptFile(className);
-		target.register(definition.name, definition.accept(new JavaDefinitionVisitor(scriptFile.classWriter)));
+		target.register(definition.name, definition.accept(new JavaDefinitionVisitor(context, scriptFile.classWriter)));
 	}
 	
 	@Override
 		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));
+		final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, new JavaWriter(visitor, method, null, null, null));
 		statementVisitor.start();
 		for (Statement statement : script.statements) {
 			statement.accept(statementVisitor);
 	
 	@Override
 	public void run() {
-		if (compiled == null)
+		if (!finished)
 			throw new IllegalStateException("Not yet built!");
 		
 		// TODO: execute this
 	public JavaModule finishAndGetModule() {
 		if (finished)
 			throw new IllegalStateException("Already finished!");
+		
 		finished = true;
 		
 		JavaMethodInfo runMethod = new JavaMethodInfo(new JavaClass("script", "Scripts", JavaClass.Kind.CLASS), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 		runWriter.end();
 		
 		target.register("Scripts", scriptsClassWriter.toByteArray());
-		
 		return target;
 	}
 }

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaContext.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.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.type.FunctionTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.RangeTypeID;
+import org.openzen.zenscript.javabytecode.compiler.CompilerUtils;
+import org.openzen.zenscript.javashared.JavaSynthesizedClass;
+import org.openzen.zenscript.javashared.JavaSyntheticClassGenerator;
+import org.openzen.zenscript.javashared.JavaTypeDescriptorVisitor;
+import org.openzen.zenscript.javashared.JavaTypeInternalNameVisitor;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaContext {
+	private final JavaModule module;
+	private final TypeGenerator typeGenerator;
+	private final JavaTypeInternalNameVisitor internalNameVisitor;
+	private final JavaTypeDescriptorVisitor descriptorVisitor;
+	
+	public JavaContext(JavaModule module) {
+		this.module = module;
+		
+		typeGenerator = new TypeGenerator();
+		internalNameVisitor = new JavaTypeInternalNameVisitor(typeGenerator);
+		descriptorVisitor = new JavaTypeDescriptorVisitor(typeGenerator);
+	}
+	
+	public JavaSyntheticClassGenerator getTypeGenerator() {
+		return typeGenerator;
+	}
+	
+	public String getDescriptor(ITypeID type) {
+		return type.accept(descriptorVisitor);
+	}
+	
+	public String getInternalName(ITypeID type) {
+		return type.accept(internalNameVisitor);
+	}
+	
+	public Type getType(ITypeID type) {
+		return Type.getType(getDescriptor(type));
+	}
+	
+	public String getMethodDescriptor(FunctionHeader header) {
+		return getMethodDescriptor(header, false);
+	}
+	
+    public String getMethodSignature(FunctionHeader header) {
+        StringBuilder signatureBuilder = new StringBuilder("(");
+        for (FunctionParameter parameter : header.parameters) {
+            signatureBuilder.append(getDescriptor(parameter.type));
+        }
+        signatureBuilder.append(")").append(getDescriptor(header.returnType));
+        return signatureBuilder.toString();
+    }
+	
+	public String getEnumConstructorDescriptor(FunctionHeader header) {
+		return getMethodDescriptor(header, true);
+	}
+	
+	private String getMethodDescriptor(FunctionHeader header, boolean isEnumConstructor) {
+        StringBuilder descBuilder = new StringBuilder("(");
+        if (isEnumConstructor)
+            descBuilder.append("Ljava/lang/String;I");
+		
+        for (FunctionParameter parameter : header.parameters) {
+			descBuilder.append(getDescriptor(parameter.type));
+        }
+        descBuilder.append(")");
+        descBuilder.append(getDescriptor(header.returnType));
+        return descBuilder.toString();
+    }
+	
+	public void register(String name, byte[] bytecode) {
+		module.register(name, bytecode);
+	}
+	
+	private class TypeGenerator implements JavaSyntheticClassGenerator {
+
+		@Override
+		public JavaSynthesizedClass synthesizeFunction(FunctionTypeID type) {
+			return CompilerUtils.getLambdaInterface(JavaContext.this, type);
+		}
+
+		@Override
+		public JavaSynthesizedClass synthesizeRange(RangeTypeID type) {
+			throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		}
+	}
+}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaFieldInfo.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.openzen.zenscript.javashared.JavaClass;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class JavaFieldInfo {
-	public final JavaClass javaClass;
-	public final String name;
-	public final 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/JavaModule.java

 
 		@Override
 		public Class<?> loadClass(String name) throws ClassNotFoundException {
-			if(customClasses.containsKey(name))
+			if (customClasses.containsKey(name))
 				return customClasses.get(name);
-			if(classes.containsKey(name)) {
+			if (classes.containsKey(name)) {
 				final byte[] bytes = classes.get(name);
 				customClasses.put(name, defineClass(name, bytes, 0, bytes.length, null));
 				return customClasses.get(name);

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/CompilerUtils.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.JavaModule;
 import org.openzen.zenscript.javabytecode.JavaParameterInfo;
 
-import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
+import org.openzen.zenscript.codemodel.type.FunctionTypeID;
+import org.openzen.zenscript.javabytecode.JavaContext;
+import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaSynthesizedClass;
+import org.openzen.zenscript.javashared.JavaSynthesizedClassNamer;
 
 public class CompilerUtils {
-    public static String calcDesc(FunctionHeader header, boolean isEnum) {
-        StringBuilder descBuilder = new StringBuilder("(");
-        if (isEnum)
-            descBuilder.append("Ljava/lang/String;I");
-        for (FunctionParameter parameter : header.parameters) {
-            //descBuilder.append(Type.getDescriptor(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
-            descBuilder.append(parameter.type.accept(JavaTypeVisitor.INSTANCE).getDescriptor());
-        }
-        descBuilder.append(")");
-        descBuilder.append(header.returnType.accept(JavaTypeVisitor.INSTANCE).getDescriptor());
-        return descBuilder.toString();
-    }
-
-    public static String calcSign(FunctionHeader header, boolean isEnum) {
-        StringBuilder signatureBuilder = new StringBuilder("(");
-        for (FunctionParameter parameter : header.parameters) {
-            signatureBuilder.append(parameter.type.accept(JavaTypeVisitor.INSTANCE).getDescriptor());
-        }
-        signatureBuilder.append(")").append(header.returnType.accept(JavaTypeVisitor.INSTANCE).getDescriptor());
-        return signatureBuilder.toString();
-    }
+	private CompilerUtils() {}
 
     public static boolean isPrimitive(ITypeID id) {
         if (id instanceof BasicTypeID) {
         return position.getFilename().substring(0, position.getFilename().lastIndexOf('.')).replace("/", "_");
     }
 
-    public static void tagMethodParameters(FunctionHeader header, boolean isStatic) {
-        JavaTypeVisitor typeVisitor = new JavaTypeVisitor();
+    public static void tagMethodParameters(JavaContext context, FunctionHeader header, boolean isStatic) {
         for (int i = 0; i < header.parameters.length; i++) {
             FunctionParameter parameter = header.parameters[i];
-            Type parameterType = parameter.type.accept(typeVisitor);
+            Type parameterType = context.getType(parameter.type);
             parameter.setTag(JavaParameterInfo.class, new JavaParameterInfo(isStatic ? i : i + 1, parameterType));
         }
     }
 
-    public static void tagConstructorParameters(FunctionHeader header, boolean isEnum) {
-        JavaTypeVisitor typeVisitor = new JavaTypeVisitor();
+    public static void tagConstructorParameters(JavaContext context, FunctionHeader header, boolean isEnum) {
         for (int i = 0; i < header.parameters.length; i++) {
             FunctionParameter parameter = header.parameters[i];
-            Type parameterType = parameter.type.accept(typeVisitor);
+            Type parameterType = context.getType(parameter.type);
             parameter.setTag(JavaParameterInfo.class, new JavaParameterInfo(isEnum ? i + 3 : i + 1, parameterType));
         }
     }
 
-    public static void writeDefaultFieldInitializers(JavaWriter constructorWriter, HighLevelDefinition definition, boolean staticFields) {
-        JavaExpressionVisitor expressionVisitor = new JavaExpressionVisitor(constructorWriter);
+    public static void writeDefaultFieldInitializers(JavaContext context, JavaWriter constructorWriter, HighLevelDefinition definition, boolean staticFields) {
+        JavaExpressionVisitor expressionVisitor = new JavaExpressionVisitor(context, constructorWriter);
         for (final IDefinitionMember definitionMember : definition.members) {
             if (!(definitionMember instanceof FieldMember))
                 continue;
                     constructorWriter.loadObject(0);
                 field.initializer.accept(expressionVisitor);
                 if (staticFields)
-                    constructorWriter.putStaticField(definition.name, field.name, Type.getDescriptor(field.type.accept(JavaTypeClassVisitor.INSTANCE)));
+                    constructorWriter.putStaticField(definition.name, field.name, context.getDescriptor(field.type));
                 else
-                    constructorWriter.putField(definition.name, field.name, Type.getDescriptor(field.type.accept(JavaTypeClassVisitor.INSTANCE)));
+                    constructorWriter.putField(definition.name, field.name, context.getDescriptor(field.type));
             }
         }
     }
 
-    private static final Map<String, String> lambdas = new HashMap<>();
-    private static int lambdaCounter = 0;
-    private static int lambdaICounter = 0;
-    public static String getLambdaInterface(final FunctionHeader header) {
-        StringBuilder builder = new StringBuilder("(");
-        for (FunctionParameter parameter : header.parameters) {
-            builder.append(parameter.type.accept(JavaTypeVisitor.INSTANCE).getDescriptor());
-        }
-
-        //final String identifier = header.toString();
-        final String identifier = builder.append(")").append(header.returnType.accept(JavaTypeVisitor.INSTANCE).getDescriptor()).toString();
-        if(!lambdas.containsKey(identifier)) {
-            final String name = "lambdaInterface" + ++lambdaICounter;
-            lambdas.put(identifier, name);
-            createLambdaInterface(header, name);
-        }
-        return lambdas.get(identifier);
+	private static final Map<String, JavaSynthesizedClass> functions = new HashMap<>();
+	
+    public static JavaSynthesizedClass getLambdaInterface(JavaContext context, FunctionTypeID function) {
+		String signature = JavaSynthesizedClassNamer.getFunctionSignature(function);
+		if (functions.containsKey(signature))
+			return functions.get(signature).withTypeParameters(JavaSynthesizedClassNamer.extractTypeParameters(function));
+		
+		JavaSynthesizedClass result = JavaSynthesizedClassNamer.createFunctionName(function);
+		functions.put(signature, result);
+		
+        createLambdaInterface(context, function.header, result.cls);
+        return result;
     }
 
-    private static void createLambdaInterface(FunctionHeader header, String name) {
+    private static void createLambdaInterface(JavaContext context, FunctionHeader header, JavaClass cls) {
         ClassWriter ifaceWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
         ifaceWriter.visitAnnotation("java/lang/FunctionalInterface", true).visitEnd();
-        ifaceWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT, name, null, "java/lang/Object", null);
-
-        ifaceWriter.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, "accept", calcDesc(header, false), calcSign(header, false), null).visitEnd();
+        ifaceWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT, cls.getClassName(), null, "java/lang/Object", null);
 
-        ifaceWriter.visitEnd();
+        ifaceWriter
+				.visitMethod(
+					Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT,
+					"accept",
+					context.getMethodDescriptor(header),
+					context.getMethodSignature(header),
+					null)
+				.visitEnd();
 
-        JavaModule.classes.putIfAbsent(name, ifaceWriter.toByteArray());
+        context.register(cls.internalName, ifaceWriter.toByteArray());
 
-        try (FileOutputStream out = new FileOutputStream(name + ".class")){
+        try (FileOutputStream out = new FileOutputStream(cls.getClassName() + ".class")){
             out.write(ifaceWriter.toByteArray());
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 
-
+	private static int lambdaCounter = 0;
     public static String getLambdaCounter() {
         return "lambda" + ++lambdaCounter;
     }
 
-
-
     public static int getKeyForSwitch(SwitchValue expression) {
 		return expression.accept(new SwitchKeyVisitor());
     }

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

 package org.openzen.zenscript.javabytecode.compiler;
 
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.Comparator;
-import java.util.Map;
 import java.util.StringJoiner;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Label;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaField;
+import org.openzen.zenscript.javashared.JavaSynthesizedClassNamer;
 
 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 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 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 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 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 JavaMethodInfo INTEGER_NUMBER_OF_TRAILING_ZEROS = new JavaMethodInfo(INTEGER, "numberOfTrailingZeros", "(I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_NUMBER_OF_LEADING_ZEROS = new JavaMethodInfo(INTEGER, "numberOfLeadingZeros", "(I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_PARSE = new JavaMethodInfo(INTEGER, "parseInt", "(Ljava/lang/String;)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_PARSE_WITH_BASE = new JavaMethodInfo(INTEGER, "parseInt", "(Ljava/lang/String;I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_PARSE_UNSIGNED = new JavaMethodInfo(INTEGER, "parseUnsignedInt", "(Ljava/lang/String;)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_PARSE_UNSIGNED_WITH_BASE = new JavaMethodInfo(INTEGER, "parseUnsignedInt", "(Ljava/lang/String;I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_HIGHEST_ONE_BIT = new JavaMethodInfo(INTEGER, "highestOneBit", "(I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_LOWEST_ONE_BIT = new JavaMethodInfo(INTEGER, "lowestOneBit", "(I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_BIT_COUNT = new JavaMethodInfo(INTEGER, "bitCount", "(I)I", PUBLIC_STATIC);
-	private static final JavaFieldInfo INTEGER_MIN_VALUE = new JavaFieldInfo(INTEGER, "MIN_VALUE", "I");
-	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 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 JavaMethodInfo LONG_REMAINDER_UNSIGNED = new JavaMethodInfo(LONG, "remainderUnsigned", "(JJ)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_NUMBER_OF_TRAILING_ZEROS = new JavaMethodInfo(LONG, "numberOfTrailingZeros", "(J)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_NUMBER_OF_LEADING_ZEROS = new JavaMethodInfo(LONG, "numberOfLeadingZeros", "(J)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_PARSE = new JavaMethodInfo(LONG, "parseLong", "(Ljava/lang/String;)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_PARSE_WITH_BASE = new JavaMethodInfo(LONG, "parseLong", "(Ljava/lang/String;I)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_PARSE_UNSIGNED = new JavaMethodInfo(LONG, "parseUnsignedLong", "(Ljava/lang/String;)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_PARSE_UNSIGNED_WITH_BASE = new JavaMethodInfo(LONG, "parseUnsignedLong", "(Ljava/lang/String;I)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_HIGHEST_ONE_BIT = new JavaMethodInfo(LONG, "highestOneBit", "(J)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_LOWEST_ONE_BIT = new JavaMethodInfo(LONG, "lowestOneBit", "(J)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_BIT_COUNT = new JavaMethodInfo(LONG, "bitCount", "(J)I", PUBLIC_STATIC);
-	private static final JavaFieldInfo LONG_MIN_VALUE = new JavaFieldInfo(LONG, "MIN_VALUE", "J");
-	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 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 JavaMethodInfo FLOAT_BITS = new JavaMethodInfo(FLOAT, "floatToRawIntBits", "(F)I", 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 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 JavaMethodInfo DOUBLE_BITS = new JavaMethodInfo(DOUBLE, "doubleToRawLongBits", "(D)J", 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 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 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_SUBSTRING = new JavaMethodInfo(STRING, "substring", "(II)Ljava/lang/String;", PUBLIC);
-	private static final JavaMethodInfo STRING_TRIM = new JavaMethodInfo(STRING, "trim", "()Ljava/lang/String;", PUBLIC);
-	private static final JavaMethodInfo STRING_TO_LOWER_CASE = new JavaMethodInfo(STRING, "toLowerCase", "()Ljava/lang/String;", PUBLIC);
-	private static final JavaMethodInfo STRING_TO_UPPER_CASE = new JavaMethodInfo(STRING, "toUpperCase", "()Ljava/lang/String;", 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 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 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_SIZE = new JavaMethodInfo(MAP, "size", "()I", 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 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_COPY_OF_RANGE_SHORTS = new JavaMethodInfo(ARRAYS, "copyOfRange", "([SII)[S", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_INTS = new JavaMethodInfo(ARRAYS, "copyOfRange", "([III)[I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_LONGS = new JavaMethodInfo(ARRAYS, "copyOfRange", "([JII)[J", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_FLOATS = new JavaMethodInfo(ARRAYS, "copyOfRange", "([FII)[F", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_DOUBLES = new JavaMethodInfo(ARRAYS, "copyOfRange", "([DII)[D", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_CHARS = new JavaMethodInfo(ARRAYS, "copyOfRange", "([CII)[C", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_OBJECTS = new JavaMethodInfo(ARRAYS, "equals", "([Ljava/lang/Object[Ljava/lang/Object)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_BOOLS = new JavaMethodInfo(ARRAYS, "equals", "([Z[Z)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_BYTES = new JavaMethodInfo(ARRAYS, "equals", "([B[B)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_SHORTS = new JavaMethodInfo(ARRAYS, "equals", "([S[S)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_INTS = new JavaMethodInfo(ARRAYS, "equals", "([I[I)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_LONGS = new JavaMethodInfo(ARRAYS, "equals", "([L[L)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_FLOATS = new JavaMethodInfo(ARRAYS, "equals", "([F[F)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_DOUBLES = new JavaMethodInfo(ARRAYS, "equals", "([D[D)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_CHARS = new JavaMethodInfo(ARRAYS, "equals", "([C[C)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_DEEPHASHCODE = new JavaMethodInfo(ARRAYS, "deepHashCode", "([Ljava/lang/Object;)", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_BOOLS = new JavaMethodInfo(ARRAYS, "hashCode", "([Z)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_BYTES = new JavaMethodInfo(ARRAYS, "hashCode", "([B)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_SHORTS = new JavaMethodInfo(ARRAYS, "hashCode", "([S)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_INTS = new JavaMethodInfo(ARRAYS, "hashCode", "([I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_LONGS = new JavaMethodInfo(ARRAYS, "hashCode", "([L)I", 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 JavaClass OBJECT = JavaCompileUtils.get(Object.class);
-	private static final JavaMethodInfo OBJECT_HASHCODE = new JavaMethodInfo(OBJECT, "hashCode", "()I", PUBLIC);
-	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);
+	private static final JavaMethodInfo BOOLEAN_PARSE = new JavaMethodInfo(JavaClass.BOOLEAN, "parseBoolean", "(Ljava/lang/String;)Z", PUBLIC_STATIC);
+	private static final JavaMethodInfo BOOLEAN_TO_STRING = new JavaMethodInfo(JavaClass.BOOLEAN, "toString", "(Z)Ljava/lang/String;", PUBLIC_STATIC);
+	private static final JavaMethodInfo BYTE_PARSE = new JavaMethodInfo(JavaClass.BYTE, "parseByte", "(Ljava/lang/String;)B", PUBLIC_STATIC);
+	private static final JavaMethodInfo BYTE_PARSE_WITH_BASE = new JavaMethodInfo(JavaClass.BYTE, "parseByte", "(Ljava/lang/String;I)B", PUBLIC_STATIC);
+	private static final JavaField BYTE_MIN_VALUE = new JavaField(JavaClass.BYTE, "MIN_VALUE", "B");
+	private static final JavaField BYTE_MAX_VALUE = new JavaField(JavaClass.BYTE, "MAX_VALUE", "B");
+	private static final JavaMethodInfo BYTE_TO_STRING = new JavaMethodInfo(JavaClass.BYTE, "toString", "(B)Ljava/lang/String;", PUBLIC_STATIC);
+	private static final JavaMethodInfo SHORT_PARSE = new JavaMethodInfo(JavaClass.SHORT, "parseShort", "(Ljava/lang/String;)S", PUBLIC_STATIC);
+	private static final JavaMethodInfo SHORT_PARSE_WITH_BASE = new JavaMethodInfo(JavaClass.SHORT, "parseShort", "(Ljava/lang/String;I)S", PUBLIC_STATIC);
+	private static final JavaField SHORT_MIN_VALUE = new JavaField(JavaClass.SHORT, "MIN_VALUE", "S");
+	private static final JavaField SHORT_MAX_VALUE = new JavaField(JavaClass.SHORT, "MAX_VALUE", "S");
+	private static final JavaMethodInfo SHORT_TO_STRING = new JavaMethodInfo(JavaClass.SHORT, "toString", "(S)Ljava/lang/String;", PUBLIC_STATIC);
+	private static final JavaMethodInfo INTEGER_COMPARE_UNSIGNED = new JavaMethodInfo(JavaClass.INTEGER, "compareUnsigned", "(II)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo INTEGER_DIVIDE_UNSIGNED = new JavaMethodInfo(JavaClass.INTEGER, "divideUnsigned", "(II)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo INTEGER_REMAINDER_UNSIGNED = new JavaMethodInfo(JavaClass.INTEGER, "remainderUnsigned", "(II)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo INTEGER_NUMBER_OF_TRAILING_ZEROS = new JavaMethodInfo(JavaClass.INTEGER, "numberOfTrailingZeros", "(I)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo INTEGER_NUMBER_OF_LEADING_ZEROS = new JavaMethodInfo(JavaClass.INTEGER, "numberOfLeadingZeros", "(I)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo INTEGER_PARSE = new JavaMethodInfo(JavaClass.INTEGER, "parseInt", "(Ljava/lang/String;)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo INTEGER_PARSE_WITH_BASE = new JavaMethodInfo(JavaClass.INTEGER, "parseInt", "(Ljava/lang/String;I)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo INTEGER_PARSE_UNSIGNED = new JavaMethodInfo(JavaClass.INTEGER, "parseUnsignedInt", "(Ljava/lang/String;)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo INTEGER_PARSE_UNSIGNED_WITH_BASE = new JavaMethodInfo(JavaClass.INTEGER, "parseUnsignedInt", "(Ljava/lang/String;I)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo INTEGER_HIGHEST_ONE_BIT = new JavaMethodInfo(JavaClass.INTEGER, "highestOneBit", "(I)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo INTEGER_LOWEST_ONE_BIT = new JavaMethodInfo(JavaClass.INTEGER, "lowestOneBit", "(I)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo INTEGER_BIT_COUNT = new JavaMethodInfo(JavaClass.INTEGER, "bitCount", "(I)I", PUBLIC_STATIC);
+	private static final JavaField INTEGER_MIN_VALUE = new JavaField(JavaClass.INTEGER, "MIN_VALUE", "I");
+	private static final JavaField INTEGER_MAX_VALUE = new JavaField(JavaClass.INTEGER, "MAX_VALUE", "I");
+	private static final JavaMethodInfo INTEGER_TO_STRING = new JavaMethodInfo(JavaClass.INTEGER, "toString", "(I)Ljava/lang/String;", PUBLIC_STATIC);
+	private static final JavaMethodInfo INTEGER_TO_UNSIGNED_STRING = new JavaMethodInfo(JavaClass.INTEGER, "toUnsignedString", "(I)Ljava/lang/String;", PUBLIC_STATIC);
+	private static final JavaMethodInfo LONG_COMPARE = new JavaMethodInfo(JavaClass.LONG, "compare", "(JJ)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo LONG_COMPARE_UNSIGNED = new JavaMethodInfo(JavaClass.LONG, "compareUnsigned", "(JJ)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo LONG_DIVIDE_UNSIGNED = new JavaMethodInfo(JavaClass.LONG, "divideUnsigned", "(JJ)J", PUBLIC_STATIC);
+	private static final JavaMethodInfo LONG_REMAINDER_UNSIGNED = new JavaMethodInfo(JavaClass.LONG, "remainderUnsigned", "(JJ)J", PUBLIC_STATIC);
+	private static final JavaMethodInfo LONG_NUMBER_OF_TRAILING_ZEROS = new JavaMethodInfo(JavaClass.LONG, "numberOfTrailingZeros", "(J)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo LONG_NUMBER_OF_LEADING_ZEROS = new JavaMethodInfo(JavaClass.LONG, "numberOfLeadingZeros", "(J)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo LONG_PARSE = new JavaMethodInfo(JavaClass.LONG, "parseLong", "(Ljava/lang/String;)J", PUBLIC_STATIC);
+	private static final JavaMethodInfo LONG_PARSE_WITH_BASE = new JavaMethodInfo(JavaClass.LONG, "parseLong", "(Ljava/lang/String;I)J", PUBLIC_STATIC);
+	private static final JavaMethodInfo LONG_PARSE_UNSIGNED = new JavaMethodInfo(JavaClass.LONG, "parseUnsignedLong", "(Ljava/lang/String;)J", PUBLIC_STATIC);
+	private static final JavaMethodInfo LONG_PARSE_UNSIGNED_WITH_BASE = new JavaMethodInfo(JavaClass.LONG, "parseUnsignedLong", "(Ljava/lang/String;I)J", PUBLIC_STATIC);
+	private static final JavaMethodInfo LONG_HIGHEST_ONE_BIT = new JavaMethodInfo(JavaClass.LONG, "highestOneBit", "(J)J", PUBLIC_STATIC);
+	private static final JavaMethodInfo LONG_LOWEST_ONE_BIT = new JavaMethodInfo(JavaClass.LONG, "lowestOneBit", "(J)J", PUBLIC_STATIC);
+	private static final JavaMethodInfo LONG_BIT_COUNT = new JavaMethodInfo(JavaClass.LONG, "bitCount", "(J)I", PUBLIC_STATIC);
+	private static final JavaField LONG_MIN_VALUE = new JavaField(JavaClass.LONG, "MIN_VALUE", "J");
+	private static final JavaField LONG_MAX_VALUE = new JavaField(JavaClass.LONG, "MAX_VALUE", "J");
+	private static final JavaMethodInfo LONG_TO_STRING = new JavaMethodInfo(JavaClass.LONG, "toString", "(J)Ljava/lang/String;", PUBLIC_STATIC);
+	private static final JavaMethodInfo LONG_TO_UNSIGNED_STRING = new JavaMethodInfo(JavaClass.LONG, "toUnsignedString", "(J)Ljava/lang/String;", PUBLIC_STATIC);
+	private static final JavaMethodInfo FLOAT_COMPARE = new JavaMethodInfo(JavaClass.FLOAT, "compare", "(FF)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo FLOAT_PARSE = new JavaMethodInfo(JavaClass.FLOAT, "parseFloat", "(Ljava/lang/String;)F", PUBLIC_STATIC);
+	private static final JavaMethodInfo FLOAT_FROM_BITS = new JavaMethodInfo(JavaClass.FLOAT, "intBitsToFloat", "(I)F", PUBLIC_STATIC);
+	private static final JavaMethodInfo FLOAT_BITS = new JavaMethodInfo(JavaClass.FLOAT, "floatToRawIntBits", "(F)I", PUBLIC_STATIC);
+	private static final JavaField FLOAT_MIN_VALUE = new JavaField(JavaClass.FLOAT, "MIN_VALUE", "F");
+	private static final JavaField FLOAT_MAX_VALUE = new JavaField(JavaClass.FLOAT, "MAX_VALUE", "F");
+	private static final JavaMethodInfo FLOAT_TO_STRING = new JavaMethodInfo(JavaClass.FLOAT, "toString", "(F)Ljava/lang/String;", PUBLIC_STATIC);
+	private static final JavaMethodInfo DOUBLE_COMPARE = new JavaMethodInfo(JavaClass.DOUBLE, "compare", "(DD)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo DOUBLE_PARSE = new JavaMethodInfo(JavaClass.DOUBLE, "parseDouble", "(Ljava/lang/String;)D", PUBLIC_STATIC);
+	private static final JavaMethodInfo DOUBLE_FROM_BITS = new JavaMethodInfo(JavaClass.DOUBLE, "longBitsToDouble", "(J)D", PUBLIC_STATIC);
+	private static final JavaMethodInfo DOUBLE_BITS = new JavaMethodInfo(JavaClass.DOUBLE, "doubleToRawLongBits", "(D)J", PUBLIC_STATIC);
+	private static final JavaField DOUBLE_MIN_VALUE = new JavaField(JavaClass.DOUBLE, "MIN_VALUE", "D");
+	private static final JavaField DOUBLE_MAX_VALUE = new JavaField(JavaClass.DOUBLE, "MAX_VALUE", "D");
+	private static final JavaMethodInfo DOUBLE_TO_STRING = new JavaMethodInfo(JavaClass.DOUBLE, "toString", "(D)Ljava/lang/String;", PUBLIC_STATIC);
+	private static final JavaMethodInfo CHARACTER_TO_LOWER_CASE = new JavaMethodInfo(JavaClass.CHARACTER, "toLowerCase", "()C", PUBLIC);
+	private static final JavaMethodInfo CHARACTER_TO_UPPER_CASE = new JavaMethodInfo(JavaClass.CHARACTER, "toUpperCase", "()C", PUBLIC);
+	private static final JavaField CHARACTER_MIN_VALUE = new JavaField(JavaClass.CHARACTER, "MIN_VALUE", "C");
+	private static final JavaField CHARACTER_MAX_VALUE = new JavaField(JavaClass.CHARACTER, "MAX_VALUE", "C");
+	private static final JavaMethodInfo CHARACTER_TO_STRING = new JavaMethodInfo(JavaClass.CHARACTER, "toString", "(C)Ljava/lang/String;", PUBLIC_STATIC);
+	private static final JavaMethodInfo STRING_COMPARETO = new JavaMethodInfo(JavaClass.STRING, "compareTo", "(Ljava/lang/String;)I", PUBLIC);
+	private static final JavaMethodInfo STRING_CONCAT = new JavaMethodInfo(JavaClass.STRING, "concat", "(Ljava/lang/String;)Ljava/lang/String;", PUBLIC);
+	private static final JavaMethodInfo STRING_CHAR_AT = new JavaMethodInfo(JavaClass.STRING, "charAt", "(I)C", PUBLIC);
+	private static final JavaMethodInfo STRING_SUBSTRING = new JavaMethodInfo(JavaClass.STRING, "substring", "(II)Ljava/lang/String;", PUBLIC);
+	private static final JavaMethodInfo STRING_TRIM = new JavaMethodInfo(JavaClass.STRING, "trim", "()Ljava/lang/String;", PUBLIC);
+	private static final JavaMethodInfo STRING_TO_LOWER_CASE = new JavaMethodInfo(JavaClass.STRING, "toLowerCase", "()Ljava/lang/String;", PUBLIC);
+	private static final JavaMethodInfo STRING_TO_UPPER_CASE = new JavaMethodInfo(JavaClass.STRING, "toUpperCase", "()Ljava/lang/String;", PUBLIC);
+	private static final JavaMethodInfo STRING_LENGTH = new JavaMethodInfo(JavaClass.STRING, "length", "()I", PUBLIC);
+	private static final JavaMethodInfo STRING_CHARACTERS = new JavaMethodInfo(JavaClass.STRING, "toCharArray", "()[C", PUBLIC);
+	private static final JavaMethodInfo STRING_ISEMPTY = new JavaMethodInfo(JavaClass.STRING, "isEmpty", "()Z", PUBLIC);
+	private static final JavaMethodInfo ENUM_COMPARETO = new JavaMethodInfo(JavaClass.ENUM, "compareTo", "(Ljava/lang/Enum;)I", PUBLIC);
+	private static final JavaMethodInfo ENUM_NAME = new JavaMethodInfo(JavaClass.ENUM, "name", "()Ljava/lang/String;", PUBLIC);
+	private static final JavaMethodInfo ENUM_ORDINAL = new JavaMethodInfo(JavaClass.ENUM, "ordinal", "()I", PUBLIC);
+	private static final JavaMethodInfo MAP_GET = new JavaMethodInfo(JavaClass.MAP, "get", "(Ljava/lang/Object;)Ljava/lang/Object;", PUBLIC);
+	private static final JavaMethodInfo MAP_PUT = new JavaMethodInfo(JavaClass.MAP, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", PUBLIC);
+	private static final JavaMethodInfo MAP_CONTAINS_KEY = new JavaMethodInfo(JavaClass.MAP, "containsKey", "(Ljava/lang/Object;)Z", PUBLIC);
+	private static final JavaMethodInfo MAP_SIZE = new JavaMethodInfo(JavaClass.MAP, "size", "()I", PUBLIC);
+	private static final JavaMethodInfo MAP_ISEMPTY = new JavaMethodInfo(JavaClass.MAP, "isEmpty", "()Z", PUBLIC);
+	private static final JavaMethodInfo MAP_KEYS = new JavaMethodInfo(JavaClass.MAP, "keys", "()Ljava/lang/Object;", PUBLIC);
+	private static final JavaMethodInfo MAP_VALUES = new JavaMethodInfo(JavaClass.MAP, "values", "()Ljava/lang/Object;", PUBLIC);
+	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_OBJECTS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([Ljava/lang/Object;II)[Ljava/lang/Object;", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_BOOLS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([ZII)[Z", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_BYTES = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([BII)[B", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_SHORTS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([SII)[S", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_INTS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([III)[I", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_LONGS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([JII)[J", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_FLOATS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([FII)[F", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_DOUBLES = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([DII)[D", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_CHARS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([CII)[C", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_EQUALS_OBJECTS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([Ljava/lang/Object[Ljava/lang/Object)Z", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_EQUALS_BOOLS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([Z[Z)Z", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_EQUALS_BYTES = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([B[B)Z", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_EQUALS_SHORTS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([S[S)Z", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_EQUALS_INTS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([I[I)Z", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_EQUALS_LONGS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([L[L)Z", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_EQUALS_FLOATS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([F[F)Z", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_EQUALS_DOUBLES = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([D[D)Z", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_EQUALS_CHARS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([C[C)Z", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_DEEPHASHCODE = new JavaMethodInfo(JavaClass.ARRAYS, "deepHashCode", "([Ljava/lang/Object;)", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_HASHCODE_BOOLS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([Z)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_HASHCODE_BYTES = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([B)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_HASHCODE_SHORTS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([S)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_HASHCODE_INTS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([I)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_HASHCODE_LONGS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([L)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_HASHCODE_FLOATS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([F)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_HASHCODE_DOUBLES = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([D)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo ARRAYS_HASHCODE_CHARS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([C)I", PUBLIC_STATIC);
+	private static final JavaMethodInfo OBJECT_HASHCODE = new JavaMethodInfo(JavaClass.OBJECT, "hashCode", "()I", PUBLIC);
+	private static final JavaMethodInfo COLLECTION_SIZE = new JavaMethodInfo(JavaClass.COLLECTION, "size", "()I", PUBLIC);
+	private static final JavaMethodInfo COLLECTION_TOARRAY = new JavaMethodInfo(JavaClass.COLLECTION, "toArray", "([Ljava/lang/Object;)[Ljava/lang/Object;", PUBLIC);
 
     private final JavaWriter javaWriter;
     private final JavaCapturedExpressionVisitor capturedExpressionVisitor = new JavaCapturedExpressionVisitor(this);
+	private final JavaContext context;
 
-    public JavaExpressionVisitor(JavaWriter javaWriter) {
+    public JavaExpressionVisitor(JavaContext context, JavaWriter javaWriter) {
         this.javaWriter = javaWriter;
-    }
-
-    private static Class<?> getForEquals(ITypeID id) {
-        if (CompilerUtils.isPrimitive(id))
-            return id.accept(JavaTypeClassVisitor.INSTANCE);
-        return Object.class;
+		this.context = context;
     }
 
     @Override
     @Override
     public Void visitArray(ArrayExpression expression) {
         javaWriter.constant(expression.expressions.length);
-        Type type = Type.getType(expression.type.accept(JavaTypeClassVisitor.INSTANCE).getComponentType());
+        Type type = context.getType(((ArrayTypeID)expression.type).elementType);
         javaWriter.newArray(type);
         for (int i = 0; i < expression.expressions.length; i++) {
             javaWriter.dup();
 				javaWriter.invokeVirtual(MAP_GET);
 
 				AssocTypeID type = (AssocTypeID) expression.target.type;
-				Type cls = type.valueType.accept(JavaTypeVisitor.INSTANCE);
-				javaWriter.checkCast(cls.getInternalName());
+				javaWriter.checkCast(context.getInternalName(type.valueType));
 				break;
 			}
 			case ASSOC_INDEXSET:
 				throw new UnsupportedOperationException("Not yet supported!");
 			case ARRAY_INDEXGET: {
 				ArrayTypeID type = (ArrayTypeID) expression.target.type;
-				javaWriter.arrayLoad(type.elementType.accept(JavaTypeVisitor.INSTANCE));
+				javaWriter.arrayLoad(context.getType(type.elementType));
 				break;
 			}
 			case ARRAY_INDEXSET: {
 				ArrayTypeID type = (ArrayTypeID) expression.target.type;
-				javaWriter.arrayStore(type.elementType.accept(JavaTypeVisitor.INSTANCE));
+				javaWriter.arrayStore(context.getType(type.elementType));
 				break;
 			}
 			case ARRAY_INDEXGETRANGE: {
 					}
 				} else {
 					javaWriter.invokeStatic(ARRAYS_COPY_OF_RANGE_OBJECTS);
-					javaWriter.checkCast("[" + type.elementType.accept(JavaTypeVisitor.INSTANCE).getDescriptor());
+					javaWriter.checkCast(context.getDescriptor(type));
 				}
 				break;
 			}
 			case FUNCTION_CALL:
 				javaWriter.invokeInterface(
 						new JavaMethodInfo(
-								JavaClass.fromInternalName(expression.target.type.accept(JavaTypeVisitor.INSTANCE).getInternalName(), JavaClass.Kind.INTERFACE),
+								JavaClass.fromInternalName(context.getInternalName(expression.target.type), JavaClass.Kind.INTERFACE),
 								"accept",
-								CompilerUtils.calcSign(expression.instancedHeader, false),
+								context.getMethodSignature(expression.instancedHeader),
 								Opcodes.ACC_PUBLIC));
 				break;
 			case AUTOOP_NOTEQUALS:
         javaWriter.pop();
         javaWriter.newObject(NullPointerException.class);
         javaWriter.dup();
-        javaWriter.constant("Tried to convert a null value to nonnull type " + expression.type.accept(JavaTypeClassVisitor.INSTANCE).getSimpleName());
+        javaWriter.constant("Tried to convert a null value to nonnull type " + context.getType(expression.type).getClassName());
         javaWriter.invokeSpecial(NullPointerException.class, "<init>", "(Ljava/lang/String;)V");
         javaWriter.aThrow();
         javaWriter.label(end);
 
     @Override
     public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
-        Type type = expression.objectType.accept(JavaTypeVisitor.INSTANCE);
-		try {
-			type.getInternalName();
-		} catch (NullPointerException ex) {
-			ex.printStackTrace();
-		}
-
         javaWriter.loadObject(0);
         if (javaWriter.method.javaClass.isEnum()) {
             javaWriter.loadObject(1);
         for (Expression argument : expression.arguments.arguments) {
             argument.accept(this);
         }
-		String internalName = type.getInternalName();
-        javaWriter.invokeSpecial(internalName, "<init>", CompilerUtils.calcDesc(expression.constructor.getHeader(), javaWriter.method.javaClass.isEnum()));
+		String internalName = context.getInternalName(expression.objectType);
+        javaWriter.invokeSpecial(internalName, "<init>", javaWriter.method.javaClass.isEnum()
+				? context.getEnumConstructorDescriptor(expression.constructor.getHeader())
+				: context.getMethodDescriptor(expression.constructor.getHeader()));
         return null;
     }
 
             argument.accept(this);
         }
         //No super calls in enums possible, and that's already handled in the enum constructor itself.
-        javaWriter.invokeSpecial(expression.objectType.accept(JavaTypeClassVisitor.INSTANCE), "<init>", CompilerUtils.calcDesc(expression.constructor.getHeader(), false));
-
-        CompilerUtils.writeDefaultFieldInitializers(javaWriter, javaWriter.forDefinition, false);
+        javaWriter.invokeSpecial(
+				context.getInternalName(expression.objectType),
+				"<init>",
+				context.getMethodDescriptor(expression.constructor.getHeader()));
+			
+        CompilerUtils.writeDefaultFieldInitializers(context, javaWriter, javaWriter.forDefinition, false);
         return null;
     }
 
     @Override
     public Void visitEnumConstant(EnumConstantExpression expression) {
-        final Type type = expression.type.accept(JavaTypeVisitor.INSTANCE);
-        javaWriter.getStaticField(type.getInternalName(), expression.value.name, type.getDescriptor());
+        javaWriter.getStaticField(context.getInternalName(expression.type), expression.value.name, context.getDescriptor(expression.type));
         return null;
     }
 
     @Override
     public Void visitFunction(FunctionExpression expression) {
-		CompilerUtils.tagMethodParameters(expression.header, false);
+		CompilerUtils.tagMethodParameters(context, expression.header, false);
 
         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 signature = CompilerUtils.calcSign(expression.header, false);
-        //final String name = CompilerUtils.getLambdaInterface(expression.header);
+        final String signature = context.getMethodSignature(expression.header);
 		final String name = CompilerUtils.getLambdaCounter();
 
         final JavaMethodInfo methodInfo = new JavaMethodInfo(javaWriter.method.javaClass, "accept", signature, Opcodes.ACC_PUBLIC);
 		final ClassWriter lambdaCW = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
-		lambdaCW.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, name, null, "java/lang/Object", new String[]{CompilerUtils.getLambdaInterface(expression.header)});
+		lambdaCW.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, name, null, "java/lang/Object", new String[]{JavaSynthesizedClassNamer.createFunctionName(new FunctionTypeID(null, expression.header)).cls.internalName});
 		final JavaWriter functionWriter = new JavaWriter(lambdaCW, methodInfo, null, signature, null, "java/lang/Override");
-
-
-
+		
 		javaWriter.newObject(name);
 		javaWriter.dup();
 
 		int i = 0;
 		for (CapturedExpression capture : expression.closure.captures) {
 			constructorWriter.dup();
-			final Type type = capture.type.accept(JavaTypeVisitor.INSTANCE);
+			Type type = context.getType(capture.type);
 			lambdaCW.visitField(Opcodes.ACC_FINAL | Opcodes.ACC_PRIVATE, "captured" + ++i, type.getDescriptor(), null, null).visitEnd();
-
+			
 			capture.accept(this);
 
 			constructorWriter.load(type, i);
 		constructorWriter.end();
 
 
-
         functionWriter.start();
 
 
-		final JavaStatementVisitor CSV = new JavaStatementVisitor(new JavaExpressionVisitor(functionWriter) {
-			//@Override
+		final JavaStatementVisitor CSV = new JavaStatementVisitor(context, new JavaExpressionVisitor(context, functionWriter) {
+			@Override
 			public Void visitGetLocalVariable(GetLocalVariableExpression varExpression) {
 				final int position = calculateMemberPosition(varExpression, expression) ;
 				if (position < 0)
 					throw new CompileException(varExpression.position, CompileExceptionCode.INTERNAL_ERROR, "Captured Statement error");
 				functionWriter.loadObject(0);
-				functionWriter.getField(name, "captured" + position, varExpression.variable.type.accept(JavaTypeVisitor.INSTANCE).getDescriptor());
+				functionWriter.getField(name, "captured" + position, context.getDescriptor(varExpression.variable.type));
 				return null;
 			}
 		});
-
-
+		
 		expression.body.accept(CSV);
-
-
+		
         functionWriter.ret();
-
-
-
 		functionWriter.end();
         lambdaCW.visitEnd();
 
 
     private String calcFunctionSignature(LambdaClosure closure) {
         StringJoiner joiner = new StringJoiner("", "(", ")V");
-
         for (CapturedExpression capture : closure.captures) {
-            String descriptor = capture.type.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+            String descriptor = context.getDescriptor(capture.type);
             joiner.add(descriptor);
         }
         return joiner.toString();
 			parameter = new JavaParameterInfo(1, Type.INT_TYPE);
 		}
 
-        javaWriter.load(expression.parameter.type.accept(JavaTypeVisitor.INSTANCE), parameter.index);
+        javaWriter.load(context.getType(expression.parameter.type), parameter.index);
         return null;
     }
 
 			case ASSOC_KEYS: {
 				AssocTypeID type = (AssocTypeID) expression.target.type;
 				ArrayTypeID result = new ArrayTypeID(null, type.keyType, 1);
-				Type resultType = result.accept(JavaTypeVisitor.INSTANCE);
+				Type resultType = context.getType(result);
 
 				javaWriter.invokeVirtual(MAP_KEYS);
 				javaWriter.dup();
 			case ASSOC_VALUES: {
 				AssocTypeID type = (AssocTypeID) expression.target.type;
 				ArrayTypeID result = new ArrayTypeID(null, type.valueType, 1);
-				Type resultType = result.accept(JavaTypeVisitor.INSTANCE);
+				Type resultType = context.getType(result);
 
 				javaWriter.invokeVirtual(MAP_VALUES);
 				javaWriter.dup();
     @Override
     public Void visitInterfaceCast(InterfaceCastExpression expression) {
         expression.value.accept(this);
-        javaWriter.checkCast(expression.type.accept(JavaTypeVisitor.INSTANCE));
+        javaWriter.checkCast(context.getDescriptor(expression.type));
         return null;
     }
 
     @Override
     public Void visitIs(IsExpression expression) {
         expression.value.accept(this);
-        javaWriter.instanceOf(expression.isType.accept(JavaTypeVisitor.INSTANCE));
+        javaWriter.instanceOf(context.getDescriptor(expression.isType));
         return null;
     }
 
 
     @Override
     public Void visitMap(MapExpression expression) {
-        javaWriter.newObject(expression.type.accept(JavaTypeClassVisitor.INSTANCE));
+        javaWriter.newObject("java/util/HashMap");
         javaWriter.dup();
-        javaWriter.invokeSpecial("java/util/Map", "<init>", "()V");
+        javaWriter.invokeSpecial("java/util/HashMap", "<init>", "()V");
         for (int i = 0; i < expression.keys.length; i++) {
             javaWriter.dup();
             expression.keys[i].accept(this);
         javaWriter.label(start);
         expression.value.accept(this);
         if (expression.value.type == BasicTypeID.STRING)
-            javaWriter.invokeVirtual(new JavaMethodInfo(OBJECT, "hashCode", "()I", 0));
+            javaWriter.invokeVirtual(new JavaMethodInfo(JavaClass.OBJECT, "hashCode", "()I", 0));
 
         final boolean hasNoDefault = hasNoDefault(expression);
 
 
     @Override
     public Void visitNew(NewExpression expression) {
+		// TODO: this code is incorrect!
+		
         final String type;
         if (expression.type instanceof DefinitionTypeID)
             type = ((DefinitionTypeID) expression.type).definition.name;
         else
-            type = Type.getDescriptor(expression.type.accept(JavaTypeClassVisitor.INSTANCE));
+            type = context.getDescriptor(expression.type);
 
         javaWriter.newObject(type);
         javaWriter.dup();
         StringBuilder signatureBuilder = new StringBuilder("(");
         for (Expression argument : expression.arguments.arguments) {
             argument.accept(this);
-            signatureBuilder.append(Type.getDescriptor(argument.type.accept(JavaTypeClassVisitor.INSTANCE)));
+            signatureBuilder.append(context.getDescriptor(argument.type));
         }
         signatureBuilder.append(")V");
         javaWriter.invokeSpecial(type, "<init>", signatureBuilder.toString());
 	@Override
 	public Void visitPostCall(PostCallExpression expression) {
 		expression.target.accept(this);
-		javaWriter.dup(expression.type.accept(new JavaTypeVisitor()));
+		javaWriter.dup(context.getType(expression.type));
         if (!checkAndExecuteByteCodeImplementation(expression.member) && !checkAndExecuteMethodInfo(expression.member))
             throw new IllegalStateException("Call target has no method info!");
 
     @Override
     public Void visitRange(RangeExpression expression) {
         // TODO: there are other kinds of ranges also; there should be a Range<T, T> type with creation of synthetic types
-        if (expression.from.type.accept(JavaTypeClassVisitor.INSTANCE) != int.class)
+        if (!context.getDescriptor(expression.from.type).equals("I"))
             throw new CompileException(expression.position, CompileExceptionCode.INTERNAL_ERROR, "Only integer ranges supported");
 
         javaWriter.newObject(IntRange.class);
     public Void visitSetFunctionParameter(SetFunctionParameterExpression expression) {
         expression.value.accept(this);
         JavaParameterInfo parameter = expression.parameter.getTag(JavaParameterInfo.class);
-        javaWriter.store(expression.type.accept(JavaTypeVisitor.INSTANCE), parameter.index);
+        javaWriter.store(context.getType(expression.type), parameter.index);
         return null;
     }
 
 
     //Will return true if a JavaFieldInfo.class tag exists, and will compile that tag
     public boolean checkAndPutFieldInfo(FieldMemberRef field, boolean isStatic) {
-		JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
+		JavaField fieldInfo = field.getTag(JavaField.class);
         if (fieldInfo == null)
             return false;
         //TODO Remove isStatic
     }
 
     public boolean checkAndGetFieldInfo(ConstMemberRef field, boolean isStatic) {
-        JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
+        JavaField fieldInfo = field.getTag(JavaField.class);
         if (fieldInfo == null)
             return false;
 
     }
 
     public boolean checkAndGetFieldInfo(FieldMemberRef field, boolean isStatic) {
-        JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
+        JavaField fieldInfo = field.getTag(JavaField.class);
         if (fieldInfo == null)
             return false;
 

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaOptionalTypeClassVisitor.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.compiler;
-
-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.ModifiedTypeID;
-import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
-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.ITypeVisitor;
-import org.openzen.zenscript.codemodel.type.IteratorTypeID;
-import org.openzen.zenscript.codemodel.type.RangeTypeID;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class JavaOptionalTypeClassVisitor implements ITypeVisitor<Class> {
-	private final JavaTypeClassVisitor base;
-	
-	public JavaOptionalTypeClassVisitor(JavaTypeClassVisitor base) {
-		this.base = base;
-	}
-
-	@Override
-	public Class visitBasic(BasicTypeID basic) {
-		switch (basic) {
-			case VOID:
-				return void.class;
-			case NULL:
-				return Object.class;
-			case BOOL:
-				return Boolean.class;
-			case BYTE:
-			case SBYTE:
-				return Byte.class;
-			case SHORT:
-			case USHORT:
-				return Short.class;
-			case INT:
-			case UINT:
-				return Integer.class;
-			case LONG:
-			case ULONG:
-				return Long.class;
-			case FLOAT:
-				return Float.class;
-			case DOUBLE:
-				return Double.class;
-			case CHAR:
-				return Character.class;
-			case STRING:
-				return String.class;
-			default:
-				throw new IllegalArgumentException("Invalid type: " + basic);
-		}
-	}
-
-	@Override
-	public Class visitArray(ArrayTypeID array) {
-		return base.visitArray(array);
-	}
-
-	@Override
-	public Class visitAssoc(AssocTypeID assoc) {
-		return base.visitAssoc(assoc);
-	}
-
-	@Override
-	public Class visitIterator(IteratorTypeID iterator) {
-		return base.visitIterator(iterator);
-	}
-
-	@Override
-	public Class visitFunction(FunctionTypeID function) {
-		return base.visitFunction(function);
-	}
-
-	@Override
-	public Class visitDefinition(DefinitionTypeID definition) {
-		return base.visitDefinition(definition);
-	}
-
-	@Override
-	public Class visitGeneric(GenericTypeID generic) {
-		return base.visitGeneric(generic);
-	}
-
-	@Override
-	public Class visitRange(RangeTypeID range) {
-		return base.visitRange(range);
-	}
-
-	@Override
-	public Class visitModified(ModifiedTypeID type) {
-		return base.visitModified(type);
-	}
-
-	@Override
-	public Class visitGenericMap(GenericMapTypeID map) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-	}
-}

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

 import org.openzen.zenscript.codemodel.expression.TryRethrowAsResultExpression;
 import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
+import org.openzen.zenscript.javabytecode.JavaContext;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 import org.openzen.zenscript.javabytecode.JavaParameterInfo;
 
 public class JavaPreDecrementVisitor implements ExpressionVisitor<Void> {
 	private final JavaExpressionVisitor expressionCompiler;
 	private final JavaWriter javaWriter;
+	private final JavaContext context;
 	
-	public JavaPreDecrementVisitor(JavaExpressionVisitor expressionCompiler) {
+	public JavaPreDecrementVisitor(JavaContext context, JavaExpressionVisitor expressionCompiler) {
 		this.expressionCompiler = expressionCompiler;
+		this.context = context;
 		javaWriter = expressionCompiler.getJavaWriter();
 	}
 
 
 	@Override
 	public Void visitGetField(GetFieldExpression expression) {
-		Type objectType = expression.target.type.accept(new JavaTypeVisitor());
+		Type objectType = context.getType(expression.target.type);
 		
 		int local = javaWriter.local(objectType);
 		expression.target.accept(expressionCompiler);

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

 import org.openzen.zenscript.codemodel.expression.TryRethrowAsResultExpression;
 import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
+import org.openzen.zenscript.javabytecode.JavaContext;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 import org.openzen.zenscript.javabytecode.JavaParameterInfo;
 
  */
 public class JavaPreIncrementVisitor implements ExpressionVisitor<Void> {
 	private final JavaExpressionVisitor expressionCompiler;
+	private final JavaContext context;
 	private final JavaWriter javaWriter;
 	
-	public JavaPreIncrementVisitor(JavaExpressionVisitor expressionCompiler) {
+	public JavaPreIncrementVisitor(JavaContext context, JavaExpressionVisitor expressionCompiler) {
 		this.expressionCompiler = expressionCompiler;
+		this.context = context;
 		javaWriter = expressionCompiler.getJavaWriter();
 	}
 
 
 	@Override
 	public Void visitGetField(GetFieldExpression expression) {
-		Type objectType = expression.target.type.accept(new JavaTypeVisitor());
+		Type objectType = context.getType(expression.target.type);
 		
 		int local = javaWriter.local(objectType);
 		expression.target.accept(expressionCompiler);

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

 
 import java.util.Arrays;
 import java.util.List;
+import org.openzen.zenscript.javabytecode.JavaContext;
 import org.openzen.zenscript.javashared.JavaClass;
 
 public class JavaStatementVisitor implements StatementVisitor<Boolean> {
     private final JavaWriter javaWriter;
+	private final JavaContext context;
     public JavaExpressionVisitor expressionVisitor;
 
     /**
      * @param javaWriter the method writer that compiles the statement
      */
-    public JavaStatementVisitor(JavaWriter javaWriter) {
+    public JavaStatementVisitor(JavaContext context, JavaWriter javaWriter) {
         this.javaWriter = javaWriter;
-        this.expressionVisitor = new JavaExpressionVisitor(javaWriter);
+		this.context = context;
+        this.expressionVisitor = new JavaExpressionVisitor(context, javaWriter);
     }
 
-    public JavaStatementVisitor(JavaExpressionVisitor expressionVisitor) {
+    public JavaStatementVisitor(JavaContext context, JavaExpressionVisitor expressionVisitor) {
         this.javaWriter = expressionVisitor.getJavaWriter();
+		this.context = context;
         this.expressionVisitor = expressionVisitor;
     }
 
 
         //Create local variables
         for (VarStatement variable : statement.loopVariables) {
-            final Type type = Type.getType(variable.type.accept(JavaTypeClassVisitor.INSTANCE));
+            final Type type = context.getType(variable.type);
             final Label variableStart = new Label();
             final JavaLocalVariableInfo info = new JavaLocalVariableInfo(type, javaWriter.local(type), variableStart, variable.name);
             info.end = end;
     @Override
     public Boolean visitReturn(ReturnStatement statement) {
         statement.value.accept(expressionVisitor);
-        javaWriter.returnType(Type.getType(statement.value.type.accept(JavaTypeClassVisitor.INSTANCE)));
+        javaWriter.returnType(context.getType(statement.value.type));
         return true;
     }
 
             javaWriter.label(catchStart);
 
             //final Type exceptionType = Type.getType(RuntimeException.class);
-            final Type exceptionType = Type.getType(catchClause.exceptionVariable.type.accept(JavaTypeClassVisitor.INSTANCE));
+            final Type exceptionType = context.getType(catchClause.exceptionVariable.type);
             final int local = javaWriter.local(exceptionType);
             javaWriter.store(exceptionType, local);
 
             statement.initializer.accept(expressionVisitor);
         }
 
-        Type type = statement.type.accept(JavaTypeVisitor.INSTANCE);
+        Type type = context.getType(statement.type);
         int local = javaWriter.local(type);
         if (statement.initializer != null)
             javaWriter.store(type, local);

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

-package org.openzen.zenscript.javabytecode.compiler;
-
-import org.openzen.zenscript.codemodel.type.*;
-import org.openzen.zenscript.javabytecode.JavaModule;
-
-import java.lang.reflect.Array;
-import java.util.Iterator;
-import java.util.Map;
-
-public class JavaTypeClassVisitor implements ITypeVisitor<Class> {
-
-    public static final JavaTypeClassVisitor INSTANCE = new JavaTypeClassVisitor();
-	private final JavaOptionalTypeClassVisitor optional = new JavaOptionalTypeClassVisitor(this);
-
-    @Override
-    public Class visitBasic(BasicTypeID basic) {
-        switch (basic) {
-            case VOID:
-                return void.class;
-            case NULL:
-            case UNDETERMINED:
-                return Object.class;
-            case BOOL:
-                return boolean.class;
-            case BYTE:
-            case SBYTE:
-                return byte.class;
-            case SHORT:
-            case USHORT:
-                return short.class;
-            case INT:
-            case UINT:
-                return int.class;
-            case LONG:
-            case ULONG:
-                return long.class;
-            case FLOAT:
-                return float.class;
-            case DOUBLE:
-                return double.class;
-            case CHAR:
-                return char.class;
-            case STRING:
-                return String.class;
-        }
-        return Object.class;
-    }
-
-    @Override
-    public Class visitArray(ArrayTypeID array) {
-        return Array.newInstance(array.elementType.accept(this), 0).getClass();
-    }
-
-    @Override
-    public Class visitAssoc(AssocTypeID assoc) {
-        return Map.class;
-    }
-
-    @Override
-    public Class visitIterator(IteratorTypeID iterator) {
-        return Iterator.class;
-    }
-
-    @Override
-    public Class visitFunction(FunctionTypeID function) {
-        try {
-            return new JavaModule().new ScriptClassLoader().loadClass(CompilerUtils.getLambdaInterface(function.header));
-        } catch (ClassNotFoundException e) {
-            return null;
-        }
-        //return function.header.returnType.accept(this);
-    }
-
-    @Override
-    public Class visitDefinition(DefinitionTypeID definition) {
-        return null;
-    }
-
-    @Override
-    public Class visitGeneric(GenericTypeID generic) {
-        return null;
-    }
-
-    @Override
-    public Class visitRange(RangeTypeID range) {
-        return null;
-    }
-
-    @Override
-    public Class visitModified(ModifiedTypeID modified) {
-        return modified.baseType.accept(this.optional);
-    }
-
-	@Override
-	public Class visitGenericMap(GenericMapTypeID map) {
-		return Map.class;
-	}
-}

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

-package org.openzen.zenscript.javabytecode.compiler;
-
-import java.util.Map;
-import org.objectweb.asm.Type;
-import org.openzen.zenscript.codemodel.type.*;
-
-public class JavaTypeVisitor implements ITypeVisitor<Type> {
-    public static final JavaTypeVisitor INSTANCE = new JavaTypeVisitor();
-
-    @Override
-    public Type visitBasic(BasicTypeID basic) {
-        return Type.getType(basic.accept(JavaTypeClassVisitor.INSTANCE));
-    }
-
-    @Override
-    public Type visitArray(ArrayTypeID array) {
-        return Type.getType(array.accept(JavaTypeClassVisitor.INSTANCE));
-    }
-
-    @Override
-    public Type visitAssoc(AssocTypeID assoc) {
-        return Type.getType(assoc.accept(JavaTypeClassVisitor.INSTANCE));
-    }
-
-    @Override
-    public Type visitIterator(IteratorTypeID iterator) {
-        return Type.getType(iterator.accept(JavaTypeClassVisitor.INSTANCE));
-    }
-
-    @Override
-    public Type visitFunction(FunctionTypeID function) {
-        Class clazz = function.accept(JavaTypeClassVisitor.INSTANCE);
-        return clazz != null ? Type.getType(clazz) : Type.getType("L" + CompilerUtils.getLambdaInterface(function.header) + ";");
-    }
-
-    @Override
-    public Type visitDefinition(DefinitionTypeID definition) {
-        return Type.getType("L" + definition + ";");
-    }
-
-    @Override
-    public Type visitGeneric(GenericTypeID generic) {
-        return Type.getType(generic.accept(JavaTypeClassVisitor.INSTANCE));
-    }
-
-    @Override
-    public Type visitRange(RangeTypeID range) {
-        return Type.getType(range.accept(JavaTypeClassVisitor.INSTANCE));
-    }
-
-    @Override
-    public Type visitModified(ModifiedTypeID optional) {
-        return Type.getType(optional.accept(JavaTypeClassVisitor.INSTANCE));
-    }
-
-	@Override
-	public Type visitGenericMap(GenericMapTypeID map) {
-		return Type.getType(Map.class);
-	}
-}

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.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;
+import org.openzen.zenscript.javashared.JavaField;
 
 public class JavaWriter {
     private static final JavaMethodInfo STRING_CONCAT = new JavaMethodInfo(
         visitor.visitTypeInsn(CHECKCAST, signature(newClass));
     }
 
-    public void checkCast(String newClass) {
+    public void checkCast(String descriptor) {
         if (debug)
-            System.out.println("checkCast " + newClass);
+            System.out.println("checkCast " + descriptor);
 
-        visitor.visitTypeInsn(CHECKCAST, newClass);
+        visitor.visitTypeInsn(CHECKCAST, descriptor);
     }
 
     public void checkCast(Type type) {
         visitor.visitInsn(DCMPL);
     }
 
-    public void instanceOf(String clsName) {
+    public void instanceOf(String descriptor) {
         if (debug)
-            System.out.println("instanceOf " + clsName);
+            System.out.println("instanceOf " + descriptor);
 
-        visitor.visitTypeInsn(INSTANCEOF, clsName);
+        visitor.visitTypeInsn(INSTANCEOF, descriptor);
     }
 
     public void instanceOf(Type type) {
 				false);
 	}
 
-    public void invokeSpecial(String owner, String name, String descriptor) {
+    public void invokeSpecial(String ownerInternalName, String name, String descriptor) {
         if (debug)
-            System.out.println("invokeSpecial " + owner + '.' + name + descriptor);
+            System.out.println("invokeSpecial " + ownerInternalName + '.' + name + descriptor);
 
-        visitor.visitMethodInsn(INVOKESPECIAL, owner, name, descriptor, false);
+        visitor.visitMethodInsn(INVOKESPECIAL, ownerInternalName, name, descriptor, false);
     }
 
     public void invokeSpecial(Class owner, String name, String descriptor) {
         visitor.visitTypeInsn(NEW, internal(type));
     }
 
-    public void newObject(String type) {
+    public void newObject(String internalName) {
         if (debug)
-            System.out.println("newObject " + type);
+            System.out.println("newObject " + internalName);
 
-        visitor.visitTypeInsn(NEW, type);
+        visitor.visitTypeInsn(NEW, internalName);
     }
 
     public void construct(Class type, Class... arguments) {
         visitor.visitFieldInsn(GETFIELD, internal(owner), name, signature(descriptor));
     }
 	
-	public void getField(JavaFieldInfo field) {
+	public void getField(JavaField field) {
         if (debug)
-            System.out.println("getField " + field.javaClass.internalName + '.' + field.name + ":" + field.signature);
+            System.out.println("getField " + field.cls.internalName + '.' + field.name + ":" + field.signature);
 		
-		visitor.visitFieldInsn(GETFIELD, field.javaClass.internalName, field.name, field.signature);
+		visitor.visitFieldInsn(GETFIELD, field.cls.internalName, field.name, field.signature);
 	}
 
     public void putField(String owner, String name, String descriptor) {
         visitor.visitFieldInsn(PUTFIELD, internal(owner), name, signature(descriptor));
     }
 	
-	public void putField(JavaFieldInfo field) {
+	public void putField(JavaField field) {
         if (debug)
-            System.out.println("putField " + field.javaClass.internalName + '.' + field.name + ":" + field.signature);
+            System.out.println("putField " + field.cls.internalName + '.' + field.name + ":" + field.signature);
 		
-		visitor.visitFieldInsn(PUTFIELD, field.javaClass.internalName, field.name, field.signature);
+		visitor.visitFieldInsn(PUTFIELD, field.cls.internalName, field.name, field.signature);
 	}
 
     public void getStaticField(String owner, String name, String descriptor) {
         visitor.visitFieldInsn(GETSTATIC, owner, name, descriptor);
     }
 	
-	public void getStaticField(JavaFieldInfo field) {
+	public void getStaticField(JavaField field) {
         if (debug)
-            System.out.println("getStaticField " + field.javaClass.internalName + '.' + field.name + ":" + field.signature);
+            System.out.println("getStaticField " + field.cls.internalName + '.' + field.name + ":" + field.signature);
 		
-		visitor.visitFieldInsn(GETSTATIC, field.javaClass.internalName, field.name, field.signature);
+		visitor.visitFieldInsn(GETSTATIC, field.cls.internalName, field.name, field.signature);
 	}
 
     public void putStaticField(String owner, String name, String descriptor) {
         visitor.visitFieldInsn(PUTSTATIC, internal(owner), field.getName(), signature(field.getType()));
     }
 	
-	public void putStaticField(JavaFieldInfo field) {
+	public void putStaticField(JavaField field) {
         if (debug)
-            System.out.println("putStaticField " + field.javaClass.internalName + '.' + field.name + ":" + field.signature);
+            System.out.println("putStaticField " + field.cls.internalName + '.' + field.name + ":" + field.signature);
 		
-		visitor.visitFieldInsn(PUTSTATIC, field.javaClass.internalName, field.name, field.signature);
+		visitor.visitFieldInsn(PUTSTATIC, field.cls.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.JavaContext;
 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 JavaMethodInfo CLASS_FORNAME = new JavaMethodInfo(
 			JavaClass.CLASS,
 			Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
 
     private final JavaClassWriter outerWriter;
+	private final JavaContext context;
 
-    public JavaDefinitionVisitor(JavaClassWriter outerWriter) {
-
+    public JavaDefinitionVisitor(JavaContext context, JavaClassWriter outerWriter) {
+		this.context = context;
         this.outerWriter = outerWriter;
     }
 
         if (definition.getSuperType() == null)
             superType = Type.getType(Object.class);
         else
-            superType = Type.getType(definition.getSuperType().accept(JavaTypeClassVisitor.INSTANCE));
+            superType = context.getType(definition.getSuperType());
 
 		JavaClass toClass = new JavaClass(definition.pkg.fullName, definition.name, JavaClass.Kind.CLASS);
         JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
         String signature = null;
 		
         writer.visit(Opcodes.V1_8, definition.modifiers, definition.name, signature, superType.getInternalName(), null);
-		JavaMemberVisitor memberVisitor = new JavaMemberVisitor(writer, toClass, definition); 
+		JavaMemberVisitor memberVisitor = new JavaMemberVisitor(context, writer, toClass, definition); 
         for (IDefinitionMember member : definition.members) {
             member.accept(memberVisitor);
         }
         //TODO: Extending Interfaces?
         String signature = null;
         writer.visit(Opcodes.V1_8, definition.modifiers | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT, definition.name, signature, Type.getInternalName(Object.class), null);
-		JavaMemberVisitor memberVisitor = new JavaMemberVisitor(writer, toClass, definition);
+		JavaMemberVisitor memberVisitor = new JavaMemberVisitor(context, writer, toClass, definition);
         for (IDefinitionMember member : definition.members) {
             member.accept(memberVisitor);
         }
         if (definition.getSuperType() == null)
             superType = Type.getType(Object.class);
         else
-            superType = Type.getType(definition.getSuperType().accept(JavaTypeClassVisitor.INSTANCE));
+            superType = context.getType(definition.getSuperType());
 
         ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
 
         //Enum Stuff(required!)
         writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC, "$VALUES", "[L" + definition.name + ";", null, null).visitEnd();
 
-        final JavaMemberVisitor visitor = new JavaMemberVisitor(writer, toClass, definition);
+        final JavaMemberVisitor visitor = new JavaMemberVisitor(context, writer, toClass, definition);
         for (IDefinitionMember member : definition.members) {
             member.accept(visitor);
         }
 
     @Override
     public byte[] visitFunction(FunctionDefinition definition) {
-		CompilerUtils.tagMethodParameters(definition.header, true);
+		CompilerUtils.tagMethodParameters(context, definition.header, true);
 		
-        final String signature = CompilerUtils.calcSign(definition.header, false);
+        final String signature = context.getMethodSignature(definition.header);
 		
 		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 JavaMethodInfo methodInfo = new JavaMethodInfo(toClass, definition.name, context.getMethodDescriptor(definition.header), CompilerUtils.calcAccess(definition.modifiers) | Opcodes.ACC_STATIC);
 
 		final JavaWriter writer = new JavaWriter(outerWriter, true, methodInfo, definition, signature, null);
-        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(writer);
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, writer);
         statementVisitor.start();
 		boolean returns = definition.statement.accept(statementVisitor);
 		if (!returns) {
 				writer.iConst0();
 			else if (type != BasicTypeID.VOID)
 				writer.aConstNull();
-			writer.returnType(type.accept(JavaTypeVisitor.INSTANCE));
+			writer.returnType(context.getType(type));
         }
 
         statementVisitor.end();

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.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.javabytecode.JavaContext;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaField;
 
 public class JavaMemberVisitor implements MemberVisitor<Void> {
     private final ClassWriter writer;
+	private final JavaContext context;
     private final JavaClass toClass;
     private final HighLevelDefinition definition;
     private final JavaStatementVisitor clinitStatementVisitor;
     private EnumDefinition enumDefinition = null;
 
-    public JavaMemberVisitor(ClassWriter writer, JavaClass toClass, HighLevelDefinition definition) {
+    public JavaMemberVisitor(JavaContext context, ClassWriter writer, JavaClass toClass, HighLevelDefinition definition) {
         this.writer = writer;
         this.toClass = toClass;
         this.definition = definition;
+		this.context = context;
 
         final JavaWriter javaWriter = new JavaWriter(writer, new JavaMethodInfo(toClass, "<clinit>", "()V", 0), definition, null, null);
-        this.clinitStatementVisitor = new JavaStatementVisitor(javaWriter);
+        this.clinitStatementVisitor = new JavaStatementVisitor(context, javaWriter);
         this.clinitStatementVisitor.start();
-        CompilerUtils.writeDefaultFieldInitializers(javaWriter, definition, true);
+        CompilerUtils.writeDefaultFieldInitializers(context, javaWriter, definition, true);
     }
 	
 	@Override
 	public Void visitConst(ConstMember member) {
         //TODO calc signature
         String signature = null;
-        final String descriptor = Type.getDescriptor(member.type.accept(JavaTypeClassVisitor.INSTANCE));
+        final String descriptor = context.getDescriptor(member.type);
         writer.visitField(CompilerUtils.calcAccess(member.modifiers), member.name, descriptor, signature, null).visitEnd();
-        member.setTag(JavaFieldInfo.class, new JavaFieldInfo(toClass, member.name, descriptor));
+        member.setTag(JavaField.class, new JavaField(toClass, member.name, descriptor));
         return null;
 	}
 
 
         //TODO calc signature
         String signature = null;
-        final String descriptor = Type.getDescriptor(member.type.accept(JavaTypeClassVisitor.INSTANCE));
+        final String descriptor = context.getDescriptor(member.type);
         writer.visitField(CompilerUtils.calcAccess(member.modifiers), member.name, descriptor, signature, null).visitEnd();
-        member.setTag(JavaFieldInfo.class, new JavaFieldInfo(toClass, member.name, descriptor));
+        member.setTag(JavaField.class, new JavaField(toClass, member.name, descriptor));
         return null;
     }
 
     @Override
     public Void visitConstructor(ConstructorMember member) {
         final boolean isEnum = definition instanceof EnumDefinition;
-        String descriptor = CompilerUtils.calcDesc(member.header, isEnum);
+        String descriptor = isEnum ? context.getEnumConstructorDescriptor(member.header) : context.getMethodDescriptor(member.header);
         final JavaMethodInfo method = new JavaMethodInfo(toClass, "<init>", descriptor, isEnum ? Opcodes.ACC_PRIVATE : CompilerUtils.calcAccess(member.modifiers));
 
         final Label constructorStart = new Label();
         final Label constructorEnd = new Label();
-        final JavaWriter constructorWriter = new JavaWriter(writer, method, definition, CompilerUtils.calcSign(member.header, isEnum), null);
+        final JavaWriter constructorWriter = new JavaWriter(writer, method, definition, context.getMethodSignature(member.header), null);
         constructorWriter.label(constructorStart);
-        CompilerUtils.tagConstructorParameters(member.header, isEnum);
+        CompilerUtils.tagConstructorParameters(context, member.header, isEnum);
         for (FunctionParameter parameter : member.header.parameters) {
             constructorWriter.nameVariable(
                     parameter.getTag(JavaParameterInfo.class).index,
                     parameter.name,
                     constructorStart,
                     constructorEnd,
-                    Type.getType(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
+                    context.getType(parameter.type));
         }
 
-        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(constructorWriter);
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, constructorWriter);
         statementVisitor.start();
 
         if (!member.isConstructorForwarded()) {
                 constructorWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
             }
 
-            CompilerUtils.writeDefaultFieldInitializers(constructorWriter, definition, false);
+            CompilerUtils.writeDefaultFieldInitializers(context, constructorWriter, definition, false);
         }
 
         member.body.accept(statementVisitor);
         final JavaWriter destructorWriter = new JavaWriter(writer, method, definition, null, null);
         destructorWriter.label(constructorStart);
 
-        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(destructorWriter);
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, 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(member.header, member.isStatic());
+        CompilerUtils.tagMethodParameters(context, member.header, member.isStatic());
 
         final boolean isAbstract = member.body == null || Modifiers.isAbstract(member.modifiers);
         int modifiers = (isAbstract ? Opcodes.ACC_ABSTRACT : 0)
         final JavaMethodInfo method = new JavaMethodInfo(
                 toClass,
                 member.name,
-                CompilerUtils.calcSign(member.header, false),
+                context.getMethodSignature(member.header),
                 modifiers);
 
         final Label methodStart = new Label();
         final Label methodEnd = new Label();
-        final JavaWriter methodWriter = new JavaWriter(writer, method, definition, CompilerUtils.calcSign(member.header, false), null);
+        final JavaWriter methodWriter = new JavaWriter(writer, method, definition, context.getMethodSignature(member.header), null);
         methodWriter.label(methodStart);
         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, Type.getType(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
+                methodWriter.nameVariable(parameter.getTag(JavaParameterInfo.class).index, parameter.name, methodStart, methodEnd, context.getType(parameter.type));
         }
 
-        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(methodWriter);
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, methodWriter);
 
         if (!isAbstract) {
             statementVisitor.start();
         if (enumDefinition != null) {
 			for (EnumConstantMember constant : enumDefinition.enumConstants) {
 				writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_ENUM, constant.name, "L" + definition.name + ";", null, null).visitEnd();
-				final String internalName = constant.constructor.type.accept(JavaTypeVisitor.INSTANCE).getInternalName();
+				final String internalName = context.getInternalName(constant.constructor.type);
 				final JavaWriter clinitWriter = clinitStatementVisitor.getJavaWriter();
 				clinitWriter.newObject(internalName);
 				clinitWriter.dup();
 					argument.accept(clinitStatementVisitor.expressionVisitor);
 				}
 
-				clinitWriter.invokeSpecial(internalName, "<init>", CompilerUtils.calcDesc(constant.constructor.constructor.getHeader(), true));
+				clinitWriter.invokeSpecial(internalName, "<init>", context.getEnumConstructorDescriptor(constant.constructor.constructor.getHeader()));
 				clinitWriter.putStaticField(internalName, constant.name, "L" + internalName + ";");
 				
 				enumDefinition = (EnumDefinition) constant.definition;

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

 	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 final JavaClass ARRAYS = new JavaClass("java.util", "Arrays", Kind.CLASS);
+	
+	public static final JavaClass BOOLEAN = new JavaClass("java.lang", "Boolean", Kind.CLASS);
+	public static final JavaClass BYTE = new JavaClass("java.lang", "Byte", Kind.CLASS);
+	public static final JavaClass SHORT = new JavaClass("java.lang", "Short", Kind.CLASS);
+	public static final JavaClass INTEGER = new JavaClass("java.lang", "Integer", Kind.CLASS);
+	public static final JavaClass LONG = new JavaClass("java.lang", "Long", Kind.CLASS);
+	public static final JavaClass FLOAT = new JavaClass("java.lang", "Float", Kind.CLASS);
+	public static final JavaClass DOUBLE = new JavaClass("java.lang", "Double", Kind.CLASS);
+	public static final JavaClass CHARACTER = new JavaClass("java.lang", "Character", Kind.CLASS);
+	public static final JavaClass COLLECTION = new JavaClass("java.util", "Collection", Kind.INTERFACE);
 	
 	public static JavaClass fromInternalName(String internalName, Kind kind) {
 		if (kind == Kind.ARRAY)
 	
 	public boolean empty = false;
 	public boolean destructible = false;
+	public boolean membersPrepared = false;
 	
 	private final String[] classNameParts;
 	

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/tags/JavaSourceField.java → JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaField.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.javasource.tags;
-
-import org.openzen.zenscript.javashared.JavaClass;
+package org.openzen.zenscript.javashared;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class JavaSourceField {
+public class JavaField {
 	public final JavaClass cls;
 	public final String name;
+	public final String signature;
 	
-	public JavaSourceField(JavaClass cls, String name) {
+	public JavaField(JavaClass cls, String name, String signature) {
 		this.cls = cls;
 		this.name = name;
+		this.signature = signature;
 	}
 }

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSynthesizedClass.java → JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaSynthesizedClass.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.javasource;
+package org.openzen.zenscript.javashared;
 
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.javashared.JavaClass;
 
 /**
  *

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaSynthesizedClassNamer.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.ArrayList;
+import java.util.List;
+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.codemodel.type.RangeTypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSynthesizedClassNamer {
+	private JavaSynthesizedClassNamer() {}
+	
+	public static JavaSynthesizedClass createFunctionName(FunctionTypeID function) {
+		String signature = getFunctionSignature(function);
+		
+		String className = "Function" + signature;
+		JavaClass cls = new JavaClass("zsynthetic", className, JavaClass.Kind.INTERFACE);
+		return new JavaSynthesizedClass(cls, extractTypeParameters(function));
+	}
+	
+	public static JavaSynthesizedClass createRangeName(RangeTypeID range) {
+		String signature = getRangeSignature(range);
+		String className = signature + "Range";
+		JavaClass cls = new JavaClass("zsynthetic", className, JavaClass.Kind.CLASS);
+		return new JavaSynthesizedClass(cls, extractTypeParameters(range));
+	}
+	
+	public static TypeParameter[] extractTypeParameters(ITypeID type) {
+		List<TypeParameter> result = new ArrayList<>();
+		type.extractTypeParameters(result);
+		return result.toArray(new TypeParameter[result.size()]);
+	}
+	
+	public static String getFunctionSignature(FunctionTypeID type) {
+		return new JavaSyntheticTypeSignatureConverter().visitFunction(type);
+	}
+	
+	public static String getRangeSignature(RangeTypeID type) {
+		return new JavaSyntheticTypeSignatureConverter().visitRange(type);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javashared;
+
+import org.openzen.zenscript.codemodel.type.FunctionTypeID;
+import org.openzen.zenscript.codemodel.type.RangeTypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface JavaSyntheticClassGenerator {
+	JavaSynthesizedClass synthesizeFunction(FunctionTypeID type);
+	
+	JavaSynthesizedClass synthesizeRange(RangeTypeID type);
+}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSyntheticTypeSignatureConverter.java → JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaSyntheticTypeSignatureConverter.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.javasource;
+package org.openzen.zenscript.javashared;
 
 import java.util.ArrayList;
 import java.util.HashMap;
 	private static final String[] typeParameterNames = {"T", "U", "V", "W", "X", "Y", "Z"}; // if we have more than this, make it Tx with x the number
 	private final Map<TypeParameter, String> typeParameters = new HashMap<>();
 	public final List<TypeParameter> typeParameterList = new ArrayList<>();
-
+	
 	@Override
 	public String visitBasic(BasicTypeID basic) {
 		switch (basic) {

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

+package org.openzen.zenscript.javashared;
+
+import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
+import org.openzen.zenscript.codemodel.type.*;
+
+public class JavaTypeDescriptorVisitor implements ITypeVisitor<String> {
+	private final JavaTypeDescriptorVisitor forOptional;
+	private final boolean optional;
+	
+	public JavaTypeDescriptorVisitor(JavaSyntheticClassGenerator generator) {
+		this(generator, false);
+	}
+	
+	private JavaTypeDescriptorVisitor(JavaSyntheticClassGenerator generator, boolean optional) {
+		this.optional = optional;
+		forOptional = optional ? this : new JavaTypeDescriptorVisitor(generator, true);
+	}
+	
+    @Override
+    public String visitBasic(BasicTypeID basic) {
+		if (optional) {
+			switch (basic) {
+				case BOOL: return "Ljava/lang/Boolean;";
+				case CHAR: return "Ljava/lang/Character;";
+				case BYTE: return "Ljava/lang/Integer;";
+				case SBYTE: return "Ljava/lang/Byte;";
+				case SHORT: return "Ljava/lang/Short;";
+				case USHORT: return "Ljava/lang/Integer;";
+				case INT: return "Ljava/lang/Integer;";
+				case UINT: return "Ljava/lang/Integer;";
+				case LONG: return "Ljava/lang/Long;";
+				case ULONG: return "Ljava/lang/Long;";
+				case FLOAT: return "Ljava/lang/Float;";
+				case DOUBLE: return "Ljava/lang/Double;";
+				case STRING: return "Ljava/lang/String;";
+				default:
+					throw new IllegalArgumentException("Not a valid type: " + basic);
+			}
+		} else {
+			switch (basic) {
+				case VOID: return "V";
+				case BOOL: return "Z";
+				case CHAR: return "C";
+				case BYTE: return "I";
+				case SBYTE: return "B";
+				case SHORT: return "S";
+				case USHORT: return "I";
+				case INT: return "I";
+				case UINT: return "I";
+				case LONG: return "J";
+				case ULONG: return "J";
+				case FLOAT: return "F";
+				case DOUBLE: return "D";
+				case STRING: return "Ljava/lang/String;";
+				default:
+					throw new IllegalArgumentException("Not a valid type: " + basic);
+			}
+		}
+    }
+
+    @Override
+    public String visitArray(ArrayTypeID array) {
+		return "[" + array.elementType.accept(this);
+    }
+
+    @Override
+    public String visitAssoc(AssocTypeID assoc) {
+		return "Ljava/util/Map;";
+    }
+
+    @Override
+    public String visitIterator(IteratorTypeID iterator) {
+		return "Ljava/lang/Iterator;";
+    }
+
+    @Override
+    public String visitFunction(FunctionTypeID function) {
+        return "L" + JavaSynthesizedClassNamer.createFunctionName(function).cls.internalName + ";";
+    }
+
+    @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);
+		
+		return "L" + cls.internalName + ";";
+    }
+
+    @Override
+    public String visitGeneric(GenericTypeID generic) {
+		for (GenericParameterBound bound : generic.parameter.bounds) {
+			if (bound instanceof ParameterTypeBound) {
+				return ((ParameterTypeBound) bound).type.accept(this);
+			}
+		}
+		
+		return "Ljava/lang/Object;";
+    }
+
+    @Override
+    public String visitRange(RangeTypeID range) {
+		return "L" + JavaSynthesizedClassNamer.createRangeName(range).cls.internalName + ";";
+    }
+
+    @Override
+    public String visitModified(ModifiedTypeID modified) {
+		if (modified.isOptional())
+			return modified.withoutOptional().accept(forOptional);
+		
+		return modified.baseType.accept(this);
+    }
+
+	@Override
+	public String visitGenericMap(GenericMapTypeID map) {
+		return "Ljava/util/Map;";
+	}
+}

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

+package org.openzen.zenscript.javashared;
+
+import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
+import org.openzen.zenscript.codemodel.type.*;
+
+public class JavaTypeInternalNameVisitor implements ITypeVisitor<String> {
+	private final JavaTypeInternalNameVisitor forOptional;
+	private final boolean optional;
+	
+	public JavaTypeInternalNameVisitor(JavaSyntheticClassGenerator generator) {
+		this(generator, false);
+	}
+	
+	private JavaTypeInternalNameVisitor(JavaSyntheticClassGenerator generator, boolean optional) {
+		this.optional = optional;
+		forOptional = optional ? this : new JavaTypeInternalNameVisitor(generator, true);
+	}
+	
+    @Override
+    public String visitBasic(BasicTypeID basic) {
+		if (optional) {
+			switch (basic) {
+				case BOOL: return "java/lang/Boolean";
+				case CHAR: return "java/lang/Character";
+				case BYTE: return "java/lang/Integer";
+				case SBYTE: return "java/lang/Byte";
+				case SHORT: return "java/lang/Short";
+				case USHORT: return "java/lang/Integer";
+				case INT: return "java/lang/Integer";
+				case UINT: return "java/lang/Integer";
+				case LONG: return "java/lang/Long";
+				case ULONG: return "java/lang/Long";
+				case FLOAT: return "java/lang/Float";
+				case DOUBLE: return "java/lang/Double";
+				case STRING: return "java/lang/String";
+				default:
+					throw new IllegalArgumentException("Not a valid type: " + basic);
+			}
+		} else {
+			switch (basic) {
+				case VOID: return "V";
+				case BOOL: return "Z";
+				case CHAR: return "C";
+				case BYTE: return "I";
+				case SBYTE: return "B";
+				case SHORT: return "S";
+				case USHORT: return "I";
+				case INT: return "I";
+				case UINT: return "I";
+				case LONG: return "J";
+				case ULONG: return "J";
+				case FLOAT: return "F";
+				case DOUBLE: return "D";
+				case STRING: return "java/lang/String";
+				default:
+					throw new IllegalArgumentException("Not a valid type: " + basic);
+			}
+		}
+    }
+
+    @Override
+    public String visitArray(ArrayTypeID array) {
+		return "[" + array.elementType.accept(this);
+    }
+
+    @Override
+    public String visitAssoc(AssocTypeID assoc) {
+		return "java/util/Map;";
+    }
+
+    @Override
+    public String visitIterator(IteratorTypeID iterator) {
+		return "java/lang/Iterator;";
+    }
+
+    @Override
+    public String visitFunction(FunctionTypeID function) {
+        return JavaSynthesizedClassNamer.createFunctionName(function).cls.internalName;
+    }
+
+    @Override
+    public String visitDefinition(DefinitionTypeID definition) {
+		return definition.definition.getTag(JavaClass.class).internalName;
+    }
+
+    @Override
+    public String visitGeneric(GenericTypeID generic) {
+		for (GenericParameterBound bound : generic.parameter.bounds) {
+			if (bound instanceof ParameterTypeBound) {
+				return ((ParameterTypeBound) bound).type.accept(this);
+			}
+		}
+		
+		return "java/lang/Object";
+    }
+
+    @Override
+    public String visitRange(RangeTypeID range) {
+		return JavaSynthesizedClassNamer.createRangeName(range).cls.internalName;
+    }
+
+    @Override
+    public String visitModified(ModifiedTypeID modified) {
+		if (modified.isOptional())
+			return modified.withoutOptional().accept(forOptional);
+		
+		return modified.baseType.accept(this);
+    }
+
+	@Override
+	public String visitGenericMap(GenericMapTypeID map) {
+		return "java/util/Map";
+	}
+}

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

 		String filename = getFilename(definition);
 		JavaSourcePrepareDefinitionVisitor prepare = new JavaSourcePrepareDefinitionVisitor(filename, null);
 		JavaClass cls = definition.accept(prepare);
-		if (cls.empty)
-			return;
 		
 		File file = new File(getDirectory(definition.pkg), cls.getName() + ".java");
 		System.out.println("Compiling " + definition.name + " as " + cls.fullName);
 	
 	@Override
 	public void finish() {
+		JavaSourceContext context = new JavaSourceContext(typeGenerator);
+		for (JavaSourceFile sourceFile : sourceFiles.values()) {
+			sourceFile.prepare(context);
+		}
+		
 		for (JavaSourceFile sourceFile : sourceFiles.values())
 			sourceFile.write();
 		

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javasource;
+
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.javashared.JavaTypeDescriptorVisitor;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSourceContext {
+	private final JavaTypeDescriptorVisitor typeDescriptorVisitor;
+	
+	public JavaSourceContext(JavaSourceSyntheticTypeGenerator generator) {
+		typeDescriptorVisitor = new JavaTypeDescriptorVisitor(generator);
+	}
+	
+	public String getDescriptor(ITypeID type) {
+		return type.accept(typeDescriptorVisitor);
+	}
+}

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.javasource.tags.JavaSourceField;
+import org.openzen.zenscript.javashared.JavaField;
 import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 import org.openzen.zenscript.javasource.tags.JavaSourceVariantOption;
 
 
 	@Override
 	public ExpressionString visitGetStaticField(GetStaticFieldExpression expression) {
-		JavaSourceField field = expression.field.getTag(JavaSourceField.class);
+		JavaField field = expression.field.getTag(JavaField.class);
 		if (field == null)
 			throw new CompileException(expression.position, CompileExceptionCode.INTERNAL_ERROR, "Missing field tag");
 		
 
 	@Override
 	public ExpressionString visitSetStaticField(SetStaticFieldExpression expression) {
-		JavaSourceField field = expression.field.getTag(JavaSourceField.class);
+		JavaField field = expression.field.getTag(JavaField.class);
 		if (field == null)
 			throw new CompileException(expression.position, CompileExceptionCode.INTERNAL_ERROR, "Missing field tag");
 		if (field.cls.fullName.equals(scope.fileScope.cls.fullName) && !scope.hasLocalVariable(field.name)) {

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

 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javasource.prepare.JavaSourcePrepareDefinitionMemberVisitor;
 
 /**
  *
 		modules.put(definition, module);
 	}
 	
+	public void prepare(JavaSourceContext context) {
+		JavaSourcePrepareDefinitionMemberVisitor visitor = new JavaSourcePrepareDefinitionMemberVisitor(context, file.getName());
+		
+		if (mainDefinition != null)
+			mainDefinition.accept(visitor);
+		
+		for (ExpansionDefinition expansion : expansions)
+			expansion.accept(visitor);
+	}
+	
 	public void write() {
 		System.out.println("Calling write on " + file.getName());
 		
-		if (mainDefinition == null)
+		if (mainDefinition == null || mainDefinition.getTag(JavaClass.class).empty) {
+			if (expansions.isEmpty())
+				return;
+			
 			mainDefinition = expansions.remove(0);
+		}
 		
 		HighLevelDefinition definition = mainDefinition;
 		JavaDefinitionVisitor visitor = new JavaDefinitionVisitor(

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

  */
 package org.openzen.zenscript.javasource;
 
+import org.openzen.zenscript.javashared.JavaSynthesizedClass;
 import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.OutputStreamWriter;
 import java.io.Writer;
 import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 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.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaSynthesizedClassNamer;
+import org.openzen.zenscript.javashared.JavaSyntheticClassGenerator;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class JavaSourceSyntheticTypeGenerator {
+public class JavaSourceSyntheticTypeGenerator implements JavaSyntheticClassGenerator {
 	private final Map<String, JavaSynthesizedClass> functions = new HashMap<>();
+	private final Map<String, JavaSynthesizedClass> ranges = new HashMap<>();
 	private final File directory;
 	private final JavaSourceFormattingSettings settings;
 	
 		this.settings = settings;
 	}
 	
-	public JavaSynthesizedClass createFunction(JavaSourceTypeVisitor typeFormatter, FunctionTypeID function) {
-		String signature = getFunctionSignature(function);
+	@Override
+	public JavaSynthesizedClass synthesizeFunction(FunctionTypeID function) {
+		String signature = JavaSynthesizedClassNamer.getFunctionSignature(function);
 		if (functions.containsKey(signature))
-			return functions.get(signature).withTypeParameters(extractTypeParameters(function));
+			return functions.get(signature).withTypeParameters(JavaSynthesizedClassNamer.extractTypeParameters(function));
 		
-		String className = "Function" + signature;
-		JavaClass cls = new JavaClass("zsynthetic", className, JavaClass.Kind.INTERFACE);
-		JavaSynthesizedClass result = new JavaSynthesizedClass(cls, extractTypeParameters(function));
+		JavaSynthesizedClass result = JavaSynthesizedClassNamer.createFunctionName(function);
 		functions.put(signature, result);
 		
-		JavaSourceImporter importer = new JavaSourceImporter(cls);
+		JavaSourceImporter importer = new JavaSourceImporter(result.cls);
 		JavaSourceTypeVisitor typeVisitor = new JavaSourceTypeVisitor(importer, this);
 		
 		StringBuilder contents = new StringBuilder();
 		contents.append("@FunctionalInterface\n");
 		contents.append("public interface ");
-		contents.append(className);
-		JavaSourceUtils.formatTypeParameters(typeFormatter, contents, result.typeParameters, false);
+		contents.append(result.cls.getName());
+		JavaSourceUtils.formatTypeParameters(typeVisitor, contents, result.typeParameters, false);
 		contents.append(" {\n");
 		contents.append(settings.indent);
 		if (function.header.getNumberOfTypeParameters() > 0) {
 		contents.append(");\n");
 		contents.append("}\n");
 		
+		writeFile(result, importer, contents);
+		return result;
+	}
+	
+	@Override
+	public JavaSynthesizedClass synthesizeRange(RangeTypeID type) {
+		String signature = JavaSynthesizedClassNamer.getRangeSignature(type);
+		if (ranges.containsKey(signature))
+			return ranges.get(signature).withTypeParameters(JavaSynthesizedClassNamer.extractTypeParameters(type));
+		
+		JavaSynthesizedClass result = JavaSynthesizedClassNamer.createRangeName(type);
+		functions.put(signature, result);
+		
+		JavaSourceImporter importer = new JavaSourceImporter(result.cls);
+		JavaSourceTypeVisitor typeVisitor = new JavaSourceTypeVisitor(importer, this);
+		
+		StringBuilder contents = new StringBuilder();
+		contents.append("public final class ").append(result.cls.getName()).append(" {\n");
+		contents.append(settings.indent).append("public final ").append(type.from.accept(typeVisitor)).append(" from;\n");
+		contents.append(settings.indent).append("public final ").append(type.to.accept(typeVisitor)).append(" to;\n");
+		contents.append(settings.indent).append("\n");
+		contents.append(settings.indent)
+				.append("public ")
+				.append(result.cls.getName())
+				.append("(")
+				.append(type.from.accept(typeVisitor))
+				.append(", ")
+				.append(type.to.accept(typeVisitor))
+				.append(") {\n");
+		contents.append(settings.indent).append(settings.indent).append("this.from = from;\n");
+		contents.append(settings.indent).append(settings.indent).append("this.to = top;\n");
+		contents.append(settings.indent).append("}\n");
+		contents.append("}\n");
+		
+		writeFile(result, importer, contents);
+		return result;
+	}
+	
+	private void writeFile(JavaSynthesizedClass result, JavaSourceImporter importer, StringBuilder contents) {
 		if (!directory.exists())
 			directory.mkdirs();
 		
-		File file = new File(directory, className + ".java");
+		File file = new File(directory, result.cls.getName() + ".java");
 		try (Writer writer = new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(file)), StandardCharsets.UTF_8)) {
 			writer.write("package zsynthetic;\n");
 			
 		} catch (IOException ex) {
 			ex.printStackTrace();
 		}
-		return result;
-	}
-	
-	private TypeParameter[] extractTypeParameters(ITypeID type) {
-		List<TypeParameter> result = new ArrayList<>();
-		type.extractTypeParameters(result);
-		return result.toArray(new TypeParameter[result.size()]);
-	}
-	
-	private static String getFunctionSignature(FunctionTypeID type) {
-		return new JavaSyntheticTypeSignatureConverter().visitFunction(type);
-	}
-	
-	private TypeParameter[] getFunctionTypeParameters(FunctionTypeID type) {
-		JavaSyntheticTypeSignatureConverter converter = new JavaSyntheticTypeSignatureConverter();
-		converter.visitFunction(type);
-		return converter.typeParameterList.toArray(new TypeParameter[converter.typeParameterList.size()]);
 	}
 }

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

  */
 package org.openzen.zenscript.javasource;
 
+import org.openzen.zenscript.javashared.JavaSynthesizedClass;
 import org.openzen.zenscript.codemodel.generic.GenericParameterBoundVisitor;
 import org.openzen.zenscript.codemodel.generic.ParameterSuperBound;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
 
 	@Override
 	public String visitFunction(FunctionTypeID function) {
-		JavaSynthesizedClass synthetic = typeGenerator.createFunction(this, function);
+		JavaSynthesizedClass synthetic = typeGenerator.synthesizeFunction(function);
 		StringBuilder result = new StringBuilder();
 		result.append(importer.importType(synthetic.cls));
 		if (synthetic.typeParameters.length > 0) {

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

 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.javasource.JavaSourceTypeNameVisitor;
 import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javasource.tags.JavaSourceField;
+import org.openzen.zenscript.javashared.JavaField;
+import org.openzen.zenscript.javasource.JavaSourceContext;
 import org.openzen.zenscript.javasource.tags.JavaSourceImplementation;
 import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 
 public class JavaSourcePrepareClassMethodVisitor implements MemberVisitor<Void> {
 	private static final boolean DEBUG_EMPTY = true;
 	
-	private final JavaSourcePrepareDefinitionVisitor definitionPreparer;
+	private final JavaSourceContext context;
 	private final String filename;
 	private final JavaClass cls;
 	private final JavaNativeClass nativeClass;
+	private final JavaSourcePrepareDefinitionMemberVisitor memberPreparer;
 	
 	public JavaSourcePrepareClassMethodVisitor(
-			JavaSourcePrepareDefinitionVisitor definitionPreparer,
+			JavaSourceContext context,
 			String filename,
 			JavaClass cls,
 			JavaNativeClass nativeClass,
+			JavaSourcePrepareDefinitionMemberVisitor memberPreparer,
 			boolean startsEmpty) {
-		this.definitionPreparer = definitionPreparer;
+		this.context = context;
 		this.filename = filename;
 		this.cls = cls;
 		this.nativeClass = nativeClass;
+		this.memberPreparer = memberPreparer;
 		
 		cls.empty = startsEmpty;
 	}
 			System.out.println("Class " + cls.fullName + " not empty because of const " + member.name);
 		
 		cls.empty = false;
-		member.setTag(JavaSourceField.class, new JavaSourceField(cls, member.name));
+		member.setTag(JavaField.class, new JavaField(cls, member.name, context.getDescriptor(member.type)));
 		return null;
 	}
 	
 	@Override
 	public Void visitField(FieldMember member) {
-		member.setTag(JavaSourceField.class, new JavaSourceField(cls, member.name));
+		member.setTag(JavaField.class, new JavaField(cls, member.name, context.getDescriptor(member.type)));
 		if (member.hasAutoGetter())
 			visitGetter(member.autoGetter);
 		if (member.hasAutoSetter())
 
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
-		definitionPreparer.prepare(member.type);
+		memberPreparer.prepare(member.type);
 		
 		if (canMergeImplementation(member)) {
 			member.setTag(JavaSourceImplementation.class, new JavaSourceImplementation(true, cls));
 			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);
+			JavaSourcePrepareClassMethodVisitor visitor = new JavaSourcePrepareClassMethodVisitor(context, filename, implementationClass, null, memberPreparer, true);
 			for (IDefinitionMember m : member.members)
 				m.accept(visitor);
 		}
 
 	@Override
 	public Void visitInnerDefinition(InnerDefinitionMember member) {
-		JavaSourcePrepareDefinitionVisitor innerDefinitionPrepare = new JavaSourcePrepareDefinitionVisitor(filename, cls);
+		JavaSourcePrepareDefinitionMemberVisitor innerDefinitionPrepare = new JavaSourcePrepareDefinitionMemberVisitor(context, filename);
 		member.innerDefinition.accept(innerDefinitionPrepare);
 		
 		if (DEBUG_EMPTY && cls.empty)

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareDefinitionMemberVisitor.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.prepare;
+
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.definition.AliasDefinition;
+import org.openzen.zenscript.codemodel.definition.ClassDefinition;
+import org.openzen.zenscript.codemodel.definition.DefinitionVisitor;
+import org.openzen.zenscript.codemodel.definition.EnumDefinition;
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
+import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
+import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
+import org.openzen.zenscript.codemodel.definition.StructDefinition;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javasource.JavaSourceContext;
+import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSourcePrepareDefinitionMemberVisitor implements DefinitionVisitor<JavaClass> {
+	private final JavaSourceContext context;
+	private final String filename;
+	
+	public JavaSourcePrepareDefinitionMemberVisitor(JavaSourceContext context, String filename) {
+		this.context = context;
+		this.filename = filename;
+	}
+	
+	private boolean isPrepared(HighLevelDefinition definition) {
+		return definition.getTag(JavaClass.class).membersPrepared;
+	}
+	
+	public void prepare(ITypeID type) {
+		if (!(type instanceof DefinitionTypeID))
+			return;
+			
+		HighLevelDefinition definition = ((DefinitionTypeID)type).definition;
+		definition.accept(this);
+	}
+	
+	@Override
+	public JavaClass visitClass(ClassDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaClass.class);
+		
+		return visitClassCompiled(definition, true, JavaClass.Kind.CLASS);
+	}
+
+	@Override
+	public JavaClass visitInterface(InterfaceDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaClass.class);
+		
+		for (ITypeID baseType : definition.baseInterfaces)
+			prepare(baseType);
+		
+		return visitClassCompiled(definition, true, JavaClass.Kind.INTERFACE);
+	}
+
+	@Override
+	public JavaClass visitEnum(EnumDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaClass.class);
+		
+		return visitClassCompiled(definition, false, JavaClass.Kind.ENUM);
+	}
+
+	@Override
+	public JavaClass visitStruct(StructDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaClass.class);
+		
+		return visitClassCompiled(definition, true, JavaClass.Kind.CLASS);
+	}
+
+	@Override
+	public JavaClass visitFunction(FunctionDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaClass.class);
+		
+		JavaClass cls = definition.getTag(JavaClass.class);
+		JavaSourceMethod method = new JavaSourceMethod(cls, JavaSourceMethod.Kind.STATIC, definition.name, true);
+		definition.caller.setTag(JavaSourceMethod.class, method);
+		return cls;
+	}
+
+	@Override
+	public JavaClass visitExpansion(ExpansionDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaClass.class);
+		
+		JavaNativeClass nativeClass = definition.getTag(JavaNativeClass.class);
+		JavaClass cls = definition.getTag(JavaClass.class);
+		visitExpansionMembers(definition, cls, nativeClass);
+		return cls;
+	}
+
+	@Override
+	public JavaClass visitAlias(AliasDefinition definition) {
+		// nothing to do
+		return null;
+	}
+
+	@Override
+	public JavaClass visitVariant(VariantDefinition variant) {
+		if (isPrepared(variant))
+			return variant.getTag(JavaClass.class);
+		
+		JavaClass cls = variant.getTag(JavaClass.class);
+		visitClassMembers(variant, cls, null, false);
+		return cls;
+	}
+	
+	private JavaClass visitClassCompiled(HighLevelDefinition definition, boolean startsEmpty, JavaClass.Kind kind) {
+		if (definition.getSuperType() != null)
+			prepare(definition.getSuperType());
+		
+		JavaNativeClass nativeClass = definition.getTag(JavaNativeClass.class);
+		JavaClass cls = definition.getTag(JavaClass.class);
+		if (nativeClass == null) {
+			visitClassMembers(definition, cls, null, startsEmpty);
+		} else {
+			visitExpansionMembers(definition, cls, nativeClass);
+		}
+		return cls;
+	}
+	
+	private void visitClassMembers(HighLevelDefinition definition, JavaClass cls, JavaNativeClass nativeClass, boolean startsEmpty) {
+		System.out.println("Preparing " + cls.internalName);
+		JavaSourcePrepareClassMethodVisitor methodVisitor = new JavaSourcePrepareClassMethodVisitor(context, filename, cls, nativeClass, this, startsEmpty);
+		for (IDefinitionMember member : definition.members) {
+			member.accept(methodVisitor);
+		}
+		cls.membersPrepared = true;
+	}
+	
+	private void visitExpansionMembers(HighLevelDefinition definition, JavaClass cls, JavaNativeClass nativeClass) {
+		System.out.println("Preparing " + cls.internalName);
+		JavaSourcePrepareExpansionMethodVisitor methodVisitor = new JavaSourcePrepareExpansionMethodVisitor(context, cls, nativeClass);
+		for (IDefinitionMember member : definition.members) {
+			member.accept(methodVisitor);
+		}
+		cls.membersPrepared = true;
+	}
+}

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

 import org.openzen.zenscript.codemodel.expression.CastExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.InnerDefinitionMember;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.formattershared.ExpressionString;
 		
 		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;
 	}
 
 			return definition.getTag(JavaClass.class);
 		
 		NativeTag nativeTag = definition.getTag(NativeTag.class);
-		JavaNativeClass nativeClass = null;
 		if (nativeTag != null) {
-			nativeClass = nativeClasses.get(nativeTag.value);
+			definition.setTag(JavaNativeClass.class, nativeClasses.get(nativeTag.value));
 		}
 		
 		JavaClass cls = new JavaClass(definition.pkg.fullName, filename, JavaClass.Kind.CLASS);
 		definition.setTag(JavaClass.class, cls);
-		visitExpansionMembers(definition, cls, nativeClass);
 		return cls;
 	}
 
 			option.setTag(JavaSourceVariantOption.class, new JavaSourceVariantOption(cls, variantCls));
 		}
 		
-		visitClassMembers(variant, cls, null, false);
 		return cls;
 	}
 	
 		
 		NativeTag nativeTag = definition.getTag(NativeTag.class);
 		JavaNativeClass nativeClass = nativeTag == null ? null : nativeClasses.get(nativeTag.value);
+		JavaClass cls;
 		if (nativeClass == null) {
-			JavaClass cls = outerClass == null ? new JavaClass(definition.pkg.fullName, definition.name, kind) : new JavaClass(outerClass, definition.name, kind);
+			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);
-			visitClassMembers(definition, cls, null, startsEmpty);
-			return cls;
 		} else {
-			JavaClass cls = outerClass == null ? new JavaClass(definition.pkg.fullName, filename, kind) : new JavaClass(outerClass, filename, kind);
+			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);
 			
 			if (nativeClass.nonDestructible)
 				cls.destructible = false;
-			
-			return cls;
-		}
-	}
-	
-	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, JavaClass cls, JavaNativeClass nativeClass) {
-		JavaSourcePrepareExpansionMethodVisitor methodVisitor = new JavaSourcePrepareExpansionMethodVisitor(cls, nativeClass);
+		
 		for (IDefinitionMember member : definition.members) {
-			member.accept(methodVisitor);
+			if (member instanceof InnerDefinitionMember) {
+				((InnerDefinitionMember) member).innerDefinition.accept(new JavaSourcePrepareDefinitionVisitor(filename, cls));
+			}
 		}
+		
+		return cls;
 	}
 }

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

 import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
 import org.openzen.zenscript.javasource.JavaSourceTypeNameVisitor;
 import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javasource.tags.JavaSourceField;
+import org.openzen.zenscript.javashared.JavaField;
+import org.openzen.zenscript.javasource.JavaSourceContext;
 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 JavaSourceContext context;
 	private final JavaClass cls;
 	private final JavaNativeClass nativeClass;
 	
-	public JavaSourcePrepareExpansionMethodVisitor(JavaClass cls, JavaNativeClass nativeClass) {
+	public JavaSourcePrepareExpansionMethodVisitor(JavaSourceContext context, JavaClass cls, JavaNativeClass nativeClass) {
 		this.cls = cls;
 		this.nativeClass = nativeClass;
+		this.context = context;
 		cls.empty = true;
 	}
 	
 	@Override
 	public Void visitConst(ConstMember member) {
-		member.setTag(JavaSourceField.class, new JavaSourceField(cls, member.name));
+		member.setTag(JavaField.class, new JavaField(cls, member.name, context.getDescriptor(member.type)));
 		
 		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(JavaSourceField.class, new JavaSourceField(cls, member.name));
+		member.setTag(JavaField.class, new JavaField(cls, member.name, context.getDescriptor(member.type)));
 		if (member.hasAutoGetter() || member.hasAutoSetter())
 			cls.empty = false;
 		return null;

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

 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.JavaFieldInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaField;
 
 /**
  *
 		PRINTSTREAM_PRINTLN.setTag(JavaMethodInfo.class, printstreamPrintln);
 		
 		JavaClass jSystem = new JavaClass("java.lang", "System", JavaClass.Kind.CLASS);
-		SYSTEM_OUT.setTag(JavaFieldInfo.class, new JavaFieldInfo(jSystem, "out", "Ljava/io/PrintStream;"));
+		SYSTEM_OUT.setTag(JavaField.class, new JavaField(jSystem, "out", "Ljava/io/PrintStream;"));
 	}
 	
 	public ZSPackage collectPackages() {