Merge remote-tracking branch 'Stan/development' into development

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/JavaBytecodeContext.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.JavaContext;
+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 JavaBytecodeContext extends JavaContext {
+	private final JavaModule module;
+	private final TypeGenerator typeGenerator;
+	private final JavaTypeInternalNameVisitor internalNameVisitor;
+	private final JavaTypeDescriptorVisitor descriptorVisitor;
+	
+	public JavaBytecodeContext(JavaModule module) {
+		this.module = module;
+		
+		typeGenerator = new TypeGenerator();
+		internalNameVisitor = new JavaTypeInternalNameVisitor(typeGenerator);
+		descriptorVisitor = new JavaTypeDescriptorVisitor(typeGenerator);
+	}
+	
+	public JavaSyntheticClassGenerator getTypeGenerator() {
+		return typeGenerator;
+	}
+	
+	@Override
+	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 void register(String name, byte[] bytecode) {
+		module.register(name, bytecode);
+	}
+	
+	private class TypeGenerator implements JavaSyntheticClassGenerator {
+
+		@Override
+		public JavaSynthesizedClass synthesizeFunction(FunctionTypeID type) {
+			return CompilerUtils.getLambdaInterface(JavaBytecodeContext.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/JavaCompiler.java

 package org.openzen.zenscript.javabytecode;
 
 import java.io.File;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
 
 import org.openzen.zenscript.javabytecode.compiler.definitions.JavaDefinitionVisitor;
 
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionMemberVisitor;
+import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionVisitor;
 
 /**
  * @author Hoofdgebruiker
 	private final JavaClassWriter scriptsClassWriter;
 	private int generatedScriptBlockCounter = 0;
 	private boolean finished = false;
-	private JavaModule compiled = null;
-private final File jarFile;
-
+	private final File jarFile;
+	private final JavaBytecodeContext context;
+	
+	private final List<HighLevelDefinition> definitions = new ArrayList<>();
+	private final List<ScriptBlock> scripts = new ArrayList<>();
+	
 	public JavaCompiler(File jarFile) {
 		this(false, jarFile);
 	}
 
 	public JavaCompiler(boolean debug, File jarFile) {
 		target = new JavaModule();
-this.jarFile = jarFile;
-
+		this.jarFile = jarFile;
+		this.context = new JavaBytecodeContext(target);
+		
 		scriptsClassWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 		scriptsClassWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Scripts", null, "java/lang/Object", null);
 	}
 
 	@Override
 	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)));
+		JavaPrepareDefinitionVisitor preparer = new JavaPrepareDefinitionVisitor(definition.position.getFilename(), null);
+		definition.accept(preparer);
+		
+		definitions.add(definition);
 	}
 
 	@Override
 	public void addScriptBlock(ScriptBlock script) {
-		final SourceFile sourceFile = script.getTag(SourceFile.class);
-		final String className = getClassName(sourceFile == null ? null : sourceFile.getFilename());
-		JavaScriptFile scriptFile = getScriptFile(className);
-
-		String methodName = scriptFile.scriptMethods.isEmpty() ? "run" : "run" + scriptFile.scriptMethods.size();
-
-		// convert scripts into methods (add them to a Scripts class?)
-		// (TODO: can we break very long scripts into smaller methods? for the extreme scripts)
-		final JavaClassWriter visitor = scriptFile.classWriter;
-		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));
-		statementVisitor.start();
-		for (Statement statement : script.statements) {
-			statement.accept(statementVisitor);
-		}
-		target.register("Scripts", scriptsClassWriter.toByteArray());
-		statementVisitor.end();
+		scripts.add(script);
 	}
 
 	private String getClassName(String filename) {
 
 	@Override
 	public void run() {
-		if (compiled == null)
+		if (!finished)
 			throw new IllegalStateException("Not yet built!");
-
-// TODO: execute this
+		
+		// TODO: execute this
 	}
 
 	public JavaModule finishAndGetModule() {
 		if (finished)
 			throw new IllegalStateException("Already finished!");
+		
 		finished = true;
-
+		
+		for (HighLevelDefinition definition : definitions) {
+			JavaPrepareDefinitionMemberVisitor memberPreparer = new JavaPrepareDefinitionMemberVisitor(context, definition.position.getFilename());
+			definition.accept(memberPreparer);
+		}
+		
+		for (HighLevelDefinition definition : definitions) {
+			String className = getClassName(definition.position.getFilename());
+			JavaScriptFile scriptFile = getScriptFile(className);
+			
+			target.register(definition.name, definition.accept(new JavaDefinitionVisitor(context, scriptFile.classWriter)));
+		}
+ 
+		for (ScriptBlock script : scripts) {
+			final SourceFile sourceFile = script.getTag(SourceFile.class);
+			final String className = getClassName(sourceFile == null ? null : sourceFile.getFilename());
+			JavaScriptFile scriptFile = getScriptFile(className);
+
+			String methodName = scriptFile.scriptMethods.isEmpty() ? "run" : "run" + scriptFile.scriptMethods.size();
+
+			// convert scripts into methods (add them to a Scripts class?)
+			// (TODO: can we break very long scripts into smaller methods? for the extreme scripts)
+			final JavaClassWriter visitor = scriptFile.classWriter;
+			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(context, new JavaWriter(visitor, method, null, null, null));
+			statementVisitor.start();
+			for (Statement statement : script.statements) {
+				statement.accept(statementVisitor);
+			}
+			statementVisitor.end();
+		}
+		
 		JavaMethodInfo runMethod = new JavaMethodInfo(new JavaClass("script", "Scripts", JavaClass.Kind.CLASS), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 		final JavaWriter runWriter = new JavaWriter(scriptsClassWriter, runMethod, null, null, null);
 		runWriter.start();
 		runWriter.end();
 
 		target.register("Scripts", scriptsClassWriter.toByteArray());
-
 		return target;
 	}
 }

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

  * @author Hoofdgebruiker
  */
 public class JavaModule {
-	public static final Map<String, byte[]> classes = new HashMap<>();
+	private final Map<String, byte[]> classes = new HashMap<>();
 
 	public JavaModule() {
 
 	}
 
 	public void register(String classname, byte[] bytecode) {
-		if (bytecode == null) return;
+		if (bytecode == null)
+			return;
+		
 		classes.put(classname, bytecode);
-		try (FileOutputStream writer = new FileOutputStream(new File(classname + ".class"))) {
+		
+		try (FileOutputStream writer = new FileOutputStream(new File(classname.replace('/', '_') + ".class"))) {
 			writer.write(bytecode);
 		} catch (IOException e) {
 			e.printStackTrace();
 
 		@Override
 		public Class<?> loadClass(String name) throws ClassNotFoundException {
+			//System.out.println("LoadClass " + name);
+			
 			if (customClasses.containsKey(name))
 				return customClasses.get(name);
 			if (classes.containsKey(name)) {

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.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.JavaBytecodeContext;
+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();
-		for (int i = 0; i < header.parameters.length; i++) {
-			FunctionParameter parameter = header.parameters[i];
-			Type parameterType = parameter.type.accept(typeVisitor);
-			parameter.setTag(JavaParameterInfo.class, new JavaParameterInfo(isStatic ? i : i + 1, parameterType));
-		}
-	}
+    public static void tagMethodParameters(JavaBytecodeContext context, FunctionHeader header, boolean isStatic) {
+        for (int i = 0; i < header.parameters.length; i++) {
+            FunctionParameter parameter = header.parameters[i];
+            Type parameterType = context.getType(parameter.type);
+            parameter.setTag(JavaParameterInfo.class, new JavaParameterInfo(isStatic ? i : i + 1, parameterType));
+        }
+    }
+
+    public static void tagConstructorParameters(JavaBytecodeContext context, FunctionHeader header, boolean isEnum) {
+        for (int i = 0; i < header.parameters.length; i++) {
+            FunctionParameter parameter = header.parameters[i];
+            Type parameterType = context.getType(parameter.type);
+            parameter.setTag(JavaParameterInfo.class, new JavaParameterInfo(isEnum ? i + 3 : i + 1, parameterType));
+        }
+    }
+
+    public static void writeDefaultFieldInitializers(JavaBytecodeContext context, JavaWriter constructorWriter, HighLevelDefinition definition, boolean staticFields) {
+        JavaExpressionVisitor expressionVisitor = new JavaExpressionVisitor(context, constructorWriter);
+        for (final IDefinitionMember definitionMember : definition.members) {
+            if (!(definitionMember instanceof FieldMember))
+                continue;
+
+            FieldMember field = (FieldMember) definitionMember;
+            if (field.isStatic() == staticFields && field.initializer != null) {
+                if (!staticFields)
+                    constructorWriter.loadObject(0);
+                field.initializer.accept(expressionVisitor);
+                if (staticFields)
+                    constructorWriter.putStaticField(definition.name, field.name, context.getDescriptor(field.type));
+                else
+                    constructorWriter.putField(definition.name, field.name, context.getDescriptor(field.type));
+            }
+        }
+    }
+
+	private static final Map<String, JavaSynthesizedClass> functions = new HashMap<>();
+	
+    public static JavaSynthesizedClass getLambdaInterface(JavaBytecodeContext context, FunctionTypeID function) {
+		String signature = JavaSynthesizedClassNamer.getFunctionSignature(function);
+		if (functions.containsKey(signature))
+			return functions.get(signature).withTypeParameters(JavaSynthesizedClassNamer.extractTypeParameters(function));
+		
+		System.out.println("Generating function " + signature);
+		
+		JavaSynthesizedClass result = JavaSynthesizedClassNamer.createFunctionName(function);
+		functions.put(signature, result);
+		
+        createLambdaInterface(context, function.header, result.cls);
+        return result;
+    }
+
+    private static void createLambdaInterface(JavaBytecodeContext 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, cls.internalName, null, "java/lang/Object", null);
+
+        ifaceWriter
+				.visitMethod(
+					Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT,
+					"accept",
+					context.getMethodDescriptor(header),
+					context.getMethodSignature(header),
+					null)
+				.visitEnd();
+
+        context.register(cls.internalName.replace('/', '.'), ifaceWriter.toByteArray());
+
+        try (FileOutputStream out = new FileOutputStream(cls.getClassName() + ".class")){
+            out.write(ifaceWriter.toByteArray());
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
 
-	public static void tagConstructorParameters(FunctionHeader header, boolean isEnum) {
-		JavaTypeVisitor typeVisitor = new JavaTypeVisitor();
-		for (int i = 0; i < header.parameters.length; i++) {
-			FunctionParameter parameter = header.parameters[i];
-			Type parameterType = parameter.type.accept(typeVisitor);
-			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);
-		for (final IDefinitionMember definitionMember : definition.members) {
-			if (!(definitionMember instanceof FieldMember))
-				continue;
-
-			FieldMember field = (FieldMember) definitionMember;
-			if (field.isStatic() == staticFields && field.initializer != null) {
-				if (!staticFields)
-					constructorWriter.loadObject(0);
-				field.initializer.accept(expressionVisitor);
-				if (staticFields)
-					constructorWriter.putStaticField(definition.name, field.name, Type.getDescriptor(field.type.accept(JavaTypeClassVisitor.INSTANCE)));
-				else
-					constructorWriter.putField(definition.name, field.name, Type.getDescriptor(field.type.accept(JavaTypeClassVisitor.INSTANCE)));
-			}
-		}
-	}
-
-	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 void createLambdaInterface(FunctionHeader header, String name) {
-		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.visitEnd();
-
-		JavaModule.classes.putIfAbsent(name, ifaceWriter.toByteArray());
-
-		try (FileOutputStream out = new FileOutputStream(name + ".class")) {
-			out.write(ifaceWriter.toByteArray());
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-	}
-
-
-	public static String getLambdaCounter() {
-		return "lambda" + ++lambdaCounter;
-	}
-
+    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.Comparator;
+import java.util.StringJoiner;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Label;
 import org.objectweb.asm.Opcodes;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import org.openzen.zenscript.javashared.JavaClass;
-import java.util.*;
+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);
 
 	protected final JavaWriter javaWriter;
 	private final JavaCapturedExpressionVisitor capturedExpressionVisitor = new JavaCapturedExpressionVisitor(this);
+	private final JavaBytecodeContext context;
 
-	public JavaExpressionVisitor(JavaWriter javaWriter) {
-		this.javaWriter = javaWriter;
-	}
+    public JavaExpressionVisitor(JavaBytecodeContext context, JavaWriter javaWriter) {
+        this.javaWriter = javaWriter;
+		this.context = context;
+    }
 
-	@Override
-	public Void visitAndAnd(AndAndExpression expression) {
-		Label end = new Label();
-		Label onFalse = new Label();
+    @Override
+    public Void visitAndAnd(AndAndExpression expression) {
+        Label end = new Label();
+        Label onFalse = new Label();
 
-		expression.left.accept(this);
+        expression.left.accept(this);
 
-		javaWriter.ifEQ(onFalse);
-		expression.right.accept(this);
+        javaWriter.ifEQ(onFalse);
+        expression.right.accept(this);
 
-		// //these two calls are redundant but make decompiled code look better. Keep?
-		// javaWriter.ifEQ(onFalse);
-		// javaWriter.iConst1();
+        // //these two calls are redundant but make decompiled code look better. Keep?
+        // javaWriter.ifEQ(onFalse);
+        // javaWriter.iConst1();
 
-		javaWriter.goTo(end);
+        javaWriter.goTo(end);
 
-		javaWriter.label(onFalse);
-		javaWriter.iConst0();
+        javaWriter.label(onFalse);
+        javaWriter.iConst0();
 
 
-		javaWriter.label(end);
+        javaWriter.label(end);
 
-		return null;
-	}
+        return null;
+    }
 
-	@Override
-	public Void visitArray(ArrayExpression expression) {
-		javaWriter.constant(expression.expressions.length);
-		Type type = Type.getType(expression.type.accept(JavaTypeClassVisitor.INSTANCE).getComponentType());
-		javaWriter.newArray(type);
-		for (int i = 0; i < expression.expressions.length; i++) {
-			javaWriter.dup();
-			javaWriter.constant(i);
-			expression.expressions[i].accept(this);
-			javaWriter.arrayStore(type);
-		}
-		return null;
-	}
+    @Override
+    public Void visitArray(ArrayExpression expression) {
+        javaWriter.constant(expression.expressions.length);
+        Type type = context.getType(((ArrayTypeID)expression.type).elementType);
+        javaWriter.newArray(type);
+        for (int i = 0; i < expression.expressions.length; i++) {
+            javaWriter.dup();
+            javaWriter.constant(i);
+            expression.expressions[i].accept(this);
+            javaWriter.arrayStore(type);
+        }
+        return null;
+    }
 
-	@Override
-	public Void visitCompare(CompareExpression expression) {
+    @Override
+    public Void visitCompare(CompareExpression expression) {
 		if (expression.operator.getBuiltin() != null) {
 			switch (expression.operator.getBuiltin()) {
 				case BYTE_COMPARE:
 
 			if (!checkAndExecuteMethodInfo(expression.member))
 				throw new IllegalStateException("Call target has no method info!");
-
-			if(expression.instancedHeader.returnType != BasicTypeID.VOID)
-				javaWriter.checkCast("java/lang/String");
 			return null;
 		}
 
 				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:
 		return null;
 	}
 
-	@Override
-	public Void visitCheckNull(CheckNullExpression expression) {
-		final Label end = new Label();
-		expression.value.accept(this);
-		javaWriter.dup();
-		javaWriter.ifNonNull(end);
-		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.invokeSpecial(NullPointerException.class, "<init>", "(Ljava/lang/String;)V");
-		javaWriter.aThrow();
-		javaWriter.label(end);
+    @Override
+    public Void visitCheckNull(CheckNullExpression expression) {
+        final Label end = new Label();
+        expression.value.accept(this);
+        javaWriter.dup();
+        javaWriter.ifNonNull(end);
+        javaWriter.pop();
+        javaWriter.newObject(NullPointerException.class);
+        javaWriter.dup();
+        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);
 
 		return null;
 	}
 		return null;
 	}
 
-	@Override
-	public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
-		Type type = expression.objectType.accept(JavaTypeVisitor.INSTANCE);
-		try {
-			type.getInternalName();
-		} catch (NullPointerException ex) {
-			ex.printStackTrace();
-		}
-
+    @Override
+    public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
 		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()));
-		return null;
-	}
-
-	@Override
-	public Void visitConstructorSuperCall(ConstructorSuperCallExpression expression) {
-		javaWriter.loadObject(0);
-		for (Expression argument : expression.arguments.arguments) {
-			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);
-		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());
-		return null;
-	}
+		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;
+    }
+
+    @Override
+    public Void visitConstructorSuperCall(ConstructorSuperCallExpression expression) {
+        javaWriter.loadObject(0);
+        for (Expression argument : expression.arguments.arguments) {
+            argument.accept(this);
+        }
+        //No super calls in enums possible, and that's already handled in the enum constructor itself.
+        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) {
+        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);
+        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 = 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.end();
 
 
-		functionWriter.start();
+        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);
 				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;
 			}
 
 			public Void visitCapturedParameter(CapturedParameterExpression varExpression) {
 				final int position = calculateMemberPosition(varExpression, expression);
 				functionWriter.loadObject(0);
-				functionWriter.getField(name, "captured" + position, varExpression.parameter.type.accept(JavaTypeVisitor.INSTANCE).getDescriptor());
+				functionWriter.getField(name, "captured" + position, context.getDescriptor(varExpression.parameter.type));
 				return null;
 			}
 		});
 
-
 		expression.body.accept(CSV);
-		functionWriter.ret();
-
 
+        functionWriter.ret();
 		functionWriter.end();
 		lambdaCW.visitEnd();
 
-		JavaModule.classes.putIfAbsent(name, lambdaCW.toByteArray());
+		context.register(name, lambdaCW.toByteArray());
 
 		try (FileOutputStream out = new FileOutputStream(name + ".class")) {
 			out.write(lambdaCW.toByteArray());
 
 	private static int calculateMemberPosition(CapturedParameterExpression functionParameterExpression, FunctionExpression expression) {
 		int h = 1;//expression.header.parameters.length;
-		for (CapturedExpression capture : expression.closure.captures) {
+    	for (CapturedExpression capture : expression.closure.captures) {
 			if (capture instanceof CapturedParameterExpression && ((CapturedParameterExpression) capture).parameter == functionParameterExpression.parameter)
 				return h;
 			h++;
 		throw new CompileException(functionParameterExpression.position, CompileExceptionCode.INTERNAL_ERROR, "Captured Statement error");
 	}
 
-
-	private String calcFunctionSignature(LambdaClosure closure) {
-		StringJoiner joiner = new StringJoiner("", "(", ")V");
-
-		for (CapturedExpression capture : closure.captures) {
-			String descriptor = capture.type.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
-			joiner.add(descriptor);
-		}
-		return joiner.toString();
-	}
+    private String calcFunctionSignature(LambdaClosure closure) {
+        StringJoiner joiner = new StringJoiner("", "(", ")V");
+	    for (CapturedExpression capture : closure.captures) {
+            String descriptor = context.getDescriptor(capture.type);
+            joiner.add(descriptor);
+        }
+        return joiner.toString();
+    }
 
 	@Override
 	public Void visitGetField(GetFieldExpression expression) {
 			throw new CompileException(expression.position, CompileExceptionCode.LAMBDA_HEADER_INVALID, "Could not resolve lambda parameter" + expression.parameter);
 		}
 
-		javaWriter.load(expression.parameter.type.accept(JavaTypeVisitor.INSTANCE), parameter.index);
-		return null;
-	}
+        javaWriter.load(context.getType(expression.parameter.type), parameter.index);
+        return null;
+    }
 
 	@Override
 	public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
 		final ITypeID type = expression.value.option.getParameterType(expression.index);
 		final JavaClass tag = expression.value.option.getTag(JavaClass.class);
 		javaWriter.checkCast(tag.internalName);
-		javaWriter.getField(new JavaFieldInfo(tag, "Field" + expression.index, type.accept(JavaTypeVisitor.INSTANCE).getDescriptor()));
+		javaWriter.getField(new JavaField(tag, "Field" + expression.index, context.getDescriptor(type)));
 		return null;
 		//throw new UnsupportedOperationException(); // TODO
 	}
 			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();
 		return expression.resolution.accept(this);
 	}
 
-	@Override
-	public Void visitInterfaceCast(InterfaceCastExpression expression) {
-		expression.value.accept(this);
-		javaWriter.checkCast(expression.type.accept(JavaTypeVisitor.INSTANCE));
-		return null;
-	}
+    @Override
+    public Void visitInterfaceCast(InterfaceCastExpression expression) {
+        expression.value.accept(this);
+        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));
-		return null;
-	}
+    @Override
+    public Void visitIs(IsExpression expression) {
+        expression.value.accept(this);
+        javaWriter.instanceOf(context.getDescriptor(expression.isType));
+        return null;
+    }
 
 	@Override
 	public Void visitMakeConst(MakeConstExpression expression) {
 		return null;
 	}
 
-	@Override
-	public Void visitMap(MapExpression expression) {
-		javaWriter.newObject(expression.type.accept(JavaTypeClassVisitor.INSTANCE));
-		javaWriter.dup();
-		javaWriter.invokeSpecial("java/util/Map", "<init>", "()V");
-		for (int i = 0; i < expression.keys.length; i++) {
-			javaWriter.dup();
-			expression.keys[i].accept(this);
-			expression.values[i].accept(this);
-			javaWriter.invokeInterface(MAP_PUT);
-			javaWriter.pop();
-		}
-		return null;
-	}
+    @Override
+    public Void visitMap(MapExpression expression) {
+        javaWriter.newObject("java/util/HashMap");
+        javaWriter.dup();
+        javaWriter.invokeSpecial("java/util/HashMap", "<init>", "()V");
+        for (int i = 0; i < expression.keys.length; i++) {
+            javaWriter.dup();
+            expression.keys[i].accept(this);
+            expression.values[i].accept(this);
+            javaWriter.invokeInterface(MAP_PUT);
+            javaWriter.pop();
+        }
+        return null;
+    }
 
 	@Override
 	public Void visitMatch(MatchExpression expression) {
 
 		//TODO replace beforeSwitch visitor or similar
 		if (expression.value.type == BasicTypeID.STRING)
-			javaWriter.invokeVirtual(new JavaMethodInfo(OBJECT, "hashCode", "()I", 0));
+			javaWriter.invokeVirtual(new JavaMethodInfo(JavaClass.OBJECT, "hashCode", "()I", 0));
 
 		//TODO replace with beforeSwitch visitor or similar
 		for (MatchExpression.Case aCase : expression.cases) {
 
 		if (hasNoDefault) {
 			javaWriter.label(defaultLabel);
-			final Type type = expression.type.accept(JavaTypeVisitor.INSTANCE);
-			if (type == null || type.getOpcode(Opcodes.ISTORE) == Opcodes.ASTORE)
+			if (context.getType(expression.type).getOpcode(Opcodes.ISTORE) == Opcodes.ASTORE)
 				javaWriter.aConstNull();
 			else
 				javaWriter.iConst0();
 		}
 
 		javaWriter.label(end);
-
-
-		//throw new UnsupportedOperationException("Not yet implemented!");
 		return null;
 	}
 
 		return true;
 	}
 
-	@Override
-	public Void visitNew(NewExpression expression) {
-		final String type;
-		if (expression.type instanceof DefinitionTypeID)
-			type = ((DefinitionTypeID) expression.type).definition.name;
-		else
-			type = Type.getDescriptor(expression.type.accept(JavaTypeClassVisitor.INSTANCE));
+    @Override
+    public Void visitNew(NewExpression expression) {
+		// TODO: this code is incorrect!
 
-		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(")V");
-		javaWriter.invokeSpecial(type, "<init>", signatureBuilder.toString());
+        final String type;
+        if (expression.type instanceof DefinitionTypeID)
+            type = ((DefinitionTypeID) expression.type).definition.name;
+        else
+            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(context.getDescriptor(argument.type));
+        }
+        signatureBuilder.append(")V");
+        javaWriter.invokeSpecial(type, "<init>", signatureBuilder.toString());
 
+		//throw new UnsupportedOperationException("Not yet implemented!");
 		return null;
 	}
 
 	@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!");
 
 		return null;
 	}
 
-	@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)
-			throw new CompileException(expression.position, CompileExceptionCode.INTERNAL_ERROR, "Only integer ranges supported");
+    @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 (!context.getDescriptor(expression.from.type).equals("I"))
+            throw new CompileException(expression.position, CompileExceptionCode.INTERNAL_ERROR, "Only integer ranges supported");
 
 		javaWriter.newObject(IntRange.class);
 		javaWriter.dup();
 		return null;
 	}
 
-	@Override
-	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);
-		return null;
-	}
+    @Override
+    public Void visitSetFunctionParameter(SetFunctionParameterExpression expression) {
+        expression.value.accept(this);
+        JavaParameterInfo parameter = expression.parameter.getTag(JavaParameterInfo.class);
+        javaWriter.store(context.getType(expression.type), parameter.index);
+        return null;
+    }
 
 	@Override
 	public Void visitSetLocalVariable(SetLocalVariableExpression expression) {
 
 		final StringBuilder builder = new StringBuilder("(");
 		for (ITypeID type : expression.option.getOption().types) {
-			builder.append(type.accept(JavaTypeVisitor.INSTANCE).getDescriptor());
+			builder.append(context.getDescriptor(type));
 		}
 		builder.append(")V");
 
 
 		javaWriter.invokeSpecial(internalName, "<init>", builder.toString());
-
-
-
 		return null;
 	}
 
 		return null;
 	}
 
-	public JavaWriter getJavaWriter() {
-		return javaWriter;
-	}
-
-
-	//Will return true if a JavaBytecodeImplementation.class tag exists, and will compile that tag
-	private boolean checkAndExecuteByteCodeImplementation(DefinitionMemberRef member) {
-		final JavaBytecodeImplementation implementation = member.getTag(JavaBytecodeImplementation.class);
-		if (implementation != null) {
-			implementation.compile(getJavaWriter());
-			return true;
-		}
-		return false;
-	}
-
-	//Will return true if a JavaMethodInfo.class tag exists, and will compile that tag
-	private boolean checkAndExecuteMethodInfo(DefinitionMemberRef member) {
-		final JavaMethodInfo methodInfo = member.getTag(JavaMethodInfo.class);
-		if (methodInfo == null)
-			return false;
-
-		if (methodInfo.isStatic()) {
-			getJavaWriter().invokeStatic(methodInfo);
-		} else {
-			getJavaWriter().invokeVirtual(methodInfo);
-		}
-		return true;
-	}
-
-
-	//Will return true if a JavaFieldInfo.class tag exists, and will compile that tag
-	public boolean checkAndPutFieldInfo(FieldMemberRef field, boolean isStatic) {
-		final JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
-		if (fieldInfo == null)
-			return false;
-		//TODO Remove isStatic
-		if (field.isStatic() || isStatic) {
-			getJavaWriter().putStaticField(fieldInfo);
-		} else {
-			getJavaWriter().putField(fieldInfo);
-		}
-		return true;
-	}
+    public JavaWriter getJavaWriter() {
+        return javaWriter;
+    }
+
+
+    //Will return true if a JavaBytecodeImplementation.class tag exists, and will compile that tag
+    private boolean checkAndExecuteByteCodeImplementation(DefinitionMemberRef member) {
+        JavaBytecodeImplementation implementation = member.getTag(JavaBytecodeImplementation.class);
+        if (implementation != null) {
+            implementation.compile(getJavaWriter());
+            return true;
+        }
+        return false;
+    }
+
+    //Will return true if a JavaMethodInfo.class tag exists, and will compile that tag
+    private boolean checkAndExecuteMethodInfo(DefinitionMemberRef member) {
+        JavaMethodInfo methodInfo = member.getTag(JavaMethodInfo.class);
+        if (methodInfo == null)
+            return false;
+
+        if (methodInfo.isStatic()) {
+            getJavaWriter().invokeStatic(methodInfo);
+        } else {
+            getJavaWriter().invokeVirtual(methodInfo);
+        }
+        return true;
+    }
+
+    //Will return true if a JavaFieldInfo.class tag exists, and will compile that tag
+    public boolean checkAndPutFieldInfo(FieldMemberRef field, boolean isStatic) {
+		JavaField fieldInfo = field.getTag(JavaField.class);
+        if (fieldInfo == null)
+            return false;
+        //TODO Remove isStatic
+        if (field.isStatic() || isStatic) {
+            getJavaWriter().putStaticField(fieldInfo);
+        } else {
+            getJavaWriter().putField(fieldInfo);
+        }
+        return true;
+    }
 
 	public boolean checkAndGetFieldInfo(ConstMemberRef field, boolean isStatic) {
-		final JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
+		final JavaField fieldInfo = field.getTag(JavaField.class);
 		if (fieldInfo == null)
 			return false;
 
 	}
 
 	public boolean checkAndGetFieldInfo(FieldMemberRef field, boolean isStatic) {
-		final JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
+		final JavaField fieldInfo = field.getTag(JavaField.class);
 		if (fieldInfo == null)
 			return false;
 
 		}
 		return true;
 	}
-
 }

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.*;
-
-/**
- * @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

 package org.openzen.zenscript.javabytecode.compiler;
 
 import org.objectweb.asm.Type;
-import org.openzen.zenscript.codemodel.expression.*;
+import org.openzen.zenscript.codemodel.expression.AndAndExpression;
+import org.openzen.zenscript.codemodel.expression.ArrayExpression;
+import org.openzen.zenscript.codemodel.expression.CompareExpression;
+import org.openzen.zenscript.codemodel.expression.CallExpression;
+import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedClosureExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedDirectExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedParameterExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedThisExpression;
+import org.openzen.zenscript.codemodel.expression.CastExpression;
+import org.openzen.zenscript.codemodel.expression.CheckNullExpression;
+import org.openzen.zenscript.codemodel.expression.CoalesceExpression;
+import org.openzen.zenscript.codemodel.expression.ConditionalExpression;
+import org.openzen.zenscript.codemodel.expression.ConstExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantBoolExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantDoubleExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantFloatExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantLongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantSByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
+import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
+import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
+import org.openzen.zenscript.codemodel.expression.ExpressionVisitor;
+import org.openzen.zenscript.codemodel.expression.FunctionExpression;
+import org.openzen.zenscript.codemodel.expression.GetFieldExpression;
+import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
+import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.GetMatchingVariantField;
+import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
+import org.openzen.zenscript.codemodel.expression.GetterExpression;
+import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
+import org.openzen.zenscript.codemodel.expression.GlobalExpression;
+import org.openzen.zenscript.codemodel.expression.InterfaceCastExpression;
+import org.openzen.zenscript.codemodel.expression.IsExpression;
+import org.openzen.zenscript.codemodel.expression.MakeConstExpression;
+import org.openzen.zenscript.codemodel.expression.MapExpression;
+import org.openzen.zenscript.codemodel.expression.MatchExpression;
+import org.openzen.zenscript.codemodel.expression.NewExpression;
+import org.openzen.zenscript.codemodel.expression.NullExpression;
+import org.openzen.zenscript.codemodel.expression.OrOrExpression;
+import org.openzen.zenscript.codemodel.expression.PanicExpression;
+import org.openzen.zenscript.codemodel.expression.PostCallExpression;
+import org.openzen.zenscript.codemodel.expression.RangeExpression;
+import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
+import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
+import org.openzen.zenscript.codemodel.expression.SetFunctionParameterExpression;
+import org.openzen.zenscript.codemodel.expression.SetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.SetStaticFieldExpression;
+import org.openzen.zenscript.codemodel.expression.SetterExpression;
+import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
+import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
+import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
+import org.openzen.zenscript.codemodel.expression.ThisExpression;
+import org.openzen.zenscript.codemodel.expression.ThrowExpression;
+import org.openzen.zenscript.codemodel.expression.TryConvertExpression;
+import org.openzen.zenscript.codemodel.expression.TryRethrowAsExceptionExpression;
+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.JavaBytecodeContext;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 import org.openzen.zenscript.javabytecode.JavaParameterInfo;
 
 /**
+ *
  * @author Hoofdgebruiker
  */
 public class JavaPreDecrementVisitor implements ExpressionVisitor<Void> {
 	private final JavaExpressionVisitor expressionCompiler;
 	private final JavaWriter javaWriter;
-
-	public JavaPreDecrementVisitor(JavaExpressionVisitor expressionCompiler) {
+	private final JavaBytecodeContext context;
+	
+	public JavaPreDecrementVisitor(JavaBytecodeContext context, JavaExpressionVisitor expressionCompiler) {
 		this.expressionCompiler = expressionCompiler;
+		this.context = context;
 		javaWriter = expressionCompiler.getJavaWriter();
 	}
 
 	public Void visitConditional(ConditionalExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
-
+	
 	@Override
 	public Void visitConst(ConstExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 
 	@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);
 		javaWriter.dup();
 		javaWriter.store(objectType, local);
-
-		if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))
-			throw new IllegalStateException("Missing field info on a field member!");
-
+		
+        if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))
+            throw new IllegalStateException("Missing field info on a field member!");
+		
 		javaWriter.iConst1();
 		javaWriter.iSub();
-
+		
 		javaWriter.load(objectType, local);
-		if (!expressionCompiler.checkAndPutFieldInfo(expression.field, false))
-			throw new IllegalStateException("Missing field info on a field member!");
-
+        if (!expressionCompiler.checkAndPutFieldInfo(expression.field, false))
+            throw new IllegalStateException("Missing field info on a field member!");
+		
 		return null;
 	}
 
 		javaWriter.idec(expression.parameter.getTag(JavaParameterInfo.class).index);
 		return null;
 	}
-
+	
 	@Override
 	public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
 		javaWriter.idec(expression.variable.getTag(JavaLocalVariableInfo.class).local);
 	@Override
 	public Void visitGetStaticField(GetStaticFieldExpression expression) {
 		if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))
-			throw new IllegalStateException("Missing field info on a field member!");
-
+            throw new IllegalStateException("Missing field info on a field member!");
+		
 		javaWriter.iConst1();
 		javaWriter.iAdd();
-
+		
 		if (!expressionCompiler.checkAndPutFieldInfo(expression.field, false))
-			throw new IllegalStateException("Missing field info on a field member!");
-
+            throw new IllegalStateException("Missing field info on a field member!");
+		
 		return null;
 	}
 
 	public Void visitOrOr(OrOrExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
-
+	
 	@Override
 	public Void visitPanic(PanicExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	public Void visitRange(RangeExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
-
+	
 	@Override
 	public Void visitSameObject(SameObjectExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	public Void visitStaticSetter(StaticSetterExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
-
+	
 	@Override
 	public Void visitSupertypeCast(SupertypeCastExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");

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

 package org.openzen.zenscript.javabytecode.compiler;
 
 import org.objectweb.asm.Type;
-import org.openzen.zenscript.codemodel.expression.*;
+import org.openzen.zenscript.codemodel.expression.AndAndExpression;
+import org.openzen.zenscript.codemodel.expression.ArrayExpression;
+import org.openzen.zenscript.codemodel.expression.CompareExpression;
+import org.openzen.zenscript.codemodel.expression.CallExpression;
+import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedClosureExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedDirectExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedParameterExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedThisExpression;
+import org.openzen.zenscript.codemodel.expression.CastExpression;
+import org.openzen.zenscript.codemodel.expression.CheckNullExpression;
+import org.openzen.zenscript.codemodel.expression.CoalesceExpression;
+import org.openzen.zenscript.codemodel.expression.ConditionalExpression;
+import org.openzen.zenscript.codemodel.expression.ConstExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantBoolExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantDoubleExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantFloatExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantLongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantSByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
+import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
+import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
+import org.openzen.zenscript.codemodel.expression.ExpressionVisitor;
+import org.openzen.zenscript.codemodel.expression.FunctionExpression;
+import org.openzen.zenscript.codemodel.expression.GetFieldExpression;
+import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
+import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.GetMatchingVariantField;
+import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
+import org.openzen.zenscript.codemodel.expression.GetterExpression;
+import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
+import org.openzen.zenscript.codemodel.expression.GlobalExpression;
+import org.openzen.zenscript.codemodel.expression.InterfaceCastExpression;
+import org.openzen.zenscript.codemodel.expression.IsExpression;
+import org.openzen.zenscript.codemodel.expression.MakeConstExpression;
+import org.openzen.zenscript.codemodel.expression.MapExpression;
+import org.openzen.zenscript.codemodel.expression.MatchExpression;
+import org.openzen.zenscript.codemodel.expression.NewExpression;
+import org.openzen.zenscript.codemodel.expression.NullExpression;
+import org.openzen.zenscript.codemodel.expression.OrOrExpression;
+import org.openzen.zenscript.codemodel.expression.PanicExpression;
+import org.openzen.zenscript.codemodel.expression.PostCallExpression;
+import org.openzen.zenscript.codemodel.expression.RangeExpression;
+import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
+import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
+import org.openzen.zenscript.codemodel.expression.SetFunctionParameterExpression;
+import org.openzen.zenscript.codemodel.expression.SetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.SetStaticFieldExpression;
+import org.openzen.zenscript.codemodel.expression.SetterExpression;
+import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
+import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
+import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
+import org.openzen.zenscript.codemodel.expression.ThisExpression;
+import org.openzen.zenscript.codemodel.expression.ThrowExpression;
+import org.openzen.zenscript.codemodel.expression.TryConvertExpression;
+import org.openzen.zenscript.codemodel.expression.TryRethrowAsExceptionExpression;
+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.JavaBytecodeContext;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 import org.openzen.zenscript.javabytecode.JavaParameterInfo;
 
 /**
+ *
  * @author Hoofdgebruiker
  */
 public class JavaPreIncrementVisitor implements ExpressionVisitor<Void> {
 	private final JavaExpressionVisitor expressionCompiler;
+	private final JavaBytecodeContext context;
 	private final JavaWriter javaWriter;
-
-	public JavaPreIncrementVisitor(JavaExpressionVisitor expressionCompiler) {
+	
+	public JavaPreIncrementVisitor(JavaBytecodeContext context, JavaExpressionVisitor expressionCompiler) {
 		this.expressionCompiler = expressionCompiler;
+		this.context = context;
 		javaWriter = expressionCompiler.getJavaWriter();
 	}
 
 	public Void visitConditional(ConditionalExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
-
+	
 	@Override
 	public Void visitConst(ConstExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 
 	@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);
 		javaWriter.dup();
 		javaWriter.store(objectType, local);
-
-		if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))
-			throw new IllegalStateException("Missing field info on a field member!");
-
+		
+        if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))
+            throw new IllegalStateException("Missing field info on a field member!");
+		
 		javaWriter.iConst1();
 		javaWriter.iAdd();
-
+		
 		javaWriter.load(objectType, local);
 		javaWriter.dupX1();
-		if (!expressionCompiler.checkAndPutFieldInfo(expression.field, false))
-			throw new IllegalStateException("Missing field info on a field member!");
-
+        if (!expressionCompiler.checkAndPutFieldInfo(expression.field, false))
+            throw new IllegalStateException("Missing field info on a field member!");
+		
 		return null;
 	}
 
 	@Override
 	public Void visitGetStaticField(GetStaticFieldExpression expression) {
 		if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))
-			throw new IllegalStateException("Missing field info on a field member!");
-
+            throw new IllegalStateException("Missing field info on a field member!");
+		
 		javaWriter.iConst1();
 		javaWriter.iAdd();
 		javaWriter.dup();
-
+		
 		if (!expressionCompiler.checkAndPutFieldInfo(expression.field, false))
-			throw new IllegalStateException("Missing field info on a field member!");
-
+            throw new IllegalStateException("Missing field info on a field member!");
+		
 		return null;
 	}
 
 	public Void visitOrOr(OrOrExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
-
+	
 	@Override
 	public Void visitPanic(PanicExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	public Void visitRange(RangeExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
-
+	
 	@Override
 	public Void visitSameObject(SameObjectExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	public Void visitStaticSetter(StaticSetterExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
-
+	
 	@Override
 	public Void visitSupertypeCast(SupertypeCastExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");

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

 
 import java.util.Arrays;
 import java.util.List;
+import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javashared.JavaClass;
 
 public class JavaStatementVisitor implements StatementVisitor<Boolean> {
-	private final JavaWriter javaWriter;
-	public JavaExpressionVisitor expressionVisitor;
-
-	/**
-	 * @param javaWriter the method writer that compiles the statement
-	 */
-	public JavaStatementVisitor(JavaWriter javaWriter) {
-		this.javaWriter = javaWriter;
-		this.expressionVisitor = new JavaExpressionVisitor(javaWriter);
-	}
-
-	public JavaStatementVisitor(JavaExpressionVisitor expressionVisitor) {
-		this.javaWriter = expressionVisitor.getJavaWriter();
-		this.expressionVisitor = expressionVisitor;
-	}
+    private final JavaWriter javaWriter;
+	private final JavaBytecodeContext context;
+    public JavaExpressionVisitor expressionVisitor;
+
+    /**
+     * @param javaWriter the method writer that compiles the statement
+     */
+    public JavaStatementVisitor(JavaBytecodeContext context, JavaWriter javaWriter) {
+        this.javaWriter = javaWriter;
+		this.context = context;
+        this.expressionVisitor = new JavaExpressionVisitor(context, javaWriter);
+    }
+
+    public JavaStatementVisitor(JavaBytecodeContext context, JavaExpressionVisitor expressionVisitor) {
+        this.javaWriter = expressionVisitor.getJavaWriter();
+		this.context = context;
+        this.expressionVisitor = expressionVisitor;
+    }
 
 	@Override
 	public Boolean visitBlock(BlockStatement statement) {
 		//Compile Array/Collection
 		statement.list.accept(expressionVisitor);
 
-		//Create local variables
-		for (VarStatement variable : statement.loopVariables) {
-			final Type type = Type.getType(variable.type.accept(JavaTypeClassVisitor.INSTANCE));
-			final Label variableStart = new Label();
-			final JavaLocalVariableInfo info = new JavaLocalVariableInfo(type, javaWriter.local(type), variableStart, variable.name);
-			info.end = end;
-			variable.setTag(JavaLocalVariableInfo.class, info);
-			javaWriter.addVariableInfo(info);
-		}
+        //Create local variables
+        for (VarStatement variable : statement.loopVariables) {
+            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;
+            variable.setTag(JavaLocalVariableInfo.class, info);
+            javaWriter.addVariableInfo(info);
+        }
 
 		//javaWriter.label(min);
 		statement.iterator.target.acceptForIterator(new JavaForeachVisitor(this, statement.loopVariables, statement.content, start, end));
 	@Override
 	public Boolean visitReturn(ReturnStatement statement) {
 		statement.value.accept(expressionVisitor);
-		javaWriter.returnType(statement.value.type.accept(JavaTypeVisitor.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);
 
 
 	@Override
 	public Boolean visitVar(VarStatement statement) {
-
 		if (statement.initializer != null) {
 			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 Object.class;
-	}
-
-	@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.definition.name + ";");
-	}
-
-	@Override
-	public Type visitGeneric(GenericTypeID generic) {
-		final Class<?> clazz = generic.accept(JavaTypeClassVisitor.INSTANCE);
-		return Type.getType(clazz == null ? Object.class : clazz);
-	}
-
-	@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/definitions/JavaDefinitionVisitor.java

 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 import org.openzen.zenscript.javabytecode.JavaModule;
 import org.openzen.zenscript.javabytecode.compiler.*;
 			Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
 
 	private final JavaClassWriter outerWriter;
+	private final JavaBytecodeContext context;
 
-	public JavaDefinitionVisitor(JavaClassWriter outerWriter) {
-
+    public JavaDefinitionVisitor(JavaBytecodeContext context, JavaClassWriter outerWriter) {
+		this.context = context;
 		this.outerWriter = outerWriter;
 	}
 
 	public byte[] visitClass(ClassDefinition definition) {
 		//Classes will always be created in a new File/Class
 
-		final Type superType;
-		if (definition.getSuperType() == null)
-			superType = Type.getType(Object.class);
-		else
-			superType = Type.getType(definition.getSuperType().accept(JavaTypeClassVisitor.INSTANCE));
+        final Type superType;
+        if (definition.getSuperType() == null)
+            superType = Type.getType(Object.class);
+        else
+            superType = context.getType(definition.getSuperType());
 
 		JavaClass toClass = new JavaClass(definition.pkg.fullName, definition.name, JavaClass.Kind.CLASS);
 		JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
-		//TODO: Calculate signature from generic parameters
-		//TODO: Interfaces?
-		String signature = null;
-
+        //TODO: Calculate signature from generic parameters
+        //TODO: Interfaces?
+        String signature = null;
 
-		writer.visit(Opcodes.V1_8, definition.modifiers, definition.name, signature, superType.getInternalName(), null);
-		JavaMemberVisitor memberVisitor = new JavaMemberVisitor(writer, toClass, definition);
-		for (IDefinitionMember member : definition.members) {
-			member.accept(memberVisitor);
-		}
+        writer.visit(Opcodes.V1_8, definition.modifiers, definition.name, signature, superType.getInternalName(), null);
+		JavaMemberVisitor memberVisitor = new JavaMemberVisitor(context, writer, toClass, definition);
+        for (IDefinitionMember member : definition.members) {
+            member.accept(memberVisitor);
+        }
 		memberVisitor.end();
 		writer.visitEnd();
 		return writer.toByteArray();
 		//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);
 		}
 	public byte[] visitEnum(EnumDefinition definition) {
 		System.out.println("Compiling enum " + definition.name + " in " + definition.position.getFilename());
 
-		final Type superType;
-		if (definition.getSuperType() == null)
-			superType = Type.getType(Object.class);
-		else
-			superType = Type.getType(definition.getSuperType().accept(JavaTypeClassVisitor.INSTANCE));
+        final Type superType;
+        if (definition.getSuperType() == null)
+            superType = Type.getType(Object.class);
+        else
+            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);
-		for (IDefinitionMember member : definition.members) {
-			member.accept(visitor);
-		}
+        final JavaMemberVisitor visitor = new JavaMemberVisitor(context, writer, toClass, definition);
+        for (IDefinitionMember member : definition.members) {
+            member.accept(visitor);
+        }
 
 		JavaClass arrayClass = JavaClass.fromInternalName("[L" + definition.name + ";", JavaClass.Kind.ARRAY);
 		JavaMethodInfo arrayClone = new JavaMethodInfo(arrayClass, "clone", "()Ljava/lang/Object;", Opcodes.ACC_PUBLIC);
 
 	@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);
-		statementVisitor.start();
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, writer);
+        statementVisitor.start();
 		boolean returns = definition.statement.accept(statementVisitor);
 		if (!returns) {
 			ITypeID type = definition.header.returnType;
 				writer.iConst0();
 			else if (type != BasicTypeID.VOID)
 				writer.aConstNull();
-			writer.returnType(type.accept(JavaTypeVisitor.INSTANCE));
+			writer.returnType(context.getType(type));
 		}
 
 		statementVisitor.end();
 		writer.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, "getDenominator", "()I", null, null).visitEnd();
 
 
-		final JavaMemberVisitor visitor = new JavaMemberVisitor(writer, toClass, variant);
+		final JavaMemberVisitor visitor = new JavaMemberVisitor(context, writer, toClass, variant);
 
 		final List<VariantDefinition.Option> options = variant.options;
 		//Each option is one of the possible child classes
 			final String signature;
 			{
 				StringBuilder builder = new StringBuilder();
+				//TODO check if this can be changed to what Stan was up to
 				builder.append("<");
 				for (final ITypeID type : option.types) {
 					builder.append(JavaTypeGenericVisitor.getSignatureWithBound(type));
 			}
 
 			optionWriter.visit(Opcodes.V1_8, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, optionClassName, signature, variantName, null);
-			final JavaMemberVisitor optionVisitor = new JavaMemberVisitor(optionWriter, optionClass, variant);
-
-
+			final JavaMemberVisitor optionVisitor = new JavaMemberVisitor(context, optionWriter, optionClass, variant);
 			final StringBuilder optionInitDescBuilder = new StringBuilder("(");
 			final StringBuilder optionInitSignatureBuilder = new StringBuilder("(");
 
 			ITypeID[] types = option.types;
 			for (int i = 0; i < types.length; ++i) {
-				final Type type = types[i].accept(JavaTypeVisitor.INSTANCE);
-				final String internalName = type.getDescriptor();
+				final String internalName = context.getInternalName(types[i]);
 				optionInitDescBuilder.append(internalName);
 				optionInitSignatureBuilder.append("T").append(((GenericTypeID) types[i]).parameter.name).append(";");
 				optionWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "Field" + i, internalName, "T" + ((GenericTypeID) types[i]).parameter.name + ";", null).visitEnd();
 				initWriter.dup();
 				initWriter.loadObject(i + 1);
 
-				final Type type = types[i].accept(JavaTypeVisitor.INSTANCE);
-				final String internalName = type.getDescriptor();
-
-				initWriter.putField(optionClassName, "Field" + i, internalName);
+				final String descriptor = context.getDescriptor(types[i]);
+				initWriter.putField(optionClassName, "Field" + i, descriptor);
 			}
 			initWriter.pop();
 			initWriter.ret();
 			optionVisitor.end();
 			optionWriter.visitEnd();
 			final byte[] byteArray = optionWriter.toByteArray();
-			JavaModule.classes.put(optionClassName, byteArray);
+			context.register(optionClassName, byteArray);
 
 			//Print the option files, won't be in production
 			try (FileOutputStream out = new FileOutputStream(optionClassName + ".class")) {

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.JavaBytecodeContext;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaField;
 
 public class JavaMemberVisitor implements MemberVisitor<Void> {
-	private final ClassWriter writer;
-	private final JavaClass toClass;
-	private final HighLevelDefinition definition;
-	private final JavaStatementVisitor clinitStatementVisitor;
-	private EnumDefinition enumDefinition = null;
-
-	public JavaMemberVisitor(ClassWriter writer, JavaClass toClass, HighLevelDefinition definition) {
-		this.writer = writer;
-		this.toClass = toClass;
-		this.definition = definition;
-
-		final JavaWriter javaWriter = new JavaWriter(writer, new JavaMethodInfo(toClass, "<clinit>", "()V", 0), definition, null, null);
-		this.clinitStatementVisitor = new JavaStatementVisitor(javaWriter);
-		this.clinitStatementVisitor.start();
-		CompilerUtils.writeDefaultFieldInitializers(javaWriter, definition, true);
-	}
+    private final ClassWriter writer;
+	private final JavaBytecodeContext context;
+    private final JavaClass toClass;
+    private final HighLevelDefinition definition;
+    private final JavaStatementVisitor clinitStatementVisitor;
+    private EnumDefinition enumDefinition = null;
+
+    public JavaMemberVisitor(JavaBytecodeContext 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(context, javaWriter);
+        this.clinitStatementVisitor.start();
+        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));
-		writer.visitField(CompilerUtils.calcAccess(member.modifiers), member.name, descriptor, signature, null).visitEnd();
-		member.setTag(JavaFieldInfo.class, new JavaFieldInfo(toClass, member.name, descriptor));
-		return null;
+        //TODO calc signature
+        String signature = null;
+        final String descriptor = context.getDescriptor(member.type);
+        writer.visitField(CompilerUtils.calcAccess(member.modifiers), member.name, descriptor, signature, null).visitEnd();
+        member.setTag(JavaField.class, new JavaField(toClass, member.name, descriptor));
+        return null;
 	}
 
 	@Override
 	public Void visitField(FieldMember member) {
 
-		//TODO calc signature
-		String signature = null;
-		final String descriptor = Type.getDescriptor(member.type.accept(JavaTypeClassVisitor.INSTANCE));
-		writer.visitField(CompilerUtils.calcAccess(member.modifiers), member.name, descriptor, signature, null).visitEnd();
-		member.setTag(JavaFieldInfo.class, new JavaFieldInfo(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);
-		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);
-		constructorWriter.label(constructorStart);
-		CompilerUtils.tagConstructorParameters(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)));
-		}
-
-		final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(constructorWriter);
-		statementVisitor.start();
+        //TODO calc signature
+        String signature = null;
+        final String descriptor = context.getDescriptor(member.type);
+        writer.visitField(CompilerUtils.calcAccess(member.modifiers), member.name, descriptor, signature, null).visitEnd();
+        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 = 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, context.getMethodSignature(member.header), null);
+        constructorWriter.label(constructorStart);
+        CompilerUtils.tagConstructorParameters(context, member.header, isEnum);
+        for (FunctionParameter parameter : member.header.parameters) {
+            constructorWriter.nameVariable(
+                    parameter.getTag(JavaParameterInfo.class).index,
+                    parameter.name,
+                    constructorStart,
+                    constructorEnd,
+                    context.getType(parameter.type));
+        }
+
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, constructorWriter);
+        statementVisitor.start();
 
 		if (!member.isConstructorForwarded()) {
 			if (isEnum) {
 				constructorWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
 			}
 
-			CompilerUtils.writeDefaultFieldInitializers(constructorWriter, definition, false);
-		}
+        }
 
 		member.body.accept(statementVisitor);
 		constructorWriter.label(constructorEnd);
 		final JavaWriter destructorWriter = new JavaWriter(writer, method, definition, null, null);
 		destructorWriter.label(constructorStart);
 
-		final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(destructorWriter);
-		statementVisitor.start();
+        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);
 		destructorWriter.label(constructorEnd);
 		return null;
 	}
 
-	@Override
-	public Void visitMethod(MethodMember member) {
-		CompilerUtils.tagMethodParameters(member.header, member.isStatic());
-
-		final boolean isAbstract = member.body == null || Modifiers.isAbstract(member.modifiers);
-		int modifiers = (isAbstract ? Opcodes.ACC_ABSTRACT : 0)
-				| (member.isStatic() ? Opcodes.ACC_STATIC : 0)
-				| CompilerUtils.calcAccess(member.modifiers);
-		final JavaMethodInfo method = new JavaMethodInfo(
-				toClass,
-				member.name,
-				CompilerUtils.calcSign(member.header, false),
-				modifiers);
+    @Override
+    public Void visitMethod(MethodMember member) {
+        CompilerUtils.tagMethodParameters(context, member.header, member.isStatic());
+
+        final boolean isAbstract = member.body == null || Modifiers.isAbstract(member.modifiers);
+        int modifiers = (isAbstract ? Opcodes.ACC_ABSTRACT : 0)
+                | (member.isStatic() ? Opcodes.ACC_STATIC : 0)
+                | CompilerUtils.calcAccess(member.modifiers);
+        final JavaMethodInfo method = new JavaMethodInfo(
+                toClass,
+                member.name,
+                context.getMethodSignature(member.header),
+                modifiers);
 
 		final Label methodStart = new Label();
 		final Label methodEnd = new Label();
+		//TODO see if this can be changed to Stan's changes (context call maybe?)
 		final JavaWriter methodWriter = new JavaWriter(writer, method, definition, JavaTypeGenericVisitor.getGenericMethodSignature(member.header), null);
 		methodWriter.label(methodStart);
 		for (final FunctionParameter parameter : member.header.parameters) {
 				methodWriter.nameVariable(parameter.getTag(JavaParameterInfo.class).index, parameter.name, methodStart, methodEnd, parameter.type.accept(JavaTypeVisitor.INSTANCE));
 		}
 
-		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;
 	

JavaShared/src/main/java/org/openzen/zenscript/javashared/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.javashared;
+
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public abstract class JavaContext {
+	public abstract String getDescriptor(ITypeID 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();
+    }
+}

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/tags/JavaSourceImplementation.java → JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaImplementation.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 JavaSourceImplementation {
+public class JavaImplementation {
 	public final boolean inline;
 	public final JavaClass implementationClass;
 	
-	public JavaSourceImplementation(boolean inline, JavaClass implementationClass) {
+	public JavaImplementation(boolean inline, JavaClass implementationClass) {
 		this.inline = inline;
 		this.implementationClass = implementationClass;
 	}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/tags/JavaSourceMethod.java → JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaMethod.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;
-import org.openzen.zenscript.javasource.JavaCallCompiler;
+package org.openzen.zenscript.javashared;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class JavaSourceMethod {
+public class JavaMethod {
 	public final JavaClass cls;
 	public final Kind kind;
 	public final String name;
 	public final boolean compile;
-	public final JavaCallCompiler compiler;
+	public final JavaNativeTranslation translation;
+	
+	public final String descriptor;
+	public final int modifiers;
 	
-	public JavaSourceMethod(JavaClass cls, Kind kind, String name, boolean compile) {
+	public JavaMethod(JavaClass cls, Kind kind, String name, boolean compile, String descriptor, int modifiers) {
 		this.cls = cls;
 		this.kind = kind;
 		this.name = name;
 		this.compile = compile;
-		compiler = null;
+		translation = null;
+		
+		this.descriptor = descriptor;
+		this.modifiers = modifiers;
 	}
 	
-	public JavaSourceMethod(JavaCallCompiler compiler) {
+	public JavaMethod(JavaNativeTranslation<?> translation) {
 		this.cls = null;
 		this.kind = Kind.COMPILED;
 		this.name = null;
 		this.compile = false;
-		this.compiler = compiler;
+		this.translation = translation;
+		this.descriptor = "";
+		this.modifiers = 0;
 	}
 	
 	public enum Kind {

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaModifiers.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.Modifiers;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaModifiers {
+	public static final int PUBLIC = 0x0001; // class, field, method
+    public static final int PRIVATE = 0x0002; // class, field, method
+    public static final int PROTECTED = 0x0004; // class, field, method
+    public static final int STATIC = 0x0008; // field, method
+    public static final int FINAL = 0x0010; // class, field, method, parameter
+    public static final int SUPER = 0x0020; // class
+    public static final int SYNCHRONIZED = 0x0020; // method
+    public static final int OPEN = 0x0020; // module
+    public static final int TRANSITIVE = 0x0020; // module requires
+    public static final int VOLATILE = 0x0040; // field
+    public static final int BRIDGE = 0x0040; // method
+    public static final int STATIC_PHASE = 0x0040; // module requires
+    public static final int VARARGS = 0x0080; // method
+    public static final int TRANSIENT = 0x0080; // field
+    public static final int NATIVE = 0x0100; // method
+    public static final int INTERFACE = 0x0200; // class
+    public static final int ABSTRACT = 0x0400; // class, method
+    public static final int STRICT = 0x0800; // method
+    public static final int SYNTHETIC = 0x1000; // class, field, method, parameter, module *
+    public static final int ANNOTATION = 0x2000; // class
+    public static final int ENUM = 0x4000; // class(?) field inner
+    public static final int MANDATED = 0x8000; // parameter, module, module *
+    public static final int MODULE = 0x8000; // class
+	
+	public static int getJavaModifiers(int modifiers) {
+		int out = 0;
+		if (Modifiers.isStatic(modifiers))
+			out |= STATIC;
+		if (Modifiers.isFinal(modifiers))
+			out |= FINAL;
+		if (Modifiers.isPublic(modifiers))
+			out |= PUBLIC;
+		if (Modifiers.isPrivate(modifiers))
+			out |= PRIVATE;
+		if (Modifiers.isProtected(modifiers))
+			out |= PROTECTED;
+		if (Modifiers.isAbstract(modifiers))
+			out |= ABSTRACT;
+		return out;
+	}
+	
+	private JavaModifiers() {}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javashared;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaNativeClass {
+	public final JavaClass cls;
+	private final Map<String, JavaMethod> methods = new HashMap<>();
+	public final boolean nonDestructible;
+	
+	public JavaNativeClass(JavaClass cls) {
+		this(cls, false);
+	}
+	
+	public JavaNativeClass(JavaClass cls, boolean nonDestructible) {
+		this.cls = cls;
+		this.nonDestructible = nonDestructible;
+	}
+	
+	public void addMethod(String key, JavaMethod method) {
+		methods.put(key, method);
+	}
+	
+	public void addConstructor(String key, String descriptor) {
+		methods.put(key, new JavaMethod(cls, JavaMethod.Kind.CONSTRUCTOR, "<init>", false, descriptor, JavaModifiers.PUBLIC));
+	}
+	
+	public void addInstanceMethod(String key, String name, String descriptor) {
+		methods.put(key, new JavaMethod(cls, JavaMethod.Kind.INSTANCE, name, false, descriptor, JavaModifiers.PUBLIC));
+	}
+	
+	public JavaMethod getMethod(String name) {
+		return methods.get(name);
+	}
+}

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaNativeTranslation.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.expression.Expression;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface JavaNativeTranslation<T> {
+	public T translate(Expression expression, JavaNativeTranslator<T> translator);
+}

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaNativeTranslator.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.expression.CallExpression;
+import org.openzen.zenscript.codemodel.expression.CastExpression;
+import org.openzen.zenscript.codemodel.expression.Expression;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface JavaNativeTranslator<T> {
+	T isEmptyAsLengthZero(Expression value);
+	
+	T listToArray(CastExpression value);
+	
+	T containsAsIndexOf(Expression target, Expression value);
+	
+	T sorted(Expression value);
+	
+	T sortedWithComparator(Expression value, Expression comparator);
+	
+	T copy(Expression value);
+	
+	T copyTo(CallExpression call);
+}

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 JavaSyntheticClassGenerator generator;
+	private final boolean optional;
+	
+	public JavaTypeDescriptorVisitor(JavaSyntheticClassGenerator generator) {
+		this(generator, false);
+	}
+	
+	private JavaTypeDescriptorVisitor(JavaSyntheticClassGenerator generator, boolean optional) {
+		this.optional = optional;
+		this.generator = generator;
+		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" + generator.synthesizeFunction(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" + generator.synthesizeRange(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 JavaSyntheticClassGenerator generator;
+	private final boolean optional;
+	
+	public JavaTypeInternalNameVisitor(JavaSyntheticClassGenerator generator) {
+		this(generator, false);
+	}
+	
+	private JavaTypeInternalNameVisitor(JavaSyntheticClassGenerator generator, boolean optional) {
+		this.optional = optional;
+		this.generator = generator;
+		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 generator.synthesizeFunction(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 generator.synthesizeRange(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/JavaSourceTypeNameVisitor.java → JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaTypeNameVisitor.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.FunctionParameter;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
  *
  * @author Hoofdgebruiker
  */
-public class JavaSourceTypeNameVisitor implements ITypeVisitor<String> {
-	public JavaSourceTypeNameVisitor() {}
+public class JavaTypeNameVisitor implements ITypeVisitor<String> {
+	public JavaTypeNameVisitor() {}
 
 	@Override
 	public String visitBasic(BasicTypeID basic) {

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/tags/JavaSourceVariantOption.java → JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaVariantOption.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 JavaSourceVariantOption {
+public class JavaVariantOption {
 	public final JavaClass variantClass;
 	public final JavaClass variantOptionClass;
 	
-	public JavaSourceVariantOption(JavaClass variantClass, JavaClass variantOptionClass) {
+	public JavaVariantOption(JavaClass variantClass, JavaClass variantOptionClass) {
 		this.variantClass = variantClass;
 		this.variantOptionClass = variantOptionClass;
 	}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareClassMethodVisitor.java → JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareClassMethodVisitor.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.javasource.prepare;
+package org.openzen.zenscript.javashared.prepare;
 
+import org.openzen.zenscript.javashared.JavaNativeClass;
 import org.openzen.zencode.shared.StringExpansion;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.annotations.NativeTag;
 import org.openzen.zenscript.codemodel.member.DefinitionMember;
 import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
-import org.openzen.zenscript.javasource.JavaSourceTypeNameVisitor;
+import org.openzen.zenscript.javashared.JavaTypeNameVisitor;
 import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javasource.tags.JavaSourceField;
-import org.openzen.zenscript.javasource.tags.JavaSourceImplementation;
-import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
+import org.openzen.zenscript.javashared.JavaField;
+import org.openzen.zenscript.javashared.JavaContext;
+import org.openzen.zenscript.javashared.JavaImplementation;
+import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaModifiers;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class JavaSourcePrepareClassMethodVisitor implements MemberVisitor<Void> {
+public class JavaPrepareClassMethodVisitor implements MemberVisitor<Void> {
 	private static final boolean DEBUG_EMPTY = true;
 	
-	private final JavaSourcePrepareDefinitionVisitor definitionPreparer;
+	private final JavaContext context;
 	private final String filename;
 	private final JavaClass cls;
 	private final JavaNativeClass nativeClass;
+	private final JavaPrepareDefinitionMemberVisitor memberPreparer;
 	
-	public JavaSourcePrepareClassMethodVisitor(
-			JavaSourcePrepareDefinitionVisitor definitionPreparer,
+	public JavaPrepareClassMethodVisitor(
+			JavaContext context,
 			String filename,
 			JavaClass cls,
 			JavaNativeClass nativeClass,
+			JavaPrepareDefinitionMemberVisitor 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 visitCaster(CasterMember member) {
-		visitFunctional(member, "to" + member.toType.accept(new JavaSourceTypeNameVisitor()));
+		visitFunctional(member, "to" + member.toType.accept(new JavaTypeNameVisitor()));
 		return null;
 	}
 
 
 	@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));
+			member.setTag(JavaImplementation.class, new JavaImplementation(true, cls));
 			for (IDefinitionMember m : member.members)
 				m.accept(this);
 		} else {
 			
 			cls.empty = false;
 			
-			JavaClass implementationClass = new JavaClass(cls, member.type.accept(new JavaSourceTypeNameVisitor()) + "Implementation", JavaClass.Kind.CLASS);
-			member.setTag(JavaSourceImplementation.class, new JavaSourceImplementation(false, implementationClass));
+			JavaClass implementationClass = new JavaClass(cls, member.type.accept(new JavaTypeNameVisitor()) + "Implementation", JavaClass.Kind.CLASS);
+			member.setTag(JavaImplementation.class, new JavaImplementation(false, implementationClass));
 			
-			JavaSourcePrepareClassMethodVisitor visitor = new JavaSourcePrepareClassMethodVisitor(definitionPreparer, filename, implementationClass, null, true);
+			JavaPrepareClassMethodVisitor visitor = new JavaPrepareClassMethodVisitor(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);
+		JavaPrepareDefinitionMemberVisitor innerDefinitionPrepare = new JavaPrepareDefinitionMemberVisitor(context, filename);
 		member.innerDefinition.accept(innerDefinitionPrepare);
 		
 		if (DEBUG_EMPTY && cls.empty)
 		return null;
 	}
 	
-	private JavaSourceMethod.Kind getKind(DefinitionMember member) {
+	private JavaMethod.Kind getKind(DefinitionMember member) {
 		if (member instanceof ConstructorMember)
-			return JavaSourceMethod.Kind.CONSTRUCTOR;
+			return JavaMethod.Kind.CONSTRUCTOR;
 		
-		return member.isStatic() ? JavaSourceMethod.Kind.STATIC : JavaSourceMethod.Kind.INSTANCE;
+		return member.isStatic() ? JavaMethod.Kind.STATIC : JavaMethod.Kind.INSTANCE;
 	}
 	
 	private String getOperatorName(OperatorType operator) {
 		}
 	}
 	
-	private void visitFunctional(DefinitionMember member, String name) {
+	private void visitFunctional(FunctionalMember member, String name) {
 		NativeTag nativeTag = member.getTag(NativeTag.class);
-		JavaSourceMethod method = null;
+		JavaMethod method = null;
 		if (nativeTag != null && nativeClass != null)
 			method = nativeClass.getMethod(nativeTag.value);
 		
 		if (member.getOverrides() != null) {
 			DefinitionMemberRef base = member.getOverrides();
-			JavaSourceMethod baseMethod = base.getTarget().getTag(JavaSourceMethod.class);
+			JavaMethod baseMethod = base.getTarget().getTag(JavaMethod.class);
 			if (baseMethod == null)
 				throw new IllegalStateException("Base method not yet prepared!");
 			
-			method = new JavaSourceMethod(cls, baseMethod.kind, baseMethod.name, true);
+			method = new JavaMethod(cls, baseMethod.kind, baseMethod.name, true, context.getMethodDescriptor(member.header), JavaModifiers.getJavaModifiers(member.modifiers));
 		} else if (method == null) {
-			method = new JavaSourceMethod(cls, getKind(member), name, true);
+			method = new JavaMethod(cls, getKind(member), name, true, context.getMethodDescriptor(member.header), JavaModifiers.getJavaModifiers(member.modifiers));
 		}
 		
 		if (method.compile) {
 			cls.empty = false;
 		}
 		
-		member.setTag(JavaSourceMethod.class, method);
+		member.setTag(JavaMethod.class, method);
 	}
 }

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareDefinitionMemberVisitor.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.prepare;
+
+import org.openzen.zenscript.javashared.JavaNativeClass;
+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.javashared.JavaContext;
+import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaModifiers;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaPrepareDefinitionMemberVisitor implements DefinitionVisitor<JavaClass> {
+	private final JavaContext context;
+	private final String filename;
+	
+	public JavaPrepareDefinitionMemberVisitor(JavaContext 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);
+		JavaMethod method = new JavaMethod(cls, JavaMethod.Kind.STATIC, definition.name, true, context.getMethodDescriptor(definition.header), JavaModifiers.getJavaModifiers(definition.modifiers));
+		definition.caller.setTag(JavaMethod.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);
+		JavaPrepareClassMethodVisitor methodVisitor = new JavaPrepareClassMethodVisitor(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);
+		JavaPrepareExpansionMethodVisitor methodVisitor = new JavaPrepareExpansionMethodVisitor(context, cls, nativeClass);
+		for (IDefinitionMember member : definition.members) {
+			member.accept(methodVisitor);
+		}
+		cls.membersPrepared = true;
+	}
+}

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareDefinitionVisitor.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.prepare;
+
+import org.openzen.zenscript.javashared.JavaNativeClass;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.annotations.NativeTag;
+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.expression.CallExpression;
+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.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaModifiers;
+import org.openzen.zenscript.javashared.JavaVariantOption;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaPrepareDefinitionVisitor implements DefinitionVisitor<JavaClass> {
+	private static final Map<String, JavaNativeClass> nativeClasses = new HashMap<>();
+	
+	static {
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.lang", "StringBuilder", JavaClass.Kind.CLASS));
+			cls.addConstructor("constructor", "()V");
+			cls.addConstructor("constructorWithCapacity", "(I)V");
+			cls.addConstructor("constructorWithValue", "(Ljava/lang/String;)V");
+			cls.addMethod("isEmpty", new JavaMethod((expression, translator) -> translator.isEmptyAsLengthZero(((CallExpression)expression).target)));
+			cls.addInstanceMethod("length", "length", "()I");
+			cls.addInstanceMethod("appendBool", "append", "(Z)Ljava/lang/StringBuilder;");
+			cls.addInstanceMethod("appendByte", "append", "(I)Ljava/lang/StringBuilder;");
+			cls.addInstanceMethod("appendSByte", "append", "(B)Ljava/lang/StringBuilder;");
+			cls.addInstanceMethod("appendShort", "append", "(S)Ljava/lang/StringBuilder;");
+			cls.addInstanceMethod("appendUShort", "append", "(I)Ljava/lang/StringBuilder;");
+			cls.addInstanceMethod("appendInt", "append", "(I)Ljava/lang/StringBuilder;");
+			cls.addInstanceMethod("appendUInt", "append", "(I)Ljava/lang/StringBuilder;");
+			cls.addInstanceMethod("appendLong", "append", "(J)Ljava/lang/StringBuilder;");
+			cls.addInstanceMethod("appendULong", "append", "(J)Ljava/lang/StringBuilder;");
+			cls.addInstanceMethod("appendFloat", "append", "(F)Ljava/lang/StringBuilder;");
+			cls.addInstanceMethod("appendDouble", "append", "(D)Ljava/lang/StringBuilder;");
+			cls.addInstanceMethod("appendChar", "append", "(C)Ljava/lang/StringBuilder;");
+			cls.addInstanceMethod("appendString", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;");
+			cls.addInstanceMethod("asString", "toString", "()Ljava/lang/String;");
+			nativeClasses.put("stdlib::StringBuilder", cls);
+		}
+		
+		{
+			JavaNativeClass list = new JavaNativeClass(new JavaClass("java.util", "List", JavaClass.Kind.INTERFACE));
+			JavaClass arrayList = new JavaClass("java.util", "ArrayList", JavaClass.Kind.CLASS);
+			list.addMethod("constructor", new JavaMethod(arrayList, JavaMethod.Kind.CONSTRUCTOR, "", false, "()V", JavaModifiers.PUBLIC));
+			list.addInstanceMethod("add", "add", "(Ljava/lang/Object;)Z"); List<?> l;
+			list.addInstanceMethod("insert", "add", "(Ljava/lang/Object;I)V");
+			list.addInstanceMethod("remove", "remove", "(java/lang/Object;)Z");
+			list.addInstanceMethod("indexOf", "indexOf", "(java/lang/Object;)I");
+			list.addInstanceMethod("lastIndexOf", "lastIndexOf", "(Ljava/lang/Object;)I");
+			list.addInstanceMethod("getAtIndex", "get", "(I)Ljava/lang/Object;");
+			list.addInstanceMethod("setAtIndex", "set", "(ILjava/lang/Object;)Ljava/lang/Object;");
+			list.addInstanceMethod("contains", "contains", "(Ljava/lang/Object;)Z");
+			list.addMethod("toArray", new JavaMethod((expression, translator) -> translator.listToArray((CastExpression)expression)));
+			list.addInstanceMethod("length", "size", "()I");
+			list.addInstanceMethod("isEmpty", "isEmpty", "()Z");
+			list.addInstanceMethod("iterate", "iterator", "()Ljava/util/Iterator;");
+			nativeClasses.put("stdlib::List", list);
+		}
+		
+		{
+			JavaNativeClass iterable = new JavaNativeClass(new JavaClass("java.lang", "Iterable", JavaClass.Kind.INTERFACE));
+			iterable.addInstanceMethod("iterate", "iterator", "()Ljava/util/Iterator;");
+			nativeClasses.put("stdlib::Iterable", iterable);
+		}
+		
+		{
+			JavaNativeClass iterator = new JavaNativeClass(JavaClass.ITERATOR);
+			iterator.addInstanceMethod("hasNext", "hasNext", "()Z");
+			iterator.addInstanceMethod("next", "next", "()Ljava/lang/Object;");
+			nativeClasses.put("stdlib::Iterator", iterator);
+		}
+		
+		{
+			JavaNativeClass comparable = new JavaNativeClass(new JavaClass("java.lang", "Comparable", JavaClass.Kind.INTERFACE));
+			comparable.addInstanceMethod("compareTo", "compareTo", "(Ljava/lang/Object;)I");
+			nativeClasses.put("stdlib::Comparable", comparable);
+		}
+		
+		{
+			JavaClass integer = new JavaClass("java.lang", "Integer", JavaClass.Kind.CLASS);
+			JavaClass math = new JavaClass("java.lang", "Math", JavaClass.Kind.CLASS);
+			
+			JavaNativeClass cls = new JavaNativeClass(integer);
+			cls.addMethod("min", new JavaMethod(math, JavaMethod.Kind.STATIC, "min", false, "(II)I", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
+			cls.addMethod("max", new JavaMethod(math, JavaMethod.Kind.STATIC, "max", false, "(II)I", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
+			cls.addMethod("toHexString", new JavaMethod(integer, JavaMethod.Kind.EXPANSION, "toHexString", false, "()Ljava/lang/String;", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
+			nativeClasses.put("stdlib::Integer", cls);
+		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.lang", "String", JavaClass.Kind.CLASS));
+			cls.addMethod("contains", new JavaMethod((expression, translator) -> {
+				CallExpression call = (CallExpression)expression;
+				Expression str = call.target;
+				Expression character = call.arguments.arguments[0];
+				return translator.containsAsIndexOf(str, character);
+			}));
+			cls.addInstanceMethod("indexOf", "indexOf", "(I)I");
+			cls.addInstanceMethod("indexOfFrom", "indexOf", "(II)I");
+			cls.addInstanceMethod("lastIndexOf", "lastIndexOf", "(I)I");
+			cls.addInstanceMethod("lastIndexOfFrom", "lastIndexOf", "(II)I");
+			cls.addInstanceMethod("trim", "trim", "()Ljava/lang/String;");
+			nativeClasses.put("stdlib::String", cls);
+		}
+		
+		{
+			JavaClass arrays = new JavaClass("java.lang", "Arrays", JavaClass.Kind.CLASS);
+			JavaNativeClass cls = new JavaNativeClass(arrays);
+			cls.addMethod("sort", new JavaMethod(arrays, JavaMethod.Kind.EXPANSION, "sort", false, "([Ljava/lang/Object;)[Ljava/lang/Object;", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
+			cls.addMethod("sorted", new JavaMethod((expression, translator) -> {
+				return translator.sorted(((CallExpression)expression).target);
+			}));
+			cls.addMethod("sortWithComparator", new JavaMethod(arrays, JavaMethod.Kind.EXPANSION, "sort", false, "([Ljava/lang/Object;Ljava/lang/Comparator;)[Ljava/lang/Object;", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
+			cls.addMethod("sortedWithComparator", new JavaMethod((expression, translator) -> {
+				return translator.sortedWithComparator(
+						((CallExpression)expression).target,
+						((CallExpression)expression).arguments.arguments[0]);
+			}));
+			cls.addMethod("copy", new JavaMethod((expression, translator) -> {
+				return translator.copy(((CallExpression)expression).target);
+			}));
+			cls.addMethod("copyResize", new JavaMethod(arrays, JavaMethod.Kind.EXPANSION, "copyOf", false, "([Ljava/lang/Object;I)[Ljava/lang/Object;", JavaModifiers.PUBLIC | JavaModifiers.STATIC));
+			cls.addMethod("copyTo", new JavaMethod((expression, translator) -> {
+				return translator.copyTo((CallExpression)expression);
+			}));
+			nativeClasses.put("stdlib::Arrays", cls);
+		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.lang", "IllegalArgumentException", JavaClass.Kind.CLASS));
+			cls.addConstructor("constructor", "(Ljava/lang/String;)V");
+			nativeClasses.put("stdlib::IllegalArgumentException", cls);
+		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.lang", "Exception", JavaClass.Kind.CLASS));
+			cls.addConstructor("constructor", "(Ljava/lang/String;)V");
+			cls.addConstructor("constructorWithCause", "(Ljava/lang/String;Ljava/lang/Throwable;)V");
+			nativeClasses.put("stdlib::Exception", cls);
+		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.io", "IOException", JavaClass.Kind.CLASS));
+			cls.addConstructor("constructor", "(Ljava/lang/String;)V");
+			nativeClasses.put("io::IOException", cls);
+		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.io", "Reader", JavaClass.Kind.INTERFACE));
+			cls.addInstanceMethod("destruct", "close", "()V");
+			cls.addInstanceMethod("readCharacter", "read", "()C");
+			cls.addInstanceMethod("readArray", "read", "([C)I");
+			cls.addInstanceMethod("readArraySlice", "read", "([CII)I");
+			nativeClasses.put("io::Reader", cls);
+		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.io", "StringReader", JavaClass.Kind.CLASS), true);
+			cls.addConstructor("constructor", "(Ljava/lang/String;)V");
+			cls.addInstanceMethod("destructor", "close", "()V");
+			cls.addInstanceMethod("readCharacter", "read", "()C");
+			cls.addInstanceMethod("readArray", "read", "([C)I");
+			cls.addInstanceMethod("readSlice", "read", "([CII)I");
+			nativeClasses.put("io::StringReader", cls);
+		}
+	}
+	
+	private final String filename;
+	private final JavaClass outerClass;
+	
+	public JavaPrepareDefinitionVisitor(String filename, JavaClass outerClass) {
+		this.filename = filename;
+		this.outerClass = outerClass;
+	}
+	
+	private boolean isPrepared(HighLevelDefinition definition) {
+		return definition.hasTag(JavaClass.class);
+	}
+	
+	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 = new JavaClass(definition.pkg.fullName, filename, JavaClass.Kind.CLASS);
+		definition.setTag(JavaClass.class, cls);
+		return cls;
+	}
+
+	@Override
+	public JavaClass visitExpansion(ExpansionDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaClass.class);
+		
+		NativeTag nativeTag = definition.getTag(NativeTag.class);
+		if (nativeTag != null) {
+			definition.setTag(JavaNativeClass.class, nativeClasses.get(nativeTag.value));
+		}
+		
+		JavaClass cls = new JavaClass(definition.pkg.fullName, filename, JavaClass.Kind.CLASS);
+		definition.setTag(JavaClass.class, cls);
+		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 = new JavaClass(variant.pkg.fullName, variant.name, JavaClass.Kind.CLASS);
+		variant.setTag(JavaClass.class, cls);
+		
+		for (VariantDefinition.Option option : variant.options) {
+			JavaClass variantCls = new JavaClass(cls.fullName, option.name, JavaClass.Kind.CLASS);
+			option.setTag(JavaVariantOption.class, new JavaVariantOption(cls, variantCls));
+		}
+		
+		return cls;
+	}
+	
+	private JavaClass visitClassCompiled(HighLevelDefinition definition, boolean startsEmpty, JavaClass.Kind kind) {
+		if (definition.getSuperType() != null)
+			prepare(definition.getSuperType());
+		
+		NativeTag nativeTag = definition.getTag(NativeTag.class);
+		JavaNativeClass nativeClass = nativeTag == null ? null : nativeClasses.get(nativeTag.value);
+		JavaClass cls;
+		if (nativeClass == null) {
+			cls = outerClass == null ? new JavaClass(definition.pkg.fullName, definition.name, kind) : new JavaClass(outerClass, definition.name, kind);
+			cls.destructible = definition.isDestructible();
+			definition.setTag(JavaClass.class, cls);
+		} else {
+			cls = outerClass == null ? new JavaClass(definition.pkg.fullName, filename, kind) : new JavaClass(outerClass, filename, kind);
+			definition.setTag(JavaClass.class, nativeClass.cls);
+			definition.setTag(JavaNativeClass.class, nativeClass);
+			
+			if (nativeClass.nonDestructible)
+				cls.destructible = false;
+		}
+		
+		for (IDefinitionMember member : definition.members) {
+			if (member instanceof InnerDefinitionMember) {
+				((InnerDefinitionMember) member).innerDefinition.accept(new JavaPrepareDefinitionVisitor(filename, cls));
+			}
+		}
+		
+		return cls;
+	}
+}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareExpansionMethodVisitor.java → JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareExpansionMethodVisitor.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.javasource.prepare;
+package org.openzen.zenscript.javashared.prepare;
 
+import org.openzen.zenscript.javashared.JavaNativeClass;
 import org.openzen.zencode.shared.StringExpansion;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.annotations.NativeTag;
 import org.openzen.zenscript.codemodel.member.DefinitionMember;
 import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
-import org.openzen.zenscript.javasource.JavaSourceTypeNameVisitor;
+import org.openzen.zenscript.javashared.JavaTypeNameVisitor;
 import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javasource.tags.JavaSourceField;
-import org.openzen.zenscript.javasource.tags.JavaSourceImplementation;
-import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
+import org.openzen.zenscript.javashared.JavaField;
+import org.openzen.zenscript.javashared.JavaContext;
+import org.openzen.zenscript.javashared.JavaImplementation;
+import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaModifiers;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class JavaSourcePrepareExpansionMethodVisitor implements MemberVisitor<Void> {
+public class JavaPrepareExpansionMethodVisitor implements MemberVisitor<Void> {
 	private static final boolean DEBUG_EMPTY = true;
 	
+	private final JavaContext context;
 	private final JavaClass cls;
 	private final JavaNativeClass nativeClass;
 	
-	public JavaSourcePrepareExpansionMethodVisitor(JavaClass cls, JavaNativeClass nativeClass) {
+	public JavaPrepareExpansionMethodVisitor(JavaContext 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;
 
 	@Override
 	public Void visitCaster(CasterMember member) {
-		visitFunctional(member, "to" + member.toType.accept(new JavaSourceTypeNameVisitor()));
+		visitFunctional(member, "to" + member.toType.accept(new JavaTypeNameVisitor()));
 		return null;
 	}
 
 
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
-		JavaClass implementationClass = new JavaClass(cls, member.type.accept(new JavaSourceTypeNameVisitor()) + "Implementation", JavaClass.Kind.CLASS);
-		member.setTag(JavaSourceImplementation.class, new JavaSourceImplementation(false, implementationClass));
+		JavaClass implementationClass = new JavaClass(cls, member.type.accept(new JavaTypeNameVisitor()) + "Implementation", JavaClass.Kind.CLASS);
+		member.setTag(JavaImplementation.class, new JavaImplementation(false, implementationClass));
 		for (IDefinitionMember implementedMember : member.members)
 			implementedMember.accept(this);
 		
 		return null;
 	}
 	
-	private void visitFunctional(DefinitionMember member, String name) {
+	private void visitFunctional(FunctionalMember member, String name) {
 		NativeTag nativeTag = member.getTag(NativeTag.class);
-		JavaSourceMethod method = null;
+		JavaMethod method = null;
 		if (nativeTag != null && nativeClass != null)
 			method = nativeClass.getMethod(nativeTag.value);
 		if (method == null)
-			method = new JavaSourceMethod(cls, getKind(member), name, true); 
+			method = new JavaMethod(cls, getKind(member), name, true, context.getMethodDescriptor(member.header), JavaModifiers.getJavaModifiers(member.modifiers)); 
 		
 		if (method.compile) {
 			if (DEBUG_EMPTY && cls.empty)
 			cls.empty = false;
 		}
 		
-		member.setTag(JavaSourceMethod.class, method);
+		member.setTag(JavaMethod.class, method);
 	}
 	
-	private JavaSourceMethod.Kind getKind(DefinitionMember member) {
-		return member.isStatic() ? JavaSourceMethod.Kind.STATIC : JavaSourceMethod.Kind.EXPANSION;
+	private JavaMethod.Kind getKind(DefinitionMember member) {
+		return member.isStatic() ? JavaMethod.Kind.STATIC : JavaMethod.Kind.EXPANSION;
 	}
 	
 	private String getOperatorName(OperatorType operator) {

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

 public class FormattingUtils {
 	private FormattingUtils() {}
 	
-	public static void formatModifiers(StringBuilder output, int modifiers) {
-		if (Modifiers.isPrivate(modifiers))
-			output.append("private ");
-		if (Modifiers.isProtected(modifiers))
-			output.append("protected ");
-		if (Modifiers.isPublic(modifiers))
-			output.append("public ");
-		if (Modifiers.isExport(modifiers))
-			output.append("export ");
-		if (Modifiers.isStatic(modifiers))
-			output.append("static ");
-		if (Modifiers.isAbstract(modifiers))
-			output.append("abstract ");
-		if (Modifiers.isVirtual(modifiers))
-			output.append("virtual ");
-		if (Modifiers.isFinal(modifiers))
-			output.append("final ");
-		if (Modifiers.isExtern(modifiers))
-			output.append("extern ");
-		if (Modifiers.isImplicit(modifiers))
-			output.append("implicit ");
-		if (Modifiers.isConst(modifiers))
-			output.append("const ");
-		if (Modifiers.isConstOptional(modifiers))
-			output.append("const? ");
-	}
-	
 	public static void formatHeader(StringBuilder result, JavaSourceFormattingSettings settings, FunctionHeader header, JavaSourceTypeVisitor typeFormatter) {
 		FormattingUtils.formatTypeParameters(result, header.typeParameters, typeFormatter);
 		result.append("(");

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.compiler.CompileScope;
 import org.openzen.zenscript.compiler.SemanticModule;
-import org.openzen.zenscript.javasource.prepare.JavaNativeClass;
+import org.openzen.zenscript.javashared.JavaNativeClass;
 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
 import org.openzen.zenscript.javasource.scope.JavaSourceStatementScope;
 import org.openzen.zenscript.javashared.JavaClass;

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

 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
-import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
+import org.openzen.zenscript.javashared.JavaMethod;
 
 /**
  *
 	}
 	
 	private void compileMethod(DefinitionMember member, FunctionHeader header, Statement body) {
-		JavaSourceMethod method = member.getTag(JavaSourceMethod.class);
+		JavaMethod method = member.getTag(JavaMethod.class);
 		if (method == null)
 			throw new AssertionError();
 		if (!method.compile)

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

  */
 package org.openzen.zenscript.javasource;
 
+import org.openzen.zenscript.javashared.JavaTypeNameVisitor;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
 import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javasource.tags.JavaSourceImplementation;
-import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
+import org.openzen.zenscript.javashared.JavaImplementation;
+import org.openzen.zenscript.javashared.JavaMethod;
 
 /**
  *
 	}
 	
 	private void compileMethod(DefinitionMember member, FunctionHeader header, Statement body) {
-		JavaSourceMethod method = member.getTag(JavaSourceMethod.class);
+		JavaMethod method = member.getTag(JavaMethod.class);
 		if (method == null)
 			throw new AssertionError();
 		if (!method.compile)
 
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
-		JavaSourceImplementation implementation = member.getTag(JavaSourceImplementation.class);
+		JavaImplementation implementation = member.getTag(JavaImplementation.class);
 		if (implementation.inline) {
 			for (IDefinitionMember m : member.members) {
 				m.accept(this);
 			}
 		} else {
-			String interfaceName = member.type.accept(new JavaSourceTypeNameVisitor());
+			String interfaceName = member.type.accept(new JavaTypeNameVisitor());
 			String implementationName = interfaceName + "Implementation";
 			
 			begin(ElementType.FIELD);

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

  */
 package org.openzen.zenscript.javasource;
 
+import org.openzen.zenscript.javashared.JavaContext;
 import java.io.File;
 import java.util.HashMap;
 import java.util.Map;
 import org.openzen.zenscript.compiler.CompilationUnit;
 import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.compiler.ZenCodeCompiler;
-import org.openzen.zenscript.javasource.prepare.JavaSourcePrepareDefinitionVisitor;
+import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionVisitor;
 import org.openzen.zenscript.javashared.JavaClass;
 
 /**
 		
 		settings = new JavaSourceFormattingSettings.Builder().build();
 		typeGenerator = new JavaSourceSyntheticTypeGenerator(directory, settings);
-		helperGenerator = new JavaSourceSyntheticHelperGenerator(directory, settings);
+		
+		JavaSourceContext context = new JavaSourceContext(typeGenerator);
+		helperGenerator = new JavaSourceSyntheticHelperGenerator(context, directory, settings);
 		
 		this.directory = directory;
 	}
 	@Override
 	public void addDefinition(HighLevelDefinition definition, SemanticModule module) {
 		String filename = getFilename(definition);
-		JavaSourcePrepareDefinitionVisitor prepare = new JavaSourcePrepareDefinitionVisitor(filename, null);
+		JavaPrepareDefinitionVisitor prepare = new JavaPrepareDefinitionVisitor(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.JavaContext;
+import org.openzen.zenscript.javashared.JavaSyntheticClassGenerator;
+import org.openzen.zenscript.javashared.JavaTypeDescriptorVisitor;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSourceContext extends JavaContext {
+	private final JavaTypeDescriptorVisitor typeDescriptorVisitor;
+	
+	public JavaSourceContext(JavaSyntheticClassGenerator generator) {
+		typeDescriptorVisitor = new JavaTypeDescriptorVisitor(generator);
+	}
+	
+	@Override
+	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.javasource.tags.JavaSourceMethod;
-import org.openzen.zenscript.javasource.tags.JavaSourceVariantOption;
+import org.openzen.zenscript.javashared.JavaField;
+import org.openzen.zenscript.javashared.JavaNativeTranslation;
+import org.openzen.zenscript.javashared.JavaNativeTranslator;
+import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaVariantOption;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class JavaSourceExpressionFormatter implements ExpressionVisitor<ExpressionString> {
+public class JavaSourceExpressionFormatter implements ExpressionVisitor<ExpressionString>, JavaNativeTranslator<ExpressionString> {
 	private static final JavaClass RESULT = new JavaClass("stdlib", "Result", JavaClass.Kind.CLASS);
 	private static final JavaClass RESULT_OK = new JavaClass("stdlib", "Result.Ok", JavaClass.Kind.CLASS);
 	private static final JavaClass RESULT_ERROR = new JavaClass("stdlib", "Result.Error", JavaClass.Kind.CLASS);
 		if (expression.member.getBuiltin() != null) {
 			return visitBuiltinCall(expression, expression.member.getBuiltin());
 		} else {
-			JavaSourceMethod method = expression.member.getTag(JavaSourceMethod.class);
+			JavaMethod method = expression.member.getTag(JavaMethod.class);
 			if (method == null)
 				throw new IllegalStateException("No source method tag for " + expression.member.getCanonicalName() + "!");
 			
-			if (method.kind == JavaSourceMethod.Kind.COMPILED) {
-				return method.compiler.call(this, expression);
+			if (method.kind == JavaMethod.Kind.COMPILED) {
+				return (ExpressionString) method.translation.translate(expression, this);
 			} else {
 				return compileCall(method, expression.target, expression.arguments);
 			}
 		}
 	}
 	
-	private ExpressionString compileCall(JavaSourceMethod method, Expression target, CallArguments arguments) {
+	private ExpressionString compileCall(JavaMethod method, Expression target, CallArguments arguments) {
 		switch (method.kind) {
 			case EXPANSION: {
 				StringBuilder output = new StringBuilder();
 		if (expression.member.getBuiltin() != null)
 			return visitBuiltinCallStatic(expression, expression.member.getBuiltin());
 		
-		JavaSourceMethod method = expression.member.getTag(JavaSourceMethod.class);
+		JavaMethod method = expression.member.getTag(JavaMethod.class);
 		if (method == null)
 			throw new IllegalStateException("No source method tag for " + expression.member.getCanonicalName() + "!");
 		
 		if (expression.member.member.builtin != null)
 			return visitBuiltinCast(expression);
 		
-		JavaSourceMethod method = expression.member.getTag(JavaSourceMethod.class);
+		JavaMethod method = expression.member.getTag(JavaMethod.class);
 		if (method == null)
 			throw new CompileException(expression.position, CompileExceptionCode.INTERNAL_ERROR, "No tag for caster");
 		
-		if (method.kind == JavaSourceMethod.Kind.COMPILED) {
-			return method.compiler.call(this, expression);
+		if (method.kind == JavaMethod.Kind.COMPILED) {
+			return (ExpressionString)method.translation.translate(expression, this);
 		} else {
 			return compileCall(method, expression.target, CallArguments.EMPTY);
 		}
 
 	@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");
 		
 		if (expression.getter.member.builtin != null)
 			return visitBuiltinGetter(expression, expression.getter.member.builtin);
 		
-		JavaSourceMethod method = expression.getter.getTag(JavaSourceMethod.class);
+		JavaMethod method = expression.getter.getTag(JavaMethod.class);
 		StringBuilder result = new StringBuilder();
 		result.append(expression.target.accept(this));
 		result.append(".");
 		if (expression.constructor.getBuiltin() != null)
 			return visitBuiltinConstructor(expression);
 		
-		JavaSourceMethod method = expression.constructor.getTag(JavaSourceMethod.class);
+		JavaMethod method = expression.constructor.getTag(JavaMethod.class);
 		switch (method.kind) {
 			case EXPANSION: {
 				StringBuilder output = new StringBuilder();
 
 	@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)) {
 	
 	@Override
 	public ExpressionString visitVariantValue(VariantValueExpression expression) {
-		JavaSourceVariantOption option = expression.option.getTag(JavaSourceVariantOption.class);
+		JavaVariantOption option = expression.option.getTag(JavaVariantOption.class);
 		
 		StringBuilder result = new StringBuilder();
 		result.append("new ").append(scope.type(option.variantOptionClass));
 		}
 	}
 	
-	public ExpressionString listToArray(CastExpression expression) {
-		Expression target = duplicable(expression.target);
-		ExpressionString targetString = target.accept(this);
-		ArrayTypeID resultType = (ArrayTypeID)expression.type;
-		return new ExpressionString(
-				targetString.value + ".toArray(" + newArray(resultType.elementType, targetString.unaryPostfix(JavaOperator.CALL, ".size()")).value + ")",
-				JavaOperator.CALL);
-	}
-	
 	public ExpressionString unaryPrefix(Expression value, JavaOperator operator) {
 		return value.accept(this).unaryPrefix(operator);
 	}
 				}
 			}
 			case ARRAY_CONTAINS: {
-				JavaSourceMethod method = scope.fileScope.helperGenerator.createArrayContains((ArrayTypeID)call.target.type);
+				JavaMethod method = scope.fileScope.helperGenerator.createArrayContains((ArrayTypeID)call.target.type);
 				return callAsStatic(scope.fileScope.importer.importType(method.cls) + '.' + method.name, call);
 			}
 			case ARRAY_EQUALS: return callAsStatic("Arrays.equals", call);
 		
 		throw new UnsupportedOperationException("Unknown builtin constructor: " + expression.constructor.getBuiltin());
 	}
+
+	@Override
+	public ExpressionString isEmptyAsLengthZero(Expression value) {
+		return value.accept(this).unaryPostfix(JavaOperator.EQUALS, ".length() == 0");
+	}
+
+	@Override
+	public ExpressionString listToArray(CastExpression expression) {
+		Expression target = duplicable(expression.target);
+		ExpressionString targetString = target.accept(this);
+		ArrayTypeID resultType = (ArrayTypeID)expression.type;
+		return new ExpressionString(
+				targetString.value + ".toArray(" + newArray(resultType.elementType, targetString.unaryPostfix(JavaOperator.CALL, ".size()")).value + ")",
+				JavaOperator.CALL);
+	}
+
+	@Override
+	public ExpressionString containsAsIndexOf(Expression target, Expression value) {
+		return target.accept(this)
+				.unaryPostfix(JavaOperator.GREATER_EQUALS, ".indexOf(" + value.accept(this).value + ") >= 0");
+	}
+
+	@Override
+	public ExpressionString sorted(Expression value) {
+		Expression target = duplicable(value);
+		ExpressionString targetString = target.accept(this);
+		ExpressionString copy = new ExpressionString("Arrays.copyOf(" + targetString.value + ", " + targetString.value + ".length).sort()", JavaOperator.CALL);
+		ExpressionString source = hoist(copy, scope.type(target.type));
+		this.target.writeLine("Arrays.sort(" + source.value + ");");
+		return source;
+	}
+
+	@Override
+	public ExpressionString sortedWithComparator(Expression value, Expression comparator) {
+		Expression target = duplicable(value);
+		ExpressionString comparatorString = comparator.accept(this);
+		ExpressionString targetString = target.accept(this);
+		ExpressionString copy = new ExpressionString("Arrays.copyOf(" + targetString.value + ", " + targetString.value + ".length).sort()", JavaOperator.CALL);
+		ExpressionString source = hoist(copy, scope.type(target.type));
+		this.target.writeLine("Arrays.sort(" + source.value + ", " + comparatorString.value + ");");
+		return source;
+	}
+
+	@Override
+	public ExpressionString copy(Expression value) {
+		Expression target = duplicable(value);
+		ExpressionString source = target.accept(this);
+		return new ExpressionString("Arrays.copyOf(" + source.value + ", " + source.value + ".length)", JavaOperator.CALL);
+	}
+
+	@Override
+	public ExpressionString copyTo(CallExpression call) {
+		Expression source = call.target;
+		Expression target = call.arguments.arguments[0];
+		Expression sourceOffset = call.arguments.arguments[1];
+		Expression targetOffset = call.arguments.arguments[2];
+		Expression length = call.arguments.arguments[3];
+		return new ExpressionString("System.arraycopy("
+			+ source.accept(this) + ", "
+			+ sourceOffset.accept(this) + ", "
+			+ target.accept(this) + ", "
+			+ targetOffset.accept(this) + ", "
+			+ length.accept(this) + ")", JavaOperator.CALL);
+	}
 }

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

  */
 package org.openzen.zenscript.javasource;
 
+import org.openzen.zenscript.javashared.JavaContext;
 import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionMemberVisitor;
 
 /**
  *
 		modules.put(definition, module);
 	}
 	
+	public void prepare(JavaContext context) {
+		JavaPrepareDefinitionMemberVisitor visitor = new JavaPrepareDefinitionMemberVisitor(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/JavaSourceSyntheticHelperGenerator.java

 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
+import org.openzen.zenscript.javashared.JavaContext;
+import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaModifiers;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class JavaSourceSyntheticHelperGenerator {
+	private final JavaContext context;
 	private final File directory;
 	private final JavaSourceFormattingSettings settings;
 	private final Map<String, List<String>> members = new HashMap<>();
 	private final JavaClass arrayHelpers = new JavaClass("zsynthetic", "ArrayHelpers", JavaClass.Kind.CLASS);
-	private final Map<ArrayKind, JavaSourceMethod> existingContains = new HashMap<>();
-	private final Map<ArrayKind, JavaSourceMethod> existingIndexOf = new HashMap<>();
+	private final Map<ArrayKind, JavaMethod> existingContains = new HashMap<>();
+	private final Map<ArrayKind, JavaMethod> existingIndexOf = new HashMap<>();
 	
-	public JavaSourceSyntheticHelperGenerator(File directory, JavaSourceFormattingSettings settings) {
+	public JavaSourceSyntheticHelperGenerator(JavaContext context, File directory, JavaSourceFormattingSettings settings) {
+		this.context = context;
 		this.directory = new File(directory, "zsynthetic");
 		this.settings = settings;
 	}
 	
-	public JavaSourceMethod createArrayContains(ArrayTypeID type) {
+	public JavaMethod createArrayContains(ArrayTypeID type) {
 		ArrayKind kind = type.accept(new ArrayKindVisitor());
 		if (existingContains.containsKey(kind))
 			return existingContains.get(kind);
 		String method = generateContains(kind);
 		addMember(arrayHelpers, method);
 		
-		JavaSourceMethod sourceMethod = new JavaSourceMethod(arrayHelpers, JavaSourceMethod.Kind.EXPANSION, kind.containsName, false);
+		String descriptor = "(" + context.getDescriptor(type) + context.getDescriptor(type.elementType) + ")Z";
+		JavaMethod sourceMethod = new JavaMethod(arrayHelpers, JavaMethod.Kind.EXPANSION, kind.containsName, false, descriptor, JavaModifiers.PUBLIC | JavaModifiers.STATIC);
 		existingContains.put(kind, sourceMethod);
 		return sourceMethod;
 	}
 	
-	public JavaSourceMethod createArrayIndexOf(ArrayTypeID type) {
+	public JavaMethod createArrayIndexOf(ArrayTypeID type) {
 		ArrayKind kind = type.accept(new ArrayKindVisitor());
 		if (existingContains.containsKey(kind))
 			return existingContains.get(kind);
 		String method = generateContains(kind);
 		addMember(arrayHelpers, method);
 		
-		JavaSourceMethod sourceMethod = new JavaSourceMethod(arrayHelpers, JavaSourceMethod.Kind.EXPANSION, kind.containsName, false);
+		String descriptor = "(" + context.getDescriptor(type) + ")I";
+		JavaMethod sourceMethod = new JavaMethod(arrayHelpers, JavaMethod.Kind.EXPANSION, kind.containsName, false, descriptor, JavaModifiers.PUBLIC | JavaModifiers.STATIC);
 		existingContains.put(kind, sourceMethod);
 		return sourceMethod;
 	}

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/JavaNativeClass.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 java.util.HashMap;
-import java.util.Map;
-import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class JavaNativeClass {
-	public final JavaClass cls;
-	private final Map<String, JavaSourceMethod> methods = new HashMap<>();
-	public final boolean nonDestructible;
-	
-	public JavaNativeClass(JavaClass cls) {
-		this(cls, false);
-	}
-	
-	public JavaNativeClass(JavaClass cls, boolean nonDestructible) {
-		this.cls = cls;
-		this.nonDestructible = nonDestructible;
-	}
-	
-	public void addMethod(String key, JavaSourceMethod method) {
-		methods.put(key, method);
-	}
-	
-	public void addConstructor(String key, String name) {
-		methods.put(key, new JavaSourceMethod(cls, JavaSourceMethod.Kind.CONSTRUCTOR, name, false));
-	}
-	
-	public void addInstanceMethod(String key, String name) {
-		methods.put(key, new JavaSourceMethod(cls, JavaSourceMethod.Kind.INSTANCE, name, false));
-	}
-	
-	public JavaSourceMethod getMethod(String name) {
-		return methods.get(name);
-	}
-}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareDefinitionVisitor.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 java.util.HashMap;
-import java.util.Map;
-import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.annotations.NativeTag;
-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.expression.CallExpression;
-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.type.DefinitionTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.formattershared.ExpressionString;
-import org.openzen.zenscript.javasource.JavaOperator;
-import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
-import org.openzen.zenscript.javasource.tags.JavaSourceVariantOption;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class JavaSourcePrepareDefinitionVisitor implements DefinitionVisitor<JavaClass> {
-	private static final Map<String, JavaNativeClass> nativeClasses = new HashMap<>();
-	
-	static {
-		{
-			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.lang", "StringBuilder", JavaClass.Kind.CLASS));
-			cls.addConstructor("constructor", "");
-			cls.addConstructor("constructorWithCapacity", "");
-			cls.addConstructor("constructorWithValue", "");
-			cls.addMethod("isEmpty", new JavaSourceMethod((formatter, call) -> ((CallExpression)call).accept(formatter).unaryPostfix(JavaOperator.EQUALS, "length() == 0")));
-			cls.addInstanceMethod("length", "length");
-			cls.addInstanceMethod("appendBool", "append");
-			cls.addInstanceMethod("appendByte", "append");
-			cls.addInstanceMethod("appendSByte", "append");
-			cls.addInstanceMethod("appendShort", "append");
-			cls.addInstanceMethod("appendUShort", "append");
-			cls.addInstanceMethod("appendInt", "append");
-			cls.addInstanceMethod("appendUInt", "append");
-			cls.addInstanceMethod("appendLong", "append");
-			cls.addInstanceMethod("appendULong", "append");
-			cls.addInstanceMethod("appendFloat", "append");
-			cls.addInstanceMethod("appendDouble", "append");
-			cls.addInstanceMethod("appendChar", "append");
-			cls.addInstanceMethod("appendString", "append");
-			cls.addInstanceMethod("asString", "toString");
-			nativeClasses.put("stdlib::StringBuilder", cls);
-		}
-		
-		{
-			JavaNativeClass list = new JavaNativeClass(new JavaClass("java.util", "List", JavaClass.Kind.INTERFACE));
-			JavaClass arrayList = new JavaClass("java.util", "ArrayList", JavaClass.Kind.CLASS);
-			list.addMethod("constructor", new JavaSourceMethod(arrayList, JavaSourceMethod.Kind.CONSTRUCTOR, "", false));
-			list.addInstanceMethod("add", "add");
-			list.addInstanceMethod("insert", "add");
-			list.addInstanceMethod("remove", "remove");
-			list.addInstanceMethod("indexOf", "indexOf");
-			list.addInstanceMethod("lastIndexOf", "lastIndexOf");
-			list.addInstanceMethod("getAtIndex", "get");
-			list.addInstanceMethod("setAtIndex", "set");
-			list.addInstanceMethod("contains", "contains");
-			list.addMethod("toArray", new JavaSourceMethod((formatter, call) -> formatter.listToArray((CastExpression)call)));
-			list.addInstanceMethod("length", "size");
-			list.addInstanceMethod("isEmpty", "isEmpty");
-			list.addInstanceMethod("iterate", "iterator");
-			nativeClasses.put("stdlib::List", list);
-		}
-		
-		{
-			JavaNativeClass iterable = new JavaNativeClass(new JavaClass("java.lang", "Iterable", JavaClass.Kind.INTERFACE));
-			iterable.addInstanceMethod("iterate", "iterator");
-			nativeClasses.put("stdlib::Iterable", iterable);
-		}
-		
-		{
-			JavaNativeClass iterator = new JavaNativeClass(JavaClass.ITERATOR);
-			iterator.addInstanceMethod("hasNext", "hasNext");
-			iterator.addInstanceMethod("next", "next");
-			nativeClasses.put("stdlib::Iterator", iterator);
-		}
-		
-		{
-			JavaNativeClass comparable = new JavaNativeClass(new JavaClass("java.lang", "Comparable", JavaClass.Kind.INTERFACE));
-			comparable.addInstanceMethod("compareTo", "compareTo");
-			nativeClasses.put("stdlib::Comparable", comparable);
-		}
-		
-		{
-			JavaClass integer = new JavaClass("java.lang", "Integer", JavaClass.Kind.CLASS);
-			JavaClass math = new JavaClass("java.lang", "Math", JavaClass.Kind.CLASS);
-			
-			JavaNativeClass cls = new JavaNativeClass(integer);
-			cls.addMethod("min", new JavaSourceMethod(math, JavaSourceMethod.Kind.STATIC, "min", false));
-			cls.addMethod("max", new JavaSourceMethod(math, JavaSourceMethod.Kind.STATIC, "max", false));
-			cls.addMethod("toHexString", new JavaSourceMethod(integer, JavaSourceMethod.Kind.EXPANSION, "toHexString", false));
-			nativeClasses.put("stdlib::Integer", cls);
-		}
-		
-		{
-			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.lang", "String", JavaClass.Kind.CLASS));
-			cls.addMethod("contains", new JavaSourceMethod((formatter, calle) -> {
-				CallExpression call = (CallExpression)calle;
-				ExpressionString str = call.arguments.arguments[0].accept(formatter);
-				ExpressionString character = call.arguments.arguments[1].accept(formatter);
-				return str.unaryPostfix(JavaOperator.GREATER_EQUALS, ".indexOf(" + character.value + ")");
-			}));
-			cls.addInstanceMethod("indexOf", "indexOf");
-			cls.addInstanceMethod("indexOfFrom", "indexOf");
-			cls.addInstanceMethod("lastIndexOf", "lastIndexOf");
-			cls.addInstanceMethod("lastIndexOfFrom", "lastIndexOf");
-			cls.addInstanceMethod("trim", "trim");
-			nativeClasses.put("stdlib::String", cls);
-		}
-		
-		{
-			JavaClass arrays = new JavaClass("java.lang", "Arrays", JavaClass.Kind.CLASS);
-			JavaNativeClass cls = new JavaNativeClass(arrays);
-			cls.addMethod("sort", new JavaSourceMethod(arrays, JavaSourceMethod.Kind.EXPANSION, "sort", false));
-			cls.addMethod("sorted", new JavaSourceMethod((formatter, calle) -> {
-				Expression target = formatter.duplicable(((CallExpression)calle).target);
-				ExpressionString targetString = target.accept(formatter);
-				ExpressionString copy = new ExpressionString("Arrays.copyOf(" + targetString.value + ", " + targetString.value + ".length).sort()", JavaOperator.CALL);
-				ExpressionString source = formatter.hoist(copy, formatter.scope.type(target.type));
-				formatter.target.writeLine("Arrays.sort(" + source.value + ");");
-				return source;
-			}));
-			cls.addMethod("sortWithComparator", new JavaSourceMethod(arrays, JavaSourceMethod.Kind.EXPANSION, "sort", false));
-			cls.addMethod("sortedWithComparator", new JavaSourceMethod((formatter, calle) -> {
-				Expression target = formatter.duplicable(((CallExpression)calle).target);
-				ExpressionString comparator = ((CallExpression)calle).arguments.arguments[0].accept(formatter);
-				ExpressionString targetString = target.accept(formatter);
-				ExpressionString copy = new ExpressionString("Arrays.copyOf(" + targetString.value + ", " + targetString.value + ".length).sort()", JavaOperator.CALL);
-				ExpressionString source = formatter.hoist(copy, formatter.scope.type(target.type));
-				formatter.target.writeLine("Arrays.sort(" + source.value + ", " + comparator.value + ");");
-				return source;
-			}));
-			cls.addMethod("copy", new JavaSourceMethod((formatter, calle) -> {
-				Expression target = formatter.duplicable(((CallExpression)calle).target);
-				ExpressionString source = target.accept(formatter);
-				return new ExpressionString("Arrays.copyOf(" + source.value + ", " + source.value + ".length)", JavaOperator.CALL);
-			}));
-			cls.addMethod("copyResize", new JavaSourceMethod(arrays, JavaSourceMethod.Kind.EXPANSION, "copyOf", false));
-			cls.addMethod("copyTo", new JavaSourceMethod((formatter, calle) -> {
-				CallExpression call = (CallExpression)calle;
-				Expression source = call.target;
-				Expression target = call.arguments.arguments[0];
-				Expression sourceOffset = call.arguments.arguments[1];
-				Expression targetOffset = call.arguments.arguments[2];
-				Expression length = call.arguments.arguments[3];
-				return new ExpressionString("System.arraycopy("
-					+ source.accept(formatter) + ", "
-					+ sourceOffset.accept(formatter) + ", "
-					+ target.accept(formatter) + ", "
-					+ targetOffset.accept(formatter) + ", "
-					+ length.accept(formatter) + ")", JavaOperator.CALL);
-			}));
-			nativeClasses.put("stdlib::Arrays", cls);
-		}
-		
-		{
-			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.lang", "IllegalArgumentException", JavaClass.Kind.CLASS));
-			cls.addConstructor("constructor", "");
-			nativeClasses.put("stdlib::IllegalArgumentException", cls);
-		}
-		
-		{
-			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.lang", "Exception", JavaClass.Kind.CLASS));
-			cls.addConstructor("constructor", "");
-			cls.addConstructor("constructorWithCause", "");
-			nativeClasses.put("stdlib::Exception", cls);
-		}
-		
-		{
-			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.io", "IOException", JavaClass.Kind.CLASS));
-			cls.addConstructor("constructor", "");
-			nativeClasses.put("io::IOException", cls);
-		}
-		
-		{
-			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.io", "Reader", JavaClass.Kind.INTERFACE));
-			cls.addInstanceMethod("destruct", "close");
-			cls.addInstanceMethod("readCharacter", "read");
-			cls.addInstanceMethod("readArray", "read");
-			cls.addInstanceMethod("readArraySlice", "read");
-			nativeClasses.put("io::Reader", cls);
-		}
-		
-		{
-			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.io", "StringReader", JavaClass.Kind.CLASS), true);
-			cls.addConstructor("constructor", "");
-			cls.addInstanceMethod("destructor", "close");
-			cls.addInstanceMethod("readCharacter", "read");
-			cls.addInstanceMethod("readSlice", "read");
-			nativeClasses.put("io::StringReader", cls);
-		}
-	}
-	
-	private final String filename;
-	private final JavaClass outerClass;
-	
-	public JavaSourcePrepareDefinitionVisitor(String filename, JavaClass outerClass) {
-		this.filename = filename;
-		this.outerClass = outerClass;
-	}
-	
-	private boolean isPrepared(HighLevelDefinition definition) {
-		return definition.hasTag(JavaClass.class);
-	}
-	
-	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 = new JavaClass(definition.pkg.fullName, filename, JavaClass.Kind.CLASS);
-		definition.setTag(JavaClass.class, cls);
-		JavaSourceMethod method = new JavaSourceMethod(cls, JavaSourceMethod.Kind.STATIC, definition.name, true);
-		definition.caller.setTag(JavaSourceMethod.class, method);
-		return cls;
-	}
-
-	@Override
-	public JavaClass visitExpansion(ExpansionDefinition definition) {
-		if (isPrepared(definition))
-			return definition.getTag(JavaClass.class);
-		
-		NativeTag nativeTag = definition.getTag(NativeTag.class);
-		JavaNativeClass nativeClass = null;
-		if (nativeTag != null) {
-			nativeClass = 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;
-	}
-
-	@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 = new JavaClass(variant.pkg.fullName, variant.name, JavaClass.Kind.CLASS);
-		variant.setTag(JavaClass.class, cls);
-		
-		for (VariantDefinition.Option option : variant.options) {
-			JavaClass variantCls = new JavaClass(cls.fullName, option.name, JavaClass.Kind.CLASS);
-			option.setTag(JavaSourceVariantOption.class, new JavaSourceVariantOption(cls, variantCls));
-		}
-		
-		visitClassMembers(variant, cls, null, false);
-		return cls;
-	}
-	
-	private JavaClass visitClassCompiled(HighLevelDefinition definition, boolean startsEmpty, JavaClass.Kind kind) {
-		if (definition.getSuperType() != null)
-			prepare(definition.getSuperType());
-		
-		NativeTag nativeTag = definition.getTag(NativeTag.class);
-		JavaNativeClass nativeClass = nativeTag == null ? null : nativeClasses.get(nativeTag.value);
-		if (nativeClass == null) {
-			JavaClass 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);
-			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);
-		}
-	}
-}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourceSignatureVisitor.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;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class JavaSourceSignatureVisitor {
-	
-}

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() {