Added type preparation.

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaContext.java → JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaBytecodeContext.java

 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;
  *
  * @author Hoofdgebruiker
  */
-public class JavaContext {
+public class JavaBytecodeContext extends JavaContext {
 	private final JavaModule module;
 	private final TypeGenerator typeGenerator;
 	private final JavaTypeInternalNameVisitor internalNameVisitor;
 	private final JavaTypeDescriptorVisitor descriptorVisitor;
 	
-	public JavaContext(JavaModule module) {
+	public JavaBytecodeContext(JavaModule module) {
 		this.module = module;
 		
 		typeGenerator = new TypeGenerator();
 		return typeGenerator;
 	}
 	
+	@Override
 	public String getDescriptor(ITypeID type) {
 		return type.accept(descriptorVisitor);
 	}
 		return Type.getType(getDescriptor(type));
 	}
 	
-	public String getMethodDescriptor(FunctionHeader header) {
-		return getMethodDescriptor(header, false);
-	}
-	
-    public String getMethodSignature(FunctionHeader header) {
-        StringBuilder signatureBuilder = new StringBuilder("(");
-        for (FunctionParameter parameter : header.parameters) {
-            signatureBuilder.append(getDescriptor(parameter.type));
-        }
-        signatureBuilder.append(")").append(getDescriptor(header.returnType));
-        return signatureBuilder.toString();
-    }
-	
-	public String getEnumConstructorDescriptor(FunctionHeader header) {
-		return getMethodDescriptor(header, true);
-	}
-	
-	private String getMethodDescriptor(FunctionHeader header, boolean isEnumConstructor) {
-        StringBuilder descBuilder = new StringBuilder("(");
-        if (isEnumConstructor)
-            descBuilder.append("Ljava/lang/String;I");
-		
-        for (FunctionParameter parameter : header.parameters) {
-			descBuilder.append(getDescriptor(parameter.type));
-        }
-        descBuilder.append(")");
-        descBuilder.append(getDescriptor(header.returnType));
-        return descBuilder.toString();
-    }
-	
 	public void register(String name, byte[] bytecode) {
 		module.register(name, bytecode);
 	}
 
 		@Override
 		public JavaSynthesizedClass synthesizeFunction(FunctionTypeID type) {
-			return CompilerUtils.getLambdaInterface(JavaContext.this, type);
+			return CompilerUtils.getLambdaInterface(JavaBytecodeContext.this, type);
 		}
 
 		@Override

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 int generatedScriptBlockCounter = 0;
 	private boolean finished = false;
 	private final File jarFile;
-	private final JavaContext context;
+	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.context = new JavaContext(target);
+		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(context, 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(context, 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) {
 			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();

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 java.util.HashMap;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
-import org.openzen.zenscript.javabytecode.JavaContext;
+import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaSynthesizedClass;
 import org.openzen.zenscript.javashared.JavaSynthesizedClassNamer;
 		return position.getFilename().substring(0, position.getFilename().lastIndexOf('.')).replace("/", "_");
 	}
 
-    public static void tagMethodParameters(JavaContext context, FunctionHeader header, boolean isStatic) {
+    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);
         }
     }
 
-    public static void tagConstructorParameters(JavaContext context, FunctionHeader header, boolean isEnum) {
+    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);
         }
     }
 
-    public static void writeDefaultFieldInitializers(JavaContext context, JavaWriter constructorWriter, HighLevelDefinition definition, boolean staticFields) {
+    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))
 
 	private static final Map<String, JavaSynthesizedClass> functions = new HashMap<>();
 	
-    public static JavaSynthesizedClass getLambdaInterface(JavaContext context, FunctionTypeID function) {
+    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);
 		
         return result;
     }
 
-    private static void createLambdaInterface(JavaContext context, FunctionHeader header, JavaClass cls) {
+    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.getClassName(), null, "java/lang/Object", null);
+        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(
 					null)
 				.visitEnd();
 
-        context.register(cls.internalName, ifaceWriter.toByteArray());
+        context.register(cls.internalName.replace('/', '.'), ifaceWriter.toByteArray());
 
         try (FileOutputStream out = new FileOutputStream(cls.getClassName() + ".class")){
             out.write(ifaceWriter.toByteArray());

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

 
 	protected final JavaWriter javaWriter;
 	private final JavaCapturedExpressionVisitor capturedExpressionVisitor = new JavaCapturedExpressionVisitor(this);
-	private final JavaContext context;
+	private final JavaBytecodeContext context;
 
-    public JavaExpressionVisitor(JavaContext context, JavaWriter javaWriter) {
+    public JavaExpressionVisitor(JavaBytecodeContext context, JavaWriter javaWriter) {
         this.javaWriter = javaWriter;
 		this.context = context;
     }
 		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());

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

 import org.openzen.zenscript.codemodel.expression.TryRethrowAsResultExpression;
 import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
-import org.openzen.zenscript.javabytecode.JavaContext;
+import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 import org.openzen.zenscript.javabytecode.JavaParameterInfo;
 
 public class JavaPreDecrementVisitor implements ExpressionVisitor<Void> {
 	private final JavaExpressionVisitor expressionCompiler;
 	private final JavaWriter javaWriter;
-	private final JavaContext context;
+	private final JavaBytecodeContext context;
 	
-	public JavaPreDecrementVisitor(JavaContext context, JavaExpressionVisitor expressionCompiler) {
+	public JavaPreDecrementVisitor(JavaBytecodeContext context, JavaExpressionVisitor expressionCompiler) {
 		this.expressionCompiler = expressionCompiler;
 		this.context = context;
 		javaWriter = expressionCompiler.getJavaWriter();

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

 import org.openzen.zenscript.codemodel.expression.TryRethrowAsResultExpression;
 import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
-import org.openzen.zenscript.javabytecode.JavaContext;
+import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 import org.openzen.zenscript.javabytecode.JavaParameterInfo;
 
  */
 public class JavaPreIncrementVisitor implements ExpressionVisitor<Void> {
 	private final JavaExpressionVisitor expressionCompiler;
-	private final JavaContext context;
+	private final JavaBytecodeContext context;
 	private final JavaWriter javaWriter;
 	
-	public JavaPreIncrementVisitor(JavaContext context, JavaExpressionVisitor expressionCompiler) {
+	public JavaPreIncrementVisitor(JavaBytecodeContext context, JavaExpressionVisitor expressionCompiler) {
 		this.expressionCompiler = expressionCompiler;
 		this.context = context;
 		javaWriter = expressionCompiler.getJavaWriter();

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

 
 import java.util.Arrays;
 import java.util.List;
-import org.openzen.zenscript.javabytecode.JavaContext;
+import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javashared.JavaClass;
 
 public class JavaStatementVisitor implements StatementVisitor<Boolean> {
     private final JavaWriter javaWriter;
-	private final JavaContext context;
+	private final JavaBytecodeContext context;
     public JavaExpressionVisitor expressionVisitor;
 
     /**
      * @param javaWriter the method writer that compiles the statement
      */
-    public JavaStatementVisitor(JavaContext context, JavaWriter javaWriter) {
+    public JavaStatementVisitor(JavaBytecodeContext context, JavaWriter javaWriter) {
         this.javaWriter = javaWriter;
 		this.context = context;
         this.expressionVisitor = new JavaExpressionVisitor(context, javaWriter);
     }
 
-    public JavaStatementVisitor(JavaContext context, JavaExpressionVisitor expressionVisitor) {
+    public JavaStatementVisitor(JavaBytecodeContext context, JavaExpressionVisitor expressionVisitor) {
         this.javaWriter = expressionVisitor.getJavaWriter();
 		this.context = context;
         this.expressionVisitor = expressionVisitor;

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

 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.javabytecode.JavaContext;
+import org.openzen.zenscript.javabytecode.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 JavaContext context;
+	private final JavaBytecodeContext context;
 
-    public JavaDefinitionVisitor(JavaContext context, JavaClassWriter outerWriter) {
+    public JavaDefinitionVisitor(JavaBytecodeContext context, JavaClassWriter outerWriter) {
 		this.context = context;
 		this.outerWriter = outerWriter;
 	}
 		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
 				StringBuilder builder = new StringBuilder();
 				for (int i = 0; i < option.types.length; ++i) {
 					builder.append("<T").append(i).append(":");
-					builder.append(option.types[i].accept(JavaTypeVisitor.INSTANCE).getDescriptor());
+					builder.append(context.getDescriptor(option.types[i]));
 				}
 				builder.append(">");
 				builder.append("L").append(variantName).append(";");
 			}
 
 			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("(");
 
 			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);
 				optionWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "Field" + i, internalName, "TT" + i + ";", 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.javabytecode.compiler.*;
 
 import java.util.List;
-import org.openzen.zenscript.javabytecode.JavaContext;
+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 JavaContext context;
+	private final JavaBytecodeContext context;
     private final JavaClass toClass;
     private final HighLevelDefinition definition;
     private final JavaStatementVisitor clinitStatementVisitor;
     private EnumDefinition enumDefinition = null;
 
-    public JavaMemberVisitor(JavaContext context, ClassWriter writer, JavaClass toClass, HighLevelDefinition definition) {
+    public JavaMemberVisitor(JavaBytecodeContext context, ClassWriter writer, JavaClass toClass, HighLevelDefinition definition) {
         this.writer = writer;
         this.toClass = toClass;
         this.definition = definition;

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/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);
+}

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

 
 public class JavaTypeDescriptorVisitor implements ITypeVisitor<String> {
 	private final JavaTypeDescriptorVisitor forOptional;
+	private final JavaSyntheticClassGenerator generator;
 	private final boolean optional;
 	
 	public JavaTypeDescriptorVisitor(JavaSyntheticClassGenerator generator) {
 	
 	private JavaTypeDescriptorVisitor(JavaSyntheticClassGenerator generator, boolean optional) {
 		this.optional = optional;
+		this.generator = generator;
 		forOptional = optional ? this : new JavaTypeDescriptorVisitor(generator, true);
 	}
 	
 
     @Override
     public String visitFunction(FunctionTypeID function) {
-        return "L" + JavaSynthesizedClassNamer.createFunctionName(function).cls.internalName + ";";
+        return "L" + generator.synthesizeFunction(function).cls.internalName + ";";
     }
 
     @Override
 
     @Override
     public String visitRange(RangeTypeID range) {
-		return "L" + JavaSynthesizedClassNamer.createRangeName(range).cls.internalName + ";";
+		return "L" + generator.synthesizeRange(range).cls.internalName + ";";
     }
 
     @Override

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

 
 public class JavaTypeInternalNameVisitor implements ITypeVisitor<String> {
 	private final JavaTypeInternalNameVisitor forOptional;
+	private final JavaSyntheticClassGenerator generator;
 	private final boolean optional;
 	
 	public JavaTypeInternalNameVisitor(JavaSyntheticClassGenerator generator) {
 	
 	private JavaTypeInternalNameVisitor(JavaSyntheticClassGenerator generator, boolean optional) {
 		this.optional = optional;
+		this.generator = generator;
 		forOptional = optional ? this : new JavaTypeInternalNameVisitor(generator, true);
 	}
 	
 
     @Override
     public String visitFunction(FunctionTypeID function) {
-        return JavaSynthesizedClassNamer.createFunctionName(function).cls.internalName;
+        return generator.synthesizeFunction(function).cls.internalName;
     }
 
     @Override
 
     @Override
     public String visitRange(RangeTypeID range) {
-		return JavaSynthesizedClassNamer.createRangeName(range).cls.internalName;
+		return generator.synthesizeRange(range).cls.internalName;
     }
 
     @Override

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.javashared.JavaField;
-import org.openzen.zenscript.javasource.JavaSourceContext;
-import org.openzen.zenscript.javasource.tags.JavaSourceImplementation;
-import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
+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 JavaSourceContext context;
+	private final JavaContext context;
 	private final String filename;
 	private final JavaClass cls;
 	private final JavaNativeClass nativeClass;
-	private final JavaSourcePrepareDefinitionMemberVisitor memberPreparer;
+	private final JavaPrepareDefinitionMemberVisitor memberPreparer;
 	
-	public JavaSourcePrepareClassMethodVisitor(
-			JavaSourceContext context,
+	public JavaPrepareClassMethodVisitor(
+			JavaContext context,
 			String filename,
 			JavaClass cls,
 			JavaNativeClass nativeClass,
-			JavaSourcePrepareDefinitionMemberVisitor memberPreparer,
+			JavaPrepareDefinitionMemberVisitor memberPreparer,
 			boolean startsEmpty) {
 		this.context = context;
 		this.filename = filename;
 
 	@Override
 	public Void visitCaster(CasterMember member) {
-		visitFunctional(member, "to" + member.toType.accept(new JavaSourceTypeNameVisitor()));
+		visitFunctional(member, "to" + member.toType.accept(new JavaTypeNameVisitor()));
 		return null;
 	}
 
 		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(context, filename, implementationClass, null, memberPreparer, 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) {
-		JavaSourcePrepareDefinitionMemberVisitor innerDefinitionPrepare = new JavaSourcePrepareDefinitionMemberVisitor(context, filename);
+		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);
 	}
 }

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareDefinitionMemberVisitor.java → JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareDefinitionMemberVisitor.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.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javasource.JavaSourceContext;
-import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
+import org.openzen.zenscript.javashared.JavaContext;
+import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaModifiers;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class JavaSourcePrepareDefinitionMemberVisitor implements DefinitionVisitor<JavaClass> {
-	private final JavaSourceContext context;
+public class JavaPrepareDefinitionMemberVisitor implements DefinitionVisitor<JavaClass> {
+	private final JavaContext context;
 	private final String filename;
 	
-	public JavaSourcePrepareDefinitionMemberVisitor(JavaSourceContext context, String filename) {
+	public JavaPrepareDefinitionMemberVisitor(JavaContext context, String filename) {
 		this.context = context;
 		this.filename = filename;
 	}
 			return definition.getTag(JavaClass.class);
 		
 		JavaClass cls = definition.getTag(JavaClass.class);
-		JavaSourceMethod method = new JavaSourceMethod(cls, JavaSourceMethod.Kind.STATIC, definition.name, true);
-		definition.caller.setTag(JavaSourceMethod.class, method);
+		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;
 	}
 
 	
 	private void visitClassMembers(HighLevelDefinition definition, JavaClass cls, JavaNativeClass nativeClass, boolean startsEmpty) {
 		System.out.println("Preparing " + cls.internalName);
-		JavaSourcePrepareClassMethodVisitor methodVisitor = new JavaSourcePrepareClassMethodVisitor(context, filename, cls, nativeClass, this, startsEmpty);
+		JavaPrepareClassMethodVisitor methodVisitor = new JavaPrepareClassMethodVisitor(context, filename, cls, nativeClass, this, startsEmpty);
 		for (IDefinitionMember member : definition.members) {
 			member.accept(methodVisitor);
 		}
 	
 	private void visitExpansionMembers(HighLevelDefinition definition, JavaClass cls, JavaNativeClass nativeClass) {
 		System.out.println("Preparing " + cls.internalName);
-		JavaSourcePrepareExpansionMethodVisitor methodVisitor = new JavaSourcePrepareExpansionMethodVisitor(context, cls, nativeClass);
+		JavaPrepareExpansionMethodVisitor methodVisitor = new JavaPrepareExpansionMethodVisitor(context, cls, nativeClass);
 		for (IDefinitionMember member : definition.members) {
 			member.accept(methodVisitor);
 		}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareDefinitionVisitor.java → JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareDefinitionVisitor.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 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.member.InnerDefinitionMember;
 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;
+import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaModifiers;
+import org.openzen.zenscript.javashared.JavaVariantOption;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class JavaSourcePrepareDefinitionVisitor implements DefinitionVisitor<JavaClass> {
+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", "");
-			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");
+			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 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");
+			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");
+			iterable.addInstanceMethod("iterate", "iterator", "()Ljava/util/Iterator;");
 			nativeClasses.put("stdlib::Iterable", iterable);
 		}
 		
 		{
 			JavaNativeClass iterator = new JavaNativeClass(JavaClass.ITERATOR);
-			iterator.addInstanceMethod("hasNext", "hasNext");
-			iterator.addInstanceMethod("next", "next");
+			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");
+			comparable.addInstanceMethod("compareTo", "compareTo", "(Ljava/lang/Object;)I");
 			nativeClasses.put("stdlib::Comparable", comparable);
 		}
 		
 			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));
+			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 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.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");
-			cls.addInstanceMethod("indexOfFrom", "indexOf");
-			cls.addInstanceMethod("lastIndexOf", "lastIndexOf");
-			cls.addInstanceMethod("lastIndexOfFrom", "lastIndexOf");
-			cls.addInstanceMethod("trim", "trim");
+			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 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("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 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("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 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("copy", new JavaMethod((expression, translator) -> {
+				return translator.copy(((CallExpression)expression).target);
 			}));
-			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);
+			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", "");
+			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", "");
-			cls.addConstructor("constructorWithCause", "");
+			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", "");
+			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");
-			cls.addInstanceMethod("readCharacter", "read");
-			cls.addInstanceMethod("readArray", "read");
-			cls.addInstanceMethod("readArraySlice", "read");
+			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", "");
-			cls.addInstanceMethod("destructor", "close");
-			cls.addInstanceMethod("readCharacter", "read");
-			cls.addInstanceMethod("readSlice", "read");
+			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 JavaSourcePrepareDefinitionVisitor(String filename, JavaClass outerClass) {
+	public JavaPrepareDefinitionVisitor(String filename, JavaClass outerClass) {
 		this.filename = filename;
 		this.outerClass = outerClass;
 	}
 		
 		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));
+			option.setTag(JavaVariantOption.class, new JavaVariantOption(cls, variantCls));
 		}
 		
 		return cls;
 		
 		for (IDefinitionMember member : definition.members) {
 			if (member instanceof InnerDefinitionMember) {
-				((InnerDefinitionMember) member).innerDefinition.accept(new JavaSourcePrepareDefinitionVisitor(filename, cls));
+				((InnerDefinitionMember) member).innerDefinition.accept(new JavaPrepareDefinitionVisitor(filename, 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.javashared.JavaField;
-import org.openzen.zenscript.javasource.JavaSourceContext;
-import org.openzen.zenscript.javasource.tags.JavaSourceImplementation;
-import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
+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 JavaSourceContext context;
+	private final JavaContext context;
 	private final JavaClass cls;
 	private final JavaNativeClass nativeClass;
 	
-	public JavaSourcePrepareExpansionMethodVisitor(JavaSourceContext context, JavaClass cls, JavaNativeClass nativeClass) {
+	public JavaPrepareExpansionMethodVisitor(JavaContext context, JavaClass cls, JavaNativeClass nativeClass) {
 		this.cls = cls;
 		this.nativeClass = nativeClass;
 		this.context = context;
 
 	@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);
 		
 		File file = new File(getDirectory(definition.pkg), cls.getName() + ".java");

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

 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 {
+public class JavaSourceContext extends JavaContext {
 	private final JavaTypeDescriptorVisitor typeDescriptorVisitor;
 	
-	public JavaSourceContext(JavaSourceSyntheticTypeGenerator generator) {
+	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.javasource.scope.JavaSourceStatementScope;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaField;
-import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
-import org.openzen.zenscript.javasource.tags.JavaSourceVariantOption;
+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);
 		}
 		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 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.javasource.prepare.JavaSourcePrepareDefinitionMemberVisitor;
+import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionMemberVisitor;
 
 /**
  *
 		modules.put(definition, module);
 	}
 	
-	public void prepare(JavaSourceContext context) {
-		JavaSourcePrepareDefinitionMemberVisitor visitor = new JavaSourcePrepareDefinitionMemberVisitor(context, file.getName());
+	public void prepare(JavaContext context) {
+		JavaPrepareDefinitionMemberVisitor visitor = new JavaPrepareDefinitionMemberVisitor(context, file.getName());
 		
 		if (mainDefinition != null)
 			mainDefinition.accept(visitor);

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/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/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 {
-	
-}