New Codestyle in JavaBytecodeCompiler

- Tabs instead of spaces

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/implementations/IntRange.java

@@ -1,12 +1,12 @@
 package org.openzen.zenscript.implementations;
 
 public class IntRange {
-    public final int from;
-    public final int to;
+	public final int from;
+	public final int to;
 
 
-    public IntRange(int from, int to) {
-        this.from = from;
-        this.to = to;
-    }
+	public IntRange(int from, int to) {
+		this.from = from;
+		this.to = to;
+	}
 }

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

@@ -8,7 +8,6 @@ package org.openzen.zenscript.javabytecode;
 import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
 
 /**
- *
  * @author Hoofdgebruiker
  */
 public interface JavaBytecodeImplementation {

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

@@ -10,20 +10,19 @@ import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.compiler.Target;
 
 /**
- *
  * @author Hoofdgebruiker
  */
 public class JavaBytecodeJarTarget implements Target {
 	private final String module;
 	private final String name;
 	private final boolean debugCompiler;
-	
+
 	public JavaBytecodeJarTarget(JSONObject definition) {
 		module = definition.getString("module");
 		name = definition.optString("name", "Java Bytecode: " + module);
 		debugCompiler = definition.optBoolean("debugCompiler", false);
 	}
-	
+
 	@Override
 	public JavaCompiler createCompiler(SemanticModule module) {
 		return new JavaCompiler(debugCompiler);

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

@@ -5,19 +5,20 @@
  */
 package org.openzen.zenscript.javabytecode;
 
-import java.io.File;
 import org.json.JSONObject;
 import org.openzen.zenscript.compiler.Target;
 import org.openzen.zenscript.compiler.TargetType;
 
+import java.io.File;
+
 /**
- *
  * @author Hoofdgebruiker
  */
 public class JavaBytecodeJarTargetType implements TargetType {
 	public static final JavaBytecodeJarTargetType INSTANCE = new JavaBytecodeJarTargetType();
-	
-	private JavaBytecodeJarTargetType() {}
+
+	private JavaBytecodeJarTargetType() {
+	}
 
 	@Override
 	public Target create(File projectDir, JSONObject definition) {

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

@@ -10,20 +10,19 @@ import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.compiler.Target;
 
 /**
- *
  * @author Hoofdgebruiker
  */
 public class JavaBytecodeRunTarget implements Target {
 	private final String module;
 	private final String name;
 	private final boolean debugCompiler;
-	
+
 	public JavaBytecodeRunTarget(JSONObject definition) {
 		module = definition.getString("module");
 		name = definition.optString("name", "Java Run: " + module);
 		debugCompiler = definition.optBoolean("debugCompiler", false);
 	}
-	
+
 	@Override
 	public JavaCompiler createCompiler(SemanticModule module) {
 		return new JavaCompiler(debugCompiler);

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

@@ -5,19 +5,20 @@
  */
 package org.openzen.zenscript.javabytecode;
 
-import java.io.File;
 import org.json.JSONObject;
 import org.openzen.zenscript.compiler.Target;
 import org.openzen.zenscript.compiler.TargetType;
 
+import java.io.File;
+
 /**
- *
  * @author Hoofdgebruiker
  */
 public class JavaBytecodeRunTargetType implements TargetType {
 	public static final JavaBytecodeRunTargetType INSTANCE = new JavaBytecodeRunTargetType();
-	
-	private JavaBytecodeRunTargetType() {}
+
+	private JavaBytecodeRunTargetType() {
+	}
 
 	@Override
 	public Target create(File projectDir, JSONObject definition) {

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

@@ -8,21 +8,20 @@ package org.openzen.zenscript.javabytecode;
 import org.objectweb.asm.Type;
 
 /**
- *
  * @author Hoofdgebruiker
  */
 public class JavaClassInfo {
 	public static JavaClassInfo get(Class<?> cls) {
 		return new JavaClassInfo(Type.getInternalName(cls), cls.isEnum());
 	}
-	
+
 	public final String internalClassName;
 	public final boolean isEnum;
-	
+
 	public JavaClassInfo(String internalClassName) {
 		this(internalClassName, false);
 	}
-	
+
 	public JavaClassInfo(String internalClassName, boolean isEnum) {
 		this.internalClassName = internalClassName;
 		this.isEnum = isEnum;

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

@@ -5,9 +5,6 @@
  */
 package org.openzen.zenscript.javabytecode;
 
-import java.util.HashMap;
-import java.util.Map;
-
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import org.openzen.zencode.shared.SourceFile;
@@ -15,16 +12,17 @@ import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.compiler.SemanticModule;
-
+import org.openzen.zenscript.compiler.ZenCodeCompiler;
 import org.openzen.zenscript.javabytecode.compiler.JavaClassWriter;
 import org.openzen.zenscript.javabytecode.compiler.JavaScriptFile;
-import org.openzen.zenscript.javabytecode.compiler.definitions.JavaDefinitionVisitor;
 import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
 import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
-import org.openzen.zenscript.compiler.ZenCodeCompiler;
+import org.openzen.zenscript.javabytecode.compiler.definitions.JavaDefinitionVisitor;
+
+import java.util.HashMap;
+import java.util.Map;
 
 /**
- *
  * @author Hoofdgebruiker
  */
 public class JavaCompiler implements ZenCodeCompiler {
@@ -34,31 +32,31 @@ public class JavaCompiler implements ZenCodeCompiler {
 	private int generatedScriptBlockCounter = 0;
 	private boolean finished = false;
 	private JavaModule compiled = null;
-	
+
 	public JavaCompiler() {
 		this(false);
 	}
-	
+
 	public JavaCompiler(boolean debug) {
 		target = new JavaModule();
-		
+
 		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.filename);
 		JavaScriptFile scriptFile = getScriptFile(className);
 		target.register(definition.name, definition.accept(new JavaDefinitionVisitor(scriptFile.classWriter)));
 	}
-	
+
 	@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?)
@@ -66,7 +64,7 @@ public class JavaCompiler implements ZenCodeCompiler {
 		final JavaClassWriter visitor = scriptFile.classWriter;
 		JavaMethodInfo method = new JavaMethodInfo(new JavaClassInfo(className), 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) {
@@ -75,7 +73,7 @@ public class JavaCompiler implements ZenCodeCompiler {
 		target.register("Scripts", scriptsClassWriter.toByteArray());
 		statementVisitor.end();
 	}
-	
+
 	private String getClassName(String filename) {
 		if (filename == null) {
 			return "generatedBlock" + (generatedScriptBlockCounter++);
@@ -85,50 +83,50 @@ public class JavaCompiler implements ZenCodeCompiler {
 			return filename.substring(0, filename.lastIndexOf('.')).replace("/", "_");
 		}
 	}
-	
+
 	private JavaScriptFile getScriptFile(String className) {
 		if (!scriptBlocks.containsKey(className)) {
 			JavaClassWriter scriptFileWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 			scriptFileWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, className, null, "java/lang/Object", null);
 			scriptBlocks.put(className, new JavaScriptFile(scriptFileWriter));
 		}
-		
+
 		return scriptBlocks.get(className);
 	}
-	
+
 	@Override
 	public void finish() {
 		finishAndGetModule();
 	}
-	
+
 	@Override
 	public void run() {
 		if (compiled == null)
 			throw new IllegalStateException("Not yet built!");
-		
-		
+
+
 	}
-	
+
 	public JavaModule finishAndGetModule() {
 		if (finished)
 			throw new IllegalStateException("Already finished!");
 		finished = true;
-		
+
 		JavaMethodInfo runMethod = new JavaMethodInfo(new JavaClassInfo("Scripts"), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 		final JavaWriter runWriter = new JavaWriter(scriptsClassWriter, runMethod, null, null, null);
 		runWriter.start();
 		for (Map.Entry<String, JavaScriptFile> entry : scriptBlocks.entrySet()) {
 			for (JavaMethodInfo method : entry.getValue().scriptMethods)
 				runWriter.invokeStatic(method);
-			
+
 			entry.getValue().classWriter.visitEnd();
 			target.register(entry.getKey(), entry.getValue().classWriter.toByteArray());
 		}
 		runWriter.ret();
 		runWriter.end();
-		
+
 		target.register("Scripts", scriptsClassWriter.toByteArray());
-		
+
 		return target;
 	}
 }

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

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

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

@@ -4,17 +4,17 @@ import org.objectweb.asm.Label;
 import org.objectweb.asm.Type;
 
 public class JavaLocalVariableInfo {
-    public final Type type;
-    public final int local;
-    public final Label start;
-    public final String name;
-    public Label end;
+	public final Type type;
+	public final int local;
+	public final Label start;
+	public final String name;
+	public Label end;
 
-    public JavaLocalVariableInfo(Type type, int local, Label start, String name) {
-        this.type = type;
-        this.local = local;
-        this.start = start;
-        this.end = start;
-        this.name = name;
-    }
+	public JavaLocalVariableInfo(Type type, int local, Label start, String name) {
+		this.type = type;
+		this.local = local;
+		this.start = start;
+		this.end = start;
+		this.name = name;
+	}
 }

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

@@ -9,33 +9,32 @@ import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 
 /**
- *
  * @author Hoofdgebruiker
  */
 public class JavaMethodInfo {
 	public static JavaMethodInfo get(int modifiers, Class owner, String name, Class result, Class... arguments) {
-        StringBuilder descriptor = new StringBuilder();
-        descriptor.append('(');
-        for (Class argument : arguments) {
-            descriptor.append(Type.getDescriptor(argument));
-        }
-        descriptor.append(')');
-        descriptor.append(result == null ? 'V' : Type.getDescriptor(result));
+		StringBuilder descriptor = new StringBuilder();
+		descriptor.append('(');
+		for (Class argument : arguments) {
+			descriptor.append(Type.getDescriptor(argument));
+		}
+		descriptor.append(')');
+		descriptor.append(result == null ? 'V' : Type.getDescriptor(result));
 		return new JavaMethodInfo(new JavaClassInfo(Type.getInternalName(owner)), name, descriptor.toString(), modifiers);
-    }
-	
+	}
+
 	public final JavaClassInfo javaClass;
 	public final String name;
 	public final String descriptor;
 	public final int modifiers;
-	
+
 	public JavaMethodInfo(JavaClassInfo javaClass, String name, String signature, int modifiers) {
 		this.javaClass = javaClass;
 		this.name = name;
 		this.descriptor = signature;
 		this.modifiers = modifiers;
 	}
-	
+
 	public boolean isStatic() {
 		return (modifiers & Opcodes.ACC_STATIC) > 0;
 	}

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

@@ -5,7 +5,9 @@
  */
 package org.openzen.zenscript.javabytecode;
 
-import java.io.*;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.util.HashMap;
 import java.util.Map;
@@ -13,44 +15,43 @@ import java.util.logging.Level;
 import java.util.logging.Logger;
 
 /**
- *
  * @author Hoofdgebruiker
  */
 public class JavaModule {
 	public static 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 + ".class"))) {
 			writer.write(bytecode);
 		} catch (IOException e) {
 			e.printStackTrace();
 		}
 	}
-	
+
 	public void execute() {
 		ScriptClassLoader classLoader = new ScriptClassLoader();
-		
+
 		try {
 			classLoader.loadClass("Scripts").getMethod("run").invoke(null);
 		} catch (ClassNotFoundException | InvocationTargetException | NoSuchMethodException | IllegalAccessException | SecurityException | IllegalArgumentException ex) {
 			Logger.getLogger(JavaModule.class.getName()).log(Level.SEVERE, null, ex);
 		}
 	}
-	
+
 	public class ScriptClassLoader extends ClassLoader {
 		private final Map<String, Class> customClasses = new HashMap<>();
 
 		@Override
 		public Class<?> loadClass(String name) throws ClassNotFoundException {
-			if(customClasses.containsKey(name))
+			if (customClasses.containsKey(name))
 				return customClasses.get(name);
-			if(classes.containsKey(name)) {
+			if (classes.containsKey(name)) {
 				final byte[] bytes = classes.get(name);
 				customClasses.put(name, defineClass(name, bytes, 0, bytes.length, null));
 				return customClasses.get(name);

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

@@ -8,13 +8,12 @@ package org.openzen.zenscript.javabytecode;
 import org.objectweb.asm.Type;
 
 /**
- *
  * @author Hoofdgebruiker
  */
 public class JavaParameterInfo {
 	public final int index;
 	public final Type type;
-	
+
 	public JavaParameterInfo(int index, Type type) {
 		this.index = index;
 		this.type = type;

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

@@ -8,13 +8,7 @@ import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
-import org.openzen.zenscript.codemodel.expression.switchvalue.CharSwitchValue;
-import org.openzen.zenscript.codemodel.expression.switchvalue.EnumConstantSwitchValue;
-import org.openzen.zenscript.codemodel.expression.switchvalue.IntSwitchValue;
-import org.openzen.zenscript.codemodel.expression.switchvalue.StringSwitchValue;
-import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
-import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValueVisitor;
-import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.*;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
@@ -22,162 +16,161 @@ import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.javabytecode.JavaModule;
 import org.openzen.zenscript.javabytecode.JavaParameterInfo;
 
-import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
 
 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();
-    }
-
-    public static boolean isPrimitive(ITypeID id) {
-        if (id instanceof BasicTypeID) {
-            switch ((BasicTypeID) id) {
-                case BOOL:
-                case BYTE:
-                case SBYTE:
-                case SHORT:
-                case USHORT:
-                case INT:
-                case UINT:
-                case LONG:
-                case ULONG:
-                case FLOAT:
-                case DOUBLE:
-                case CHAR:
-                    return true;
-            }
-        }
-        return false;
-    }
-
-    public static int calcAccess(int modifiers) {
-        int out = 0;
-        if (Modifiers.isStatic(modifiers))
-            out |= Opcodes.ACC_STATIC;
-        if (Modifiers.isFinal(modifiers))
-            out |= Opcodes.ACC_FINAL;
-        if (Modifiers.isPublic(modifiers))
-            out |= Opcodes.ACC_PUBLIC;
-        if (Modifiers.isPrivate(modifiers))
-            out |= Opcodes.ACC_PRIVATE;
-        if (Modifiers.isProtected(modifiers))
-            out |= Opcodes.ACC_PROTECTED;
-        if (Modifiers.isAbstract(modifiers))
-            out |= Opcodes.ACC_ABSTRACT;
-        return out;
-    }
-
-    public static String calcClasName(CodePosition position) {
-        return position.filename.substring(0, position.filename.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 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 int getKeyForSwitch(SwitchValue expression) {
+	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();
+	}
+
+	public static boolean isPrimitive(ITypeID id) {
+		if (id instanceof BasicTypeID) {
+			switch ((BasicTypeID) id) {
+				case BOOL:
+				case BYTE:
+				case SBYTE:
+				case SHORT:
+				case USHORT:
+				case INT:
+				case UINT:
+				case LONG:
+				case ULONG:
+				case FLOAT:
+				case DOUBLE:
+				case CHAR:
+					return true;
+			}
+		}
+		return false;
+	}
+
+	public static int calcAccess(int modifiers) {
+		int out = 0;
+		if (Modifiers.isStatic(modifiers))
+			out |= Opcodes.ACC_STATIC;
+		if (Modifiers.isFinal(modifiers))
+			out |= Opcodes.ACC_FINAL;
+		if (Modifiers.isPublic(modifiers))
+			out |= Opcodes.ACC_PUBLIC;
+		if (Modifiers.isPrivate(modifiers))
+			out |= Opcodes.ACC_PRIVATE;
+		if (Modifiers.isProtected(modifiers))
+			out |= Opcodes.ACC_PROTECTED;
+		if (Modifiers.isAbstract(modifiers))
+			out |= Opcodes.ACC_ABSTRACT;
+		return out;
+	}
+
+	public static String calcClasName(CodePosition position) {
+		return position.filename.substring(0, position.filename.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 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 int getKeyForSwitch(SwitchValue expression) {
 		return expression.accept(new SwitchKeyVisitor());
-    }
-	
+	}
+
 	private static class SwitchKeyVisitor implements SwitchValueVisitor<Integer> {
 
 		@Override
@@ -187,7 +180,7 @@ public class CompilerUtils {
 
 		@Override
 		public Integer acceptChar(CharSwitchValue value) {
-			return (int)value.value;
+			return (int) value.value;
 		}
 
 		@Override

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

@@ -4,35 +4,35 @@ import org.openzen.zenscript.codemodel.expression.*;
 
 public class JavaCapturedExpressionVisitor implements CapturedExpressionVisitor<Void> {
 
-    public final JavaExpressionVisitor expressionVisitor;
-
-    public JavaCapturedExpressionVisitor(JavaExpressionVisitor expressionVisitor) {
-        this.expressionVisitor = expressionVisitor;
-    }
-
-    @Override
-    public Void visitCapturedThis(CapturedThisExpression expression) {
-        return null;
-    }
-
-    @Override
-    public Void visitCapturedParameter(CapturedParameterExpression expression) {
-        return new GetFunctionParameterExpression(expression.position, expression.parameter).accept(expressionVisitor);
-    }
-
-    @Override
-    public Void visitCapturedLocal(CapturedLocalVariableExpression expression) {
-        return new GetLocalVariableExpression(expression.position, expression.variable)
-                .accept(expressionVisitor);
-    }
-
-    @Override
-    public Void visitCapturedDirect(CapturedDirectExpression expression) {
-        return expression.value.accept(expressionVisitor);
-    }
-
-    @Override
-    public Void visitRecaptured(CapturedClosureExpression expression) {
-        return expression.value.accept(this);
-    }
+	public final JavaExpressionVisitor expressionVisitor;
+
+	public JavaCapturedExpressionVisitor(JavaExpressionVisitor expressionVisitor) {
+		this.expressionVisitor = expressionVisitor;
+	}
+
+	@Override
+	public Void visitCapturedThis(CapturedThisExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitCapturedParameter(CapturedParameterExpression expression) {
+		return new GetFunctionParameterExpression(expression.position, expression.parameter).accept(expressionVisitor);
+	}
+
+	@Override
+	public Void visitCapturedLocal(CapturedLocalVariableExpression expression) {
+		return new GetLocalVariableExpression(expression.position, expression.variable)
+				.accept(expressionVisitor);
+	}
+
+	@Override
+	public Void visitCapturedDirect(CapturedDirectExpression expression) {
+		return expression.value.accept(expressionVisitor);
+	}
+
+	@Override
+	public Void visitRecaptured(CapturedClosureExpression expression) {
+		return expression.value.accept(this);
+	}
 }

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

@@ -3,7 +3,7 @@ package org.openzen.zenscript.javabytecode.compiler;
 import org.objectweb.asm.ClassWriter;
 
 public class JavaClassWriter extends ClassWriter {
-    public JavaClassWriter(int flags) {
-        super(flags);
-    }
+	public JavaClassWriter(int flags) {
+		super(flags);
+	}
 }

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

@@ -8,54 +8,54 @@ import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 
 public class JavaForeachVisitor implements ForeachIteratorVisitor<Void> {
 
-    private final JavaWriter javaWriter;
-    private final VarStatement[] variables;
-    private final Statement content;
-    private final Label startLabel;
-    private final Label endLabel;
-    private final JavaStatementVisitor statementVisitor;
-
-    public JavaForeachVisitor(JavaStatementVisitor statementVisitor, VarStatement[] variables, Statement content, Label start, Label end) {
-        this.statementVisitor = statementVisitor;
-        this.javaWriter = statementVisitor.getJavaWriter();
-        this.variables = variables;
-        this.content = content;
-        this.startLabel = start;
-        this.endLabel = end;
-    }
-
-    @Override
-    public Void visitIntRange() {
-        javaWriter.dup();
-        javaWriter.getField("org/openzen/zenscript/implementations/IntRange", "to", "I");
-        javaWriter.swap();
-        javaWriter.getField("org/openzen/zenscript/implementations/IntRange", "from", "I");
-
-        final int z = variables[0].getTag(JavaLocalVariableInfo.class).local;
-        javaWriter.storeInt(z);
-        javaWriter.label(startLabel);
-        javaWriter.dup();
-        javaWriter.loadInt(z);
-        javaWriter.ifICmpLE(endLabel);
-
-        content.accept(statementVisitor);
-        javaWriter.iinc(z);
-
-
-        return null;
-    }
-
-    @Override
-    public Void visitArrayValueIterator() {
-        handleArray(javaWriter.local(int.class), variables[0].getTag(JavaLocalVariableInfo.class));
-        return null;
-    }
-
-    @Override
-    public Void visitArrayKeyValueIterator() {
-        handleArray(variables[0].getTag(JavaLocalVariableInfo.class).local, variables[1].getTag(JavaLocalVariableInfo.class));
-        return null;
-    }
+	private final JavaWriter javaWriter;
+	private final VarStatement[] variables;
+	private final Statement content;
+	private final Label startLabel;
+	private final Label endLabel;
+	private final JavaStatementVisitor statementVisitor;
+
+	public JavaForeachVisitor(JavaStatementVisitor statementVisitor, VarStatement[] variables, Statement content, Label start, Label end) {
+		this.statementVisitor = statementVisitor;
+		this.javaWriter = statementVisitor.getJavaWriter();
+		this.variables = variables;
+		this.content = content;
+		this.startLabel = start;
+		this.endLabel = end;
+	}
+
+	@Override
+	public Void visitIntRange() {
+		javaWriter.dup();
+		javaWriter.getField("org/openzen/zenscript/implementations/IntRange", "to", "I");
+		javaWriter.swap();
+		javaWriter.getField("org/openzen/zenscript/implementations/IntRange", "from", "I");
+
+		final int z = variables[0].getTag(JavaLocalVariableInfo.class).local;
+		javaWriter.storeInt(z);
+		javaWriter.label(startLabel);
+		javaWriter.dup();
+		javaWriter.loadInt(z);
+		javaWriter.ifICmpLE(endLabel);
+
+		content.accept(statementVisitor);
+		javaWriter.iinc(z);
+
+
+		return null;
+	}
+
+	@Override
+	public Void visitArrayValueIterator() {
+		handleArray(javaWriter.local(int.class), variables[0].getTag(JavaLocalVariableInfo.class));
+		return null;
+	}
+
+	@Override
+	public Void visitArrayKeyValueIterator() {
+		handleArray(variables[0].getTag(JavaLocalVariableInfo.class).local, variables[1].getTag(JavaLocalVariableInfo.class));
+		return null;
+	}
 
 	@Override
 	public Void visitStringCharacterIterator() {
@@ -63,30 +63,30 @@ public class JavaForeachVisitor implements ForeachIteratorVisitor<Void> {
 		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
 	}
 
-    private void handleArray(final int z, final JavaLocalVariableInfo arrayTypeInfo) {
-        javaWriter.iConst0();
-        javaWriter.storeInt(z);
+	private void handleArray(final int z, final JavaLocalVariableInfo arrayTypeInfo) {
+		javaWriter.iConst0();
+		javaWriter.storeInt(z);
 
-        javaWriter.label(startLabel);
-        javaWriter.dup();
-        javaWriter.dup();
-        javaWriter.arrayLength();
-        javaWriter.loadInt(z);
+		javaWriter.label(startLabel);
+		javaWriter.dup();
+		javaWriter.dup();
+		javaWriter.arrayLength();
+		javaWriter.loadInt(z);
 
-        javaWriter.ifICmpLE(endLabel);
-        javaWriter.loadInt(z);
+		javaWriter.ifICmpLE(endLabel);
+		javaWriter.loadInt(z);
 
 
-        javaWriter.arrayLoad(arrayTypeInfo.type);
-        javaWriter.store(arrayTypeInfo.type, arrayTypeInfo.local);
-        content.accept(statementVisitor);
-        javaWriter.iinc(z);
-    }
+		javaWriter.arrayLoad(arrayTypeInfo.type);
+		javaWriter.store(arrayTypeInfo.type, arrayTypeInfo.local);
+		content.accept(statementVisitor);
+		javaWriter.iinc(z);
+	}
 
-    @Override
-    public Void visitCustomIterator() {
-        return null;
-    }
+	@Override
+	public Void visitCustomIterator() {
+		return null;
+	}
 
 	@Override
 	public Void visitAssocKeyIterator() {

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

@@ -5,26 +5,14 @@
  */
 package org.openzen.zenscript.javabytecode.compiler;
 
-import org.openzen.zenscript.codemodel.type.ArrayTypeID;
-import org.openzen.zenscript.codemodel.type.AssocTypeID;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ConstTypeID;
-import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
-import org.openzen.zenscript.codemodel.type.FunctionTypeID;
-import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
-import org.openzen.zenscript.codemodel.type.GenericTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeVisitor;
-import org.openzen.zenscript.codemodel.type.IteratorTypeID;
-import org.openzen.zenscript.codemodel.type.OptionalTypeID;
-import org.openzen.zenscript.codemodel.type.RangeTypeID;
+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;
 	}

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

@@ -6,84 +6,17 @@
 package org.openzen.zenscript.javabytecode.compiler;
 
 import org.objectweb.asm.Type;
-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.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.codemodel.expression.*;
 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) {
 		this.expressionCompiler = expressionCompiler;
 		javaWriter = expressionCompiler.getJavaWriter();
@@ -158,7 +91,7 @@ public class JavaPreDecrementVisitor implements ExpressionVisitor<Void> {
 	public Void visitConditional(ConditionalExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
-	
+
 	@Override
 	public Void visitConst(ConstExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
@@ -252,22 +185,22 @@ public class JavaPreDecrementVisitor implements ExpressionVisitor<Void> {
 	@Override
 	public Void visitGetField(GetFieldExpression expression) {
 		Type objectType = expression.target.type.accept(new JavaTypeVisitor());
-		
+
 		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;
 	}
 
@@ -286,14 +219,14 @@ public class JavaPreDecrementVisitor implements ExpressionVisitor<Void> {
 	@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;
 	}
 
@@ -351,7 +284,7 @@ public class JavaPreDecrementVisitor implements ExpressionVisitor<Void> {
 	public Void visitOrOr(OrOrExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
-	
+
 	@Override
 	public Void visitPanic(PanicExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
@@ -366,7 +299,7 @@ public class JavaPreDecrementVisitor implements ExpressionVisitor<Void> {
 	public Void visitRange(RangeExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
-	
+
 	@Override
 	public Void visitSameObject(SameObjectExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
@@ -406,7 +339,7 @@ public class JavaPreDecrementVisitor implements ExpressionVisitor<Void> {
 	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

@@ -6,84 +6,17 @@
 package org.openzen.zenscript.javabytecode.compiler;
 
 import org.objectweb.asm.Type;
-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.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.codemodel.expression.*;
 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 JavaWriter javaWriter;
-	
+
 	public JavaPreIncrementVisitor(JavaExpressionVisitor expressionCompiler) {
 		this.expressionCompiler = expressionCompiler;
 		javaWriter = expressionCompiler.getJavaWriter();
@@ -158,7 +91,7 @@ public class JavaPreIncrementVisitor implements ExpressionVisitor<Void> {
 	public Void visitConditional(ConditionalExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
-	
+
 	@Override
 	public Void visitConst(ConstExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
@@ -252,23 +185,23 @@ public class JavaPreIncrementVisitor implements ExpressionVisitor<Void> {
 	@Override
 	public Void visitGetField(GetFieldExpression expression) {
 		Type objectType = expression.target.type.accept(new JavaTypeVisitor());
-		
+
 		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;
 	}
 
@@ -291,15 +224,15 @@ public class JavaPreIncrementVisitor implements ExpressionVisitor<Void> {
 	@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;
 	}
 
@@ -357,7 +290,7 @@ public class JavaPreIncrementVisitor implements ExpressionVisitor<Void> {
 	public Void visitOrOr(OrOrExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
-	
+
 	@Override
 	public Void visitPanic(PanicExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
@@ -372,7 +305,7 @@ public class JavaPreIncrementVisitor implements ExpressionVisitor<Void> {
 	public Void visitRange(RangeExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
-	
+
 	@Override
 	public Void visitSameObject(SameObjectExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
@@ -412,7 +345,7 @@ public class JavaPreIncrementVisitor implements ExpressionVisitor<Void> {
 	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/JavaScriptFile.java

@@ -5,18 +5,18 @@
  */
 package org.openzen.zenscript.javabytecode.compiler;
 
+import org.openzen.zenscript.javabytecode.JavaMethodInfo;
+
 import java.util.ArrayList;
 import java.util.List;
-import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 
 /**
- *
  * @author Hoofdgebruiker
  */
 public class JavaScriptFile {
 	public final JavaClassWriter classWriter;
 	public final List<JavaMethodInfo> scriptMethods;
-	
+
 	public JavaScriptFile(JavaClassWriter classWriter) {
 		this.classWriter = classWriter;
 		this.scriptMethods = new ArrayList<>();

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

@@ -12,312 +12,312 @@ import java.util.Arrays;
 import java.util.List;
 
 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;
-    }
-
-    @Override
-    public Boolean visitBlock(BlockStatement statement) {
-        Boolean returns = false;
-        for (Statement statement1 : statement.statements) {
-            returns = statement1.accept(this);
-        }
-        return returns;
-    }
-
-    @Override
-    public Boolean visitBreak(BreakStatement statement) {
-        javaWriter.goTo(javaWriter.getNamedLabel(statement.target.label + "_end"));
-        return false;
-    }
-
-    @Override
-    public Boolean visitContinue(ContinueStatement statement) {
-        javaWriter.goTo(javaWriter.getNamedLabel(statement.target.label + "_start"));
-        return false;
-    }
-
-    @Override
-    public Boolean visitDoWhile(DoWhileStatement statement) {
-        Label start = new Label();
-        Label end = new Label();
-        if (statement.label == null)
-            statement.label = javaWriter.createLabelName() + "DoWhile";
-        javaWriter.putNamedLabel(start, statement.label + "_start");
-        javaWriter.putNamedLabel(end, statement.label + "_end");
-        javaWriter.label(start);
-        statement.content.accept(this);
-
-        statement.condition.accept(expressionVisitor);
-        javaWriter.ifNE(start);
-
-        //Only needed for break statements, should be nop if not used
-        javaWriter.label(end);
-        return false;
-    }
-
-    @Override
-    public Boolean visitEmpty(EmptyStatement statement) {
-        //No-Op
-        return false;
-    }
-
-    @Override
-    public Boolean visitExpression(ExpressionStatement statement) {
-        statement.expression.accept(expressionVisitor);
-        return false;
-    }
-
-    @Override
-    public Boolean visitForeach(ForeachStatement statement) {
-        //Create Labels
-        Label start = new Label();
-        Label end = new Label();
-        if (statement.label == null) {
-            statement.label = javaWriter.createLabelName() + "ForEach";
-        }
-        javaWriter.putNamedLabel(start, statement.label + "_start");
-        javaWriter.putNamedLabel(end, statement.label + "_end");
-
-
-        //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);
-        }
-
-        //javaWriter.label(min);
-        statement.iterator.target.acceptForIterator(new JavaForeachVisitor(this, statement.loopVariables, statement.content, start, end));
-        javaWriter.goTo(start);
-        javaWriter.label(end);
-        return false;
-    }
-
-    @Override
-    public Boolean visitIf(IfStatement statement) {
-        statement.condition.accept(expressionVisitor);
-        Label onElse = null;
-        Label end = new Label();
-        final boolean hasElse = statement.onElse != null;
-        if (hasElse) {
-            onElse = new Label();
-            javaWriter.ifEQ(onElse);
-        } else {
-            javaWriter.ifEQ(end);
-        }
-        statement.onThen.accept(this);
-        if (hasElse) {
-            javaWriter.goTo(end);
-            javaWriter.label(onElse);
-            statement.onElse.accept(this);
-        }
-        javaWriter.label(end);
-        return false;
-    }
-
-    @Override
-    public Boolean visitLock(LockStatement statement) {
-        return false;
-    }
-
-    @Override
-    public Boolean visitReturn(ReturnStatement statement) {
-        statement.value.accept(expressionVisitor);
-        javaWriter.returnType(Type.getType(statement.value.type.accept(JavaTypeClassVisitor.INSTANCE)));
-        return true;
-    }
-
-    @Override
-    public Boolean visitSwitch(SwitchStatement statement) {
-
-        final Label start = new Label();
-        final Label end = new Label();
-
-        if (statement.label == null)
-            statement.label = javaWriter.createLabelName() + "Switch";
-
-        javaWriter.putNamedLabel(start, statement.label + "_start");
-        javaWriter.putNamedLabel(end, statement.label + "_end");
-
-
-        javaWriter.label(start);
-        statement.value.accept(expressionVisitor);
-        if (statement.value.type == BasicTypeID.STRING)
-            javaWriter.invokeVirtual(new JavaMethodInfo(new JavaClassInfo("java/lang/Object"), "hashCode", "()I", 0));
-        boolean out = false;
-
-        final boolean hasNoDefault = hasNoDefault(statement);
-
-        final List<SwitchCase> cases = statement.cases;
-        final JavaSwitchLabel[] switchLabels = new JavaSwitchLabel[hasNoDefault ? cases.size() : cases.size() - 1];
-        final Label defaultLabel = new Label();
-
-        int i = 0;
-        for (final SwitchCase switchCase : cases) {
-            if (switchCase.value != null) {
-                switchLabels[i++] = new JavaSwitchLabel(CompilerUtils.getKeyForSwitch(switchCase.value), new Label());
-            }
-        }
-
-        JavaSwitchLabel[] sortedSwitchLabels = Arrays.copyOf(switchLabels, switchLabels.length);
-        Arrays.sort(sortedSwitchLabels, (a, b) -> a.key - b.key);
-
-        javaWriter.lookupSwitch(defaultLabel, sortedSwitchLabels);
-
-        i = 0;
-        for (final SwitchCase switchCase : cases) {
-            if (hasNoDefault || switchCase.value != null) {
-                javaWriter.label(switchLabels[i++].label);
-            } else {
-                javaWriter.label(defaultLabel);
-            }
-            for (Statement statement1 : switchCase.statements) {
-                out |= statement1.accept(this);
-            }
-        }
-
-        if (hasNoDefault)
-            javaWriter.label(defaultLabel);
-
-        javaWriter.label(end);
-
-
-        //throw new UnsupportedOperationException("Not yet implemented!");
-        return out;
-    }
-
-    private boolean hasNoDefault(SwitchStatement switchStatement) {
-        for (SwitchCase switchCase : switchStatement.cases)
-            if (switchCase.value == null) return false;
-        return true;
-    }
-
-    @Override
-    public Boolean visitThrow(ThrowStatement statement) {
-        statement.value.accept(expressionVisitor);
-        javaWriter.aThrow();
-        return false;
-    }
-
-    @Override
-    public Boolean visitTryCatch(TryCatchStatement statement) {
-        final Label tryCatchStart = new Label();
-        final Label tryFinish = new Label();
-        final Label tryCatchFinish = new Label();
-        final Label finallyStart = new Label();
-
-        javaWriter.label(tryCatchStart);
-        //TODO Check for returns or breaks out of the try-catch and inject finally block before them
-        statement.content.accept(this);
-        javaWriter.label(tryFinish);
-        if (statement.finallyClause != null)
-            statement.finallyClause.accept(this);
-        javaWriter.goTo(tryCatchFinish);
-
-        for (CatchClause catchClause : statement.catchClauses) {
-            final Label catchStart = new Label();
-            javaWriter.label(catchStart);
-
-            //final Type exceptionType = Type.getType(RuntimeException.class);
-            final Type exceptionType = Type.getType(catchClause.exceptionVariable.type.accept(JavaTypeClassVisitor.INSTANCE));
-            final int local = javaWriter.local(exceptionType);
-            javaWriter.store(exceptionType, local);
-
-            catchClause.content.accept(this);
-            final Label catchFinish = new Label();
-            javaWriter.label(catchFinish);
-
-            if (statement.finallyClause != null) {
-                statement.finallyClause.accept(this);
-                javaWriter.tryCatch(catchStart, catchFinish, finallyStart, null);
-            }
-
-            javaWriter.tryCatch(tryCatchStart, tryFinish, catchStart, exceptionType.getInternalName());
-            javaWriter.goTo(tryCatchFinish);
-        }
-
-        if (statement.finallyClause != null) {
-            javaWriter.label(finallyStart);
-            final int local = javaWriter.local(Object.class);
-            javaWriter.storeObject(local);
-            statement.finallyClause.accept(this);
-            javaWriter.loadObject(local);
-            javaWriter.aThrow();
-            javaWriter.tryCatch(tryCatchStart, tryFinish, finallyStart, null);
-        }
-        javaWriter.label(tryCatchFinish);
-
-        return false;
-    }
-
-    @Override
-    public Boolean visitVar(VarStatement statement) {
-
-        if (statement.initializer != null) {
-            statement.initializer.accept(expressionVisitor);
-        }
-
-        Type type = statement.type.accept(JavaTypeVisitor.INSTANCE);
-        int local = javaWriter.local(type);
-        if (statement.initializer != null)
-            javaWriter.store(type, local);
-        final Label variableStart = new Label();
-        javaWriter.label(variableStart);
-        final JavaLocalVariableInfo info = new JavaLocalVariableInfo(type, local, variableStart, statement.name);
-        statement.setTag(JavaLocalVariableInfo.class, info);
-        javaWriter.addVariableInfo(info);
-        return false;
-    }
-
-    @Override
-    public Boolean visitWhile(WhileStatement statement) {
-        Label start = new Label();
-        Label end = new Label();
-
-        if (statement.label == null) {
-            statement.label = javaWriter.createLabelName() + "WhileDo";
-        }
-        javaWriter.putNamedLabel(start, statement.label + "_start");
-        javaWriter.putNamedLabel(end, statement.label + "_end");
-
-        javaWriter.label(start);
-        statement.condition.accept(expressionVisitor);
-        javaWriter.ifEQ(end);
-        statement.content.accept(this);
-        javaWriter.goTo(start);
-        javaWriter.label(end);
-        return false;
-    }
-
-    public void start() {
-        javaWriter.start();
-    }
-
-    public void end() {
-        javaWriter.ret();
-        javaWriter.end();
-    }
-
-    public JavaWriter getJavaWriter() {
-        return javaWriter;
-    }
+	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;
+	}
+
+	@Override
+	public Boolean visitBlock(BlockStatement statement) {
+		Boolean returns = false;
+		for (Statement statement1 : statement.statements) {
+			returns = statement1.accept(this);
+		}
+		return returns;
+	}
+
+	@Override
+	public Boolean visitBreak(BreakStatement statement) {
+		javaWriter.goTo(javaWriter.getNamedLabel(statement.target.label + "_end"));
+		return false;
+	}
+
+	@Override
+	public Boolean visitContinue(ContinueStatement statement) {
+		javaWriter.goTo(javaWriter.getNamedLabel(statement.target.label + "_start"));
+		return false;
+	}
+
+	@Override
+	public Boolean visitDoWhile(DoWhileStatement statement) {
+		Label start = new Label();
+		Label end = new Label();
+		if (statement.label == null)
+			statement.label = javaWriter.createLabelName() + "DoWhile";
+		javaWriter.putNamedLabel(start, statement.label + "_start");
+		javaWriter.putNamedLabel(end, statement.label + "_end");
+		javaWriter.label(start);
+		statement.content.accept(this);
+
+		statement.condition.accept(expressionVisitor);
+		javaWriter.ifNE(start);
+
+		//Only needed for break statements, should be nop if not used
+		javaWriter.label(end);
+		return false;
+	}
+
+	@Override
+	public Boolean visitEmpty(EmptyStatement statement) {
+		//No-Op
+		return false;
+	}
+
+	@Override
+	public Boolean visitExpression(ExpressionStatement statement) {
+		statement.expression.accept(expressionVisitor);
+		return false;
+	}
+
+	@Override
+	public Boolean visitForeach(ForeachStatement statement) {
+		//Create Labels
+		Label start = new Label();
+		Label end = new Label();
+		if (statement.label == null) {
+			statement.label = javaWriter.createLabelName() + "ForEach";
+		}
+		javaWriter.putNamedLabel(start, statement.label + "_start");
+		javaWriter.putNamedLabel(end, statement.label + "_end");
+
+
+		//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);
+		}
+
+		//javaWriter.label(min);
+		statement.iterator.target.acceptForIterator(new JavaForeachVisitor(this, statement.loopVariables, statement.content, start, end));
+		javaWriter.goTo(start);
+		javaWriter.label(end);
+		return false;
+	}
+
+	@Override
+	public Boolean visitIf(IfStatement statement) {
+		statement.condition.accept(expressionVisitor);
+		Label onElse = null;
+		Label end = new Label();
+		final boolean hasElse = statement.onElse != null;
+		if (hasElse) {
+			onElse = new Label();
+			javaWriter.ifEQ(onElse);
+		} else {
+			javaWriter.ifEQ(end);
+		}
+		statement.onThen.accept(this);
+		if (hasElse) {
+			javaWriter.goTo(end);
+			javaWriter.label(onElse);
+			statement.onElse.accept(this);
+		}
+		javaWriter.label(end);
+		return false;
+	}
+
+	@Override
+	public Boolean visitLock(LockStatement statement) {
+		return false;
+	}
+
+	@Override
+	public Boolean visitReturn(ReturnStatement statement) {
+		statement.value.accept(expressionVisitor);
+		javaWriter.returnType(Type.getType(statement.value.type.accept(JavaTypeClassVisitor.INSTANCE)));
+		return true;
+	}
+
+	@Override
+	public Boolean visitSwitch(SwitchStatement statement) {
+
+		final Label start = new Label();
+		final Label end = new Label();
+
+		if (statement.label == null)
+			statement.label = javaWriter.createLabelName() + "Switch";
+
+		javaWriter.putNamedLabel(start, statement.label + "_start");
+		javaWriter.putNamedLabel(end, statement.label + "_end");
+
+
+		javaWriter.label(start);
+		statement.value.accept(expressionVisitor);
+		if (statement.value.type == BasicTypeID.STRING)
+			javaWriter.invokeVirtual(new JavaMethodInfo(new JavaClassInfo("java/lang/Object"), "hashCode", "()I", 0));
+		boolean out = false;
+
+		final boolean hasNoDefault = hasNoDefault(statement);
+
+		final List<SwitchCase> cases = statement.cases;
+		final JavaSwitchLabel[] switchLabels = new JavaSwitchLabel[hasNoDefault ? cases.size() : cases.size() - 1];
+		final Label defaultLabel = new Label();
+
+		int i = 0;
+		for (final SwitchCase switchCase : cases) {
+			if (switchCase.value != null) {
+				switchLabels[i++] = new JavaSwitchLabel(CompilerUtils.getKeyForSwitch(switchCase.value), new Label());
+			}
+		}
+
+		JavaSwitchLabel[] sortedSwitchLabels = Arrays.copyOf(switchLabels, switchLabels.length);
+		Arrays.sort(sortedSwitchLabels, (a, b) -> a.key - b.key);
+
+		javaWriter.lookupSwitch(defaultLabel, sortedSwitchLabels);
+
+		i = 0;
+		for (final SwitchCase switchCase : cases) {
+			if (hasNoDefault || switchCase.value != null) {
+				javaWriter.label(switchLabels[i++].label);
+			} else {
+				javaWriter.label(defaultLabel);
+			}
+			for (Statement statement1 : switchCase.statements) {
+				out |= statement1.accept(this);
+			}
+		}
+
+		if (hasNoDefault)
+			javaWriter.label(defaultLabel);
+
+		javaWriter.label(end);
+
+
+		//throw new UnsupportedOperationException("Not yet implemented!");
+		return out;
+	}
+
+	private boolean hasNoDefault(SwitchStatement switchStatement) {
+		for (SwitchCase switchCase : switchStatement.cases)
+			if (switchCase.value == null) return false;
+		return true;
+	}
+
+	@Override
+	public Boolean visitThrow(ThrowStatement statement) {
+		statement.value.accept(expressionVisitor);
+		javaWriter.aThrow();
+		return false;
+	}
+
+	@Override
+	public Boolean visitTryCatch(TryCatchStatement statement) {
+		final Label tryCatchStart = new Label();
+		final Label tryFinish = new Label();
+		final Label tryCatchFinish = new Label();
+		final Label finallyStart = new Label();
+
+		javaWriter.label(tryCatchStart);
+		//TODO Check for returns or breaks out of the try-catch and inject finally block before them
+		statement.content.accept(this);
+		javaWriter.label(tryFinish);
+		if (statement.finallyClause != null)
+			statement.finallyClause.accept(this);
+		javaWriter.goTo(tryCatchFinish);
+
+		for (CatchClause catchClause : statement.catchClauses) {
+			final Label catchStart = new Label();
+			javaWriter.label(catchStart);
+
+			//final Type exceptionType = Type.getType(RuntimeException.class);
+			final Type exceptionType = Type.getType(catchClause.exceptionVariable.type.accept(JavaTypeClassVisitor.INSTANCE));
+			final int local = javaWriter.local(exceptionType);
+			javaWriter.store(exceptionType, local);
+
+			catchClause.content.accept(this);
+			final Label catchFinish = new Label();
+			javaWriter.label(catchFinish);
+
+			if (statement.finallyClause != null) {
+				statement.finallyClause.accept(this);
+				javaWriter.tryCatch(catchStart, catchFinish, finallyStart, null);
+			}
+
+			javaWriter.tryCatch(tryCatchStart, tryFinish, catchStart, exceptionType.getInternalName());
+			javaWriter.goTo(tryCatchFinish);
+		}
+
+		if (statement.finallyClause != null) {
+			javaWriter.label(finallyStart);
+			final int local = javaWriter.local(Object.class);
+			javaWriter.storeObject(local);
+			statement.finallyClause.accept(this);
+			javaWriter.loadObject(local);
+			javaWriter.aThrow();
+			javaWriter.tryCatch(tryCatchStart, tryFinish, finallyStart, null);
+		}
+		javaWriter.label(tryCatchFinish);
+
+		return false;
+	}
+
+	@Override
+	public Boolean visitVar(VarStatement statement) {
+
+		if (statement.initializer != null) {
+			statement.initializer.accept(expressionVisitor);
+		}
+
+		Type type = statement.type.accept(JavaTypeVisitor.INSTANCE);
+		int local = javaWriter.local(type);
+		if (statement.initializer != null)
+			javaWriter.store(type, local);
+		final Label variableStart = new Label();
+		javaWriter.label(variableStart);
+		final JavaLocalVariableInfo info = new JavaLocalVariableInfo(type, local, variableStart, statement.name);
+		statement.setTag(JavaLocalVariableInfo.class, info);
+		javaWriter.addVariableInfo(info);
+		return false;
+	}
+
+	@Override
+	public Boolean visitWhile(WhileStatement statement) {
+		Label start = new Label();
+		Label end = new Label();
+
+		if (statement.label == null) {
+			statement.label = javaWriter.createLabelName() + "WhileDo";
+		}
+		javaWriter.putNamedLabel(start, statement.label + "_start");
+		javaWriter.putNamedLabel(end, statement.label + "_end");
+
+		javaWriter.label(start);
+		statement.condition.accept(expressionVisitor);
+		javaWriter.ifEQ(end);
+		statement.content.accept(this);
+		javaWriter.goTo(start);
+		javaWriter.label(end);
+		return false;
+	}
+
+	public void start() {
+		javaWriter.start();
+	}
+
+	public void end() {
+		javaWriter.ret();
+		javaWriter.end();
+	}
+
+	public JavaWriter getJavaWriter() {
+		return javaWriter;
+	}
 }

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

@@ -8,13 +8,12 @@ package org.openzen.zenscript.javabytecode.compiler;
 import org.objectweb.asm.Label;
 
 /**
- *
  * @author Hoofdgebruiker
  */
 public class JavaSwitchLabel {
 	public final int key;
 	public final Label label;
-	
+
 	public JavaSwitchLabel(int key, Label label) {
 		this.key = key;
 		this.label = label;

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

@@ -9,92 +9,92 @@ import java.util.Map;
 
 public class JavaTypeClassVisitor implements ITypeVisitor<Class> {
 
-    public static final JavaTypeClassVisitor INSTANCE = new JavaTypeClassVisitor();
+	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 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 visitArray(ArrayTypeID array) {
+		return Array.newInstance(array.elementType.accept(this), 0).getClass();
+	}
 
-    @Override
-    public Class visitAssoc(AssocTypeID assoc) {
-        return Map.class;
-    }
+	@Override
+	public Class visitAssoc(AssocTypeID assoc) {
+		return Map.class;
+	}
 
-    @Override
-    public Class visitIterator(IteratorTypeID iterator) {
-        return Iterator.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 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 visitDefinition(DefinitionTypeID definition) {
+		return null;
+	}
 
-    @Override
-    public Class visitGeneric(GenericTypeID generic) {
-        return null;
-    }
+	@Override
+	public Class visitGeneric(GenericTypeID generic) {
+		return null;
+	}
 
-    @Override
-    public Class visitRange(RangeTypeID range) {
-        return null;
-    }
+	@Override
+	public Class visitRange(RangeTypeID range) {
+		return null;
+	}
 
-    @Override
-    public Class visitConst(ConstTypeID type) {
-        return type.baseType.accept(this);
-    }
+	@Override
+	public Class visitConst(ConstTypeID type) {
+		return type.baseType.accept(this);
+	}
 
-    @Override
-    public Class visitOptional(OptionalTypeID optional) {
-        return optional.baseType.accept(this.optional);
-    }
+	@Override
+	public Class visitOptional(OptionalTypeID optional) {
+		return optional.baseType.accept(this.optional);
+	}
 
 	@Override
 	public Class visitGenericMap(GenericMapTypeID map) {

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

@@ -4,58 +4,58 @@ import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.type.*;
 
 public class JavaTypeVisitor implements ITypeVisitor<Type> {
-    public static final JavaTypeVisitor INSTANCE = new JavaTypeVisitor();
+	public static final JavaTypeVisitor INSTANCE = new JavaTypeVisitor();
 
-    @Override
-    public Type visitBasic(BasicTypeID basic) {
-        return Type.getType(basic.accept(JavaTypeClassVisitor.INSTANCE));
-    }
+	@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 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 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 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 visitFunction(FunctionTypeID function) {
+		Class clazz = function.accept(JavaTypeClassVisitor.INSTANCE);
+		return clazz != null ? Type.getType(clazz) : Type.getType("L" + CompilerUtils.getLambdaInterface(function.header) + ";");
+	}
 
-    @Override
-    public Type visitDefinition(DefinitionTypeID definition) {
-        return Type.getType("L" + definition + ";");
-    }
+	@Override
+	public Type visitDefinition(DefinitionTypeID definition) {
+		return Type.getType("L" + definition + ";");
+	}
 
-    @Override
-    public Type visitGeneric(GenericTypeID generic) {
-        return Type.getType(generic.accept(JavaTypeClassVisitor.INSTANCE));
-    }
+	@Override
+	public Type visitGeneric(GenericTypeID generic) {
+		return Type.getType(generic.accept(JavaTypeClassVisitor.INSTANCE));
+	}
 
-    @Override
-    public Type visitRange(RangeTypeID range) {
-        return Type.getType(range.accept(JavaTypeClassVisitor.INSTANCE));
-    }
+	@Override
+	public Type visitRange(RangeTypeID range) {
+		return Type.getType(range.accept(JavaTypeClassVisitor.INSTANCE));
+	}
 
-    @Override
-    public Type visitConst(ConstTypeID type) {
-        return Type.getType(type.accept(JavaTypeClassVisitor.INSTANCE));
-    }
+	@Override
+	public Type visitConst(ConstTypeID type) {
+		return Type.getType(type.accept(JavaTypeClassVisitor.INSTANCE));
+	}
 
-    @Override
-    public Type visitOptional(OptionalTypeID optional) {
-        return Type.getType(optional.accept(JavaTypeClassVisitor.INSTANCE));
-    }
+	@Override
+	public Type visitOptional(OptionalTypeID optional) {
+		return Type.getType(optional.accept(JavaTypeClassVisitor.INSTANCE));
+	}
 
 	@Override
 	public Type visitGenericMap(GenericMapTypeID map) {

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

@@ -3,7 +3,6 @@ package org.openzen.zenscript.javabytecode.compiler.definitions;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
-import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.definition.*;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
@@ -11,7 +10,6 @@ import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 import org.openzen.zenscript.javabytecode.JavaModule;
-import org.openzen.zenscript.javabytecode.JavaParameterInfo;
 import org.openzen.zenscript.javabytecode.compiler.*;
 
 
@@ -22,7 +20,7 @@ public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 			"forName",
 			"(Ljava/lang/String;)Ljava/lang/Class;",
 			Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-	
+
 	private static final JavaClassInfo T_ENUM = new JavaClassInfo("java/lang/Enum");
 	private static final JavaMethodInfo ENUM_VALUEOF = new JavaMethodInfo(
 			T_ENUM,
@@ -30,127 +28,127 @@ public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 			"(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;",
 			Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
 
-    private final JavaClassWriter outerWriter;
+	private final JavaClassWriter outerWriter;
 
-    public JavaDefinitionVisitor(JavaClassWriter outerWriter) {
+	public JavaDefinitionVisitor(JavaClassWriter outerWriter) {
 
-        this.outerWriter = outerWriter;
-    }
+		this.outerWriter = outerWriter;
+	}
 
-    @Override
-    public byte[] visitClass(ClassDefinition definition) {
-        //Classes will always be created in a new File/Class
+	@Override
+	public byte[] visitClass(ClassDefinition definition) {
+		//Classes will always be created in a new File/Class
 
-        final Type superType;
-        if (definition.superType == null)
-            superType = Type.getType(Object.class);
-        else
-            superType = Type.getType(definition.superType.accept(JavaTypeClassVisitor.INSTANCE));
+		final Type superType;
+		if (definition.superType == null)
+			superType = Type.getType(Object.class);
+		else
+			superType = Type.getType(definition.superType.accept(JavaTypeClassVisitor.INSTANCE));
 
 		JavaClassInfo toClass = new JavaClassInfo(definition.name);
-        JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
+		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(writer, toClass, definition);
+		for (IDefinitionMember member : definition.members) {
+			member.accept(memberVisitor);
+		}
 		memberVisitor.end();
-        writer.visitEnd();
-        return writer.toByteArray();
-    }
+		writer.visitEnd();
+		return writer.toByteArray();
+	}
 
-    @Override
-    public byte[] visitInterface(InterfaceDefinition definition) {
+	@Override
+	public byte[] visitInterface(InterfaceDefinition definition) {
 		JavaClassInfo toClass = new JavaClassInfo(definition.name);
-        ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+		ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
 
-        //TODO: Calculate signature from generic parameters
-        //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);
+		//TODO: Calculate signature from generic parameters
+		//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);
-        for (IDefinitionMember member : definition.members) {
-            member.accept(memberVisitor);
-        }
+		for (IDefinitionMember member : definition.members) {
+			member.accept(memberVisitor);
+		}
 		memberVisitor.end();
-        writer.visitEnd();
-        return writer.toByteArray();
-    }
+		writer.visitEnd();
+		return writer.toByteArray();
+	}
 
-    @Override
-    public byte[] visitEnum(EnumDefinition definition) {
+	@Override
+	public byte[] visitEnum(EnumDefinition definition) {
 		System.out.println("Compiling enum " + definition.name + " in " + definition.position.filename);
-		
-        final Type superType;
-        if (definition.superType == null)
-            superType = Type.getType(Object.class);
-        else
-            superType = Type.getType(definition.superType.accept(JavaTypeClassVisitor.INSTANCE));
 
-        ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+		final Type superType;
+		if (definition.superType == null)
+			superType = Type.getType(Object.class);
+		else
+			superType = Type.getType(definition.superType.accept(JavaTypeClassVisitor.INSTANCE));
+
+		ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
 
-        writer.visit(Opcodes.V1_8, Opcodes.ACC_ENUM | Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER | Opcodes.ACC_FINAL, definition.name, "Ljava/lang/Enum<L" + definition.name + ";>;", superType.getInternalName(), null);
+		writer.visit(Opcodes.V1_8, Opcodes.ACC_ENUM | Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER | Opcodes.ACC_FINAL, definition.name, "Ljava/lang/Enum<L" + definition.name + ";>;", superType.getInternalName(), null);
 
 		JavaClassInfo toClass = new JavaClassInfo(definition.name, true);
 
-        //Enum Stuff(required!)
-        writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC, "$VALUES", "[L" + definition.name + ";", null, null).visitEnd();
+		//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(writer, toClass, definition);
-        for (IDefinitionMember member : definition.members) {
-            member.accept(visitor);
-        }
-		
 		JavaClassInfo arrayClass = new JavaClassInfo("[L" + definition.name + ";");
 		JavaMethodInfo arrayClone = new JavaMethodInfo(arrayClass, "clone", "()Ljava/lang/Object;", Opcodes.ACC_PUBLIC);
 
 		JavaMethodInfo valuesMethodInfo = new JavaMethodInfo(toClass, "values", "()[L" + definition.name + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-        JavaWriter valuesWriter = new JavaWriter(writer, true, valuesMethodInfo, definition, null, null);
-        valuesWriter.start();
-        valuesWriter.getStaticField(definition.name, "$VALUES", "[L" + definition.name + ";");
-        valuesWriter.invokeVirtual(arrayClone);
-        valuesWriter.checkCast("[L" + definition.name + ";");
-        valuesWriter.returnObject();
-        valuesWriter.end();
+		JavaWriter valuesWriter = new JavaWriter(writer, true, valuesMethodInfo, definition, null, null);
+		valuesWriter.start();
+		valuesWriter.getStaticField(definition.name, "$VALUES", "[L" + definition.name + ";");
+		valuesWriter.invokeVirtual(arrayClone);
+		valuesWriter.checkCast("[L" + definition.name + ";");
+		valuesWriter.returnObject();
+		valuesWriter.end();
 
 		JavaMethodInfo valueOfMethodInfo = new JavaMethodInfo(toClass, "valueOf", "(Ljava/lang/String;)L" + definition.name + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-        JavaWriter valueOfWriter = new JavaWriter(writer, true, valueOfMethodInfo, definition, null, null);
-        valueOfWriter.start();
-        valueOfWriter.invokeStatic(CLASS_FORNAME);
-        valueOfWriter.loadObject(0);
-        valueOfWriter.invokeStatic(ENUM_VALUEOF);
-        valueOfWriter.checkCast("L" + definition.name + ";");
-        valueOfWriter.returnObject();
-        valueOfWriter.end();
-
-
-        writer.visitEnd();
-        return writer.toByteArray();
-    }
-
-    @Override
-    public byte[] visitStruct(StructDefinition definition) {
-        return null;
-    }
-
-    @Override
-    public byte[] visitFunction(FunctionDefinition definition) {
+		JavaWriter valueOfWriter = new JavaWriter(writer, true, valueOfMethodInfo, definition, null, null);
+		valueOfWriter.start();
+		valueOfWriter.invokeStatic(CLASS_FORNAME);
+		valueOfWriter.loadObject(0);
+		valueOfWriter.invokeStatic(ENUM_VALUEOF);
+		valueOfWriter.checkCast("L" + definition.name + ";");
+		valueOfWriter.returnObject();
+		valueOfWriter.end();
+
+
+		writer.visitEnd();
+		return writer.toByteArray();
+	}
+
+	@Override
+	public byte[] visitStruct(StructDefinition definition) {
+		return null;
+	}
+
+	@Override
+	public byte[] visitFunction(FunctionDefinition definition) {
 		CompilerUtils.tagMethodParameters(definition.header, true);
-		
-        final String signature = CompilerUtils.calcSign(definition.header, false);
-		
+
+		final String signature = CompilerUtils.calcSign(definition.header, false);
+
 		final JavaClassInfo toClass = new JavaClassInfo(CompilerUtils.calcClasName(definition.position));
 		final JavaMethodInfo methodInfo = new JavaMethodInfo(toClass, definition.name, CompilerUtils.calcDesc(definition.header, false), CompilerUtils.calcAccess(definition.modifiers) | Opcodes.ACC_STATIC);
 
 		final JavaWriter writer = new JavaWriter(outerWriter, true, methodInfo, definition, signature, null);
-        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(writer);
-        statementVisitor.start();
+		final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(writer);
+		statementVisitor.start();
 		boolean returns = definition.statement.accept(statementVisitor);
 		if (!returns) {
 			ITypeID type = definition.header.returnType;
@@ -159,25 +157,25 @@ public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 			else if (type != BasicTypeID.VOID)
 				writer.aConstNull();
 			writer.returnType(type.accept(JavaTypeVisitor.INSTANCE));
-        }
-
-        statementVisitor.end();
-		
-        definition.setTag(JavaMethodInfo.class, methodInfo);
-        definition.caller.setTag(JavaMethodInfo.class, methodInfo);
-        return null;
-    }
-
-    @Override
-    public byte[] visitExpansion(ExpansionDefinition definition) {
-        return null;
-    }
-
-    @Override
-    public byte[] visitAlias(AliasDefinition definition) {
-        //TODO would that work?
-        return JavaModule.classes.get(definition.name);
-    }
+		}
+
+		statementVisitor.end();
+
+		definition.setTag(JavaMethodInfo.class, methodInfo);
+		definition.caller.setTag(JavaMethodInfo.class, methodInfo);
+		return null;
+	}
+
+	@Override
+	public byte[] visitExpansion(ExpansionDefinition definition) {
+		return null;
+	}
+
+	@Override
+	public byte[] visitAlias(AliasDefinition definition) {
+		//TODO would that work?
+		return JavaModule.classes.get(definition.name);
+	}
 
 	@Override
 	public byte[] visitVariant(VariantDefinition variant) {

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

@@ -6,16 +6,16 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class JavaInitializedVariables {
-    public final List<FieldMember> fields;
-    public final String owner;
+	public final List<FieldMember> fields;
+	public final String owner;
 
-    public JavaInitializedVariables(String owner) {
-        this.owner = owner;
-        fields = new ArrayList<>();
-    }
+	public JavaInitializedVariables(String owner) {
+		this.owner = owner;
+		fields = new ArrayList<>();
+	}
 
-    public JavaInitializedVariables(List<FieldMember> fields, String owner) {
-        this.fields = fields;
-        this.owner = owner;
-    }
+	public JavaInitializedVariables(List<FieldMember> fields, String owner) {
+		this.fields = fields;
+		this.owner = owner;
+	}
 }

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

@@ -19,195 +19,195 @@ import org.openzen.zenscript.javabytecode.compiler.*;
 import java.util.List;
 
 public class JavaMemberVisitor implements MemberVisitor<Void> {
-    private final ClassWriter writer;
-    private final JavaClassInfo toClass;
-    private final HighLevelDefinition definition;
-    private final JavaStatementVisitor clinitStatementVisitor;
-    private EnumDefinition enumDefinition = null;
-
-    public JavaMemberVisitor(ClassWriter writer, JavaClassInfo 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 JavaClassInfo toClass;
+	private final HighLevelDefinition definition;
+	private final JavaStatementVisitor clinitStatementVisitor;
+	private EnumDefinition enumDefinition = null;
+
+	public JavaMemberVisitor(ClassWriter writer, JavaClassInfo 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);
+	}
+
 	@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;
-	}
-
-    @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();
-
-        if (!member.isConstructorForwarded()) {
-            if (isEnum) {
-                System.out.println("Writing enum constructor");
-                constructorWriter.getVisitor().newLocal(Type.getType(String.class));
-                constructorWriter.getVisitor().newLocal(Type.getType(int.class));
-                constructorWriter.loadObject(0);
-                constructorWriter.loadObject(1);
-                constructorWriter.loadInt(2);
-                constructorWriter.invokeSpecial(Type.getInternalName(Enum.class), "<init>", "(Ljava/lang/String;I)V");
-            } else if (definition.superType == null) {
-                System.out.println("Writing regular constructor");
-                constructorWriter.load(Type.getType(Object.class), 0);
-                constructorWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
-            }
-
-            CompilerUtils.writeDefaultFieldInitializers(constructorWriter, definition, false);
-        }
-
-        member.body.accept(statementVisitor);
-        constructorWriter.label(constructorEnd);
-        statementVisitor.end();
-        return null;
-    }
-	
+		//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 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();
+
+		if (!member.isConstructorForwarded()) {
+			if (isEnum) {
+				System.out.println("Writing enum constructor");
+				constructorWriter.getVisitor().newLocal(Type.getType(String.class));
+				constructorWriter.getVisitor().newLocal(Type.getType(int.class));
+				constructorWriter.loadObject(0);
+				constructorWriter.loadObject(1);
+				constructorWriter.loadInt(2);
+				constructorWriter.invokeSpecial(Type.getInternalName(Enum.class), "<init>", "(Ljava/lang/String;I)V");
+			} else if (definition.superType == null) {
+				System.out.println("Writing regular constructor");
+				constructorWriter.load(Type.getType(Object.class), 0);
+				constructorWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
+			}
+
+			CompilerUtils.writeDefaultFieldInitializers(constructorWriter, definition, false);
+		}
+
+		member.body.accept(statementVisitor);
+		constructorWriter.label(constructorEnd);
+		statementVisitor.end();
+		return null;
+	}
+
 	@Override
 	public Void visitDestructor(DestructorMember member) {
 		final JavaMethodInfo method = new JavaMethodInfo(toClass, "close", "()V", Opcodes.ACC_PUBLIC);
 
-        final Label constructorStart = new Label();
-        final Label constructorEnd = new Label();
-        final JavaWriter destructorWriter = new JavaWriter(writer, method, definition, null, null);
-        destructorWriter.label(constructorStart);
+		final Label constructorStart = new Label();
+		final Label constructorEnd = new Label();
+		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(destructorWriter);
+		statementVisitor.start();
 		// TODO: destruction of members (to be done when memory tags are implemented)
-        member.body.accept(statementVisitor);
-        destructorWriter.label(constructorEnd);
-        statementVisitor.end();
-        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);
-
-        final Label methodStart = new Label();
-        final Label methodEnd = new Label();
-        final JavaWriter methodWriter = new JavaWriter(writer, method, definition, CompilerUtils.calcSign(member.header, false), null);
-        methodWriter.label(methodStart);
-        for (final FunctionParameter parameter : member.header.parameters) {
-            methodWriter.nameParameter(0, parameter.name);
-            if (!isAbstract)
-                methodWriter.nameVariable(parameter.getTag(JavaParameterInfo.class).index, parameter.name, methodStart, methodEnd, Type.getType(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
-        }
-
-        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(methodWriter);
-
-        if (!isAbstract) {
-            statementVisitor.start();
-            member.body.accept(statementVisitor);
-            methodWriter.label(methodEnd);
-            statementVisitor.end();
-        }
-
-        member.setTag(JavaMethodInfo.class, method);
-        return null;
-    }
-
-    @Override
-    public Void visitGetter(GetterMember member) {
-        return null;
-    }
-
-    @Override
-    public Void visitSetter(SetterMember member) {
-        return null;
-    }
-
-    @Override
-    public Void visitOperator(OperatorMember member) {
-        return null;
-    }
-
-    @Override
-    public Void visitCaster(CasterMember member) {
-        return null;
-    }
-
-    @Override
-    public Void visitCustomIterator(CustomIteratorMember member) {
-        return null;
-    }
-
-    @Override
-    public Void visitCaller(CallerMember member) {
-        return null;
-    }
-
-    @Override
-    public Void visitImplementation(ImplementationMember member) {
-        return null;
-    }
-
-    @Override
-    public Void visitInnerDefinition(InnerDefinitionMember member) {
-        return null;
-    }
-
-    @Override
-    public Void visitStaticInitializer(StaticInitializerMember member) {
-        member.body.accept(clinitStatementVisitor);
-        return null;
-    }
-
-    public void end() {
-
-        if (enumDefinition != null) {
+		member.body.accept(statementVisitor);
+		destructorWriter.label(constructorEnd);
+		statementVisitor.end();
+		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);
+
+		final Label methodStart = new Label();
+		final Label methodEnd = new Label();
+		final JavaWriter methodWriter = new JavaWriter(writer, method, definition, CompilerUtils.calcSign(member.header, false), null);
+		methodWriter.label(methodStart);
+		for (final FunctionParameter parameter : member.header.parameters) {
+			methodWriter.nameParameter(0, parameter.name);
+			if (!isAbstract)
+				methodWriter.nameVariable(parameter.getTag(JavaParameterInfo.class).index, parameter.name, methodStart, methodEnd, Type.getType(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
+		}
+
+		final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(methodWriter);
+
+		if (!isAbstract) {
+			statementVisitor.start();
+			member.body.accept(statementVisitor);
+			methodWriter.label(methodEnd);
+			statementVisitor.end();
+		}
+
+		member.setTag(JavaMethodInfo.class, method);
+		return null;
+	}
+
+	@Override
+	public Void visitGetter(GetterMember member) {
+		return null;
+	}
+
+	@Override
+	public Void visitSetter(SetterMember member) {
+		return null;
+	}
+
+	@Override
+	public Void visitOperator(OperatorMember member) {
+		return null;
+	}
+
+	@Override
+	public Void visitCaster(CasterMember member) {
+		return null;
+	}
+
+	@Override
+	public Void visitCustomIterator(CustomIteratorMember member) {
+		return null;
+	}
+
+	@Override
+	public Void visitCaller(CallerMember member) {
+		return null;
+	}
+
+	@Override
+	public Void visitImplementation(ImplementationMember member) {
+		return null;
+	}
+
+	@Override
+	public Void visitInnerDefinition(InnerDefinitionMember member) {
+		return null;
+	}
+
+	@Override
+	public Void visitStaticInitializer(StaticInitializerMember member) {
+		member.body.accept(clinitStatementVisitor);
+		return null;
+	}
+
+	public void end() {
+
+		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();
@@ -222,25 +222,25 @@ public class JavaMemberVisitor implements MemberVisitor<Void> {
 
 				clinitWriter.invokeSpecial(internalName, "<init>", CompilerUtils.calcDesc(constant.constructor.constructor.header, true));
 				clinitWriter.putStaticField(internalName, constant.name, "L" + internalName + ";");
-				
+
 				enumDefinition = (EnumDefinition) constant.definition;
 			}
-			
-            final JavaWriter clinitWriter = clinitStatementVisitor.getJavaWriter();
-            final List<EnumConstantMember> enumConstants = enumDefinition.enumConstants;
-            clinitWriter.constant(enumConstants.size());
-            clinitWriter.newArray(Type.getType("L" + definition.name + ";"));
-
-            for (EnumConstantMember enumConstant : enumConstants) {
-                clinitWriter.dup();
-                clinitWriter.constant(enumConstant.value);
-                clinitWriter.getStaticField(definition.name, enumConstant.name, "L" + definition.name + ";");
-                clinitWriter.arrayStore(Type.getType("L" + definition.name + ";"));
-            }
-            clinitWriter.putStaticField(definition.name, "$VALUES", "[L" + definition.name + ";");
-        }
-
-
-        clinitStatementVisitor.end();
-    }
+
+			final JavaWriter clinitWriter = clinitStatementVisitor.getJavaWriter();
+			final List<EnumConstantMember> enumConstants = enumDefinition.enumConstants;
+			clinitWriter.constant(enumConstants.size());
+			clinitWriter.newArray(Type.getType("L" + definition.name + ";"));
+
+			for (EnumConstantMember enumConstant : enumConstants) {
+				clinitWriter.dup();
+				clinitWriter.constant(enumConstant.value);
+				clinitWriter.getStaticField(definition.name, enumConstant.name, "L" + definition.name + ";");
+				clinitWriter.arrayStore(Type.getType("L" + definition.name + ";"));
+			}
+			clinitWriter.putStaticField(definition.name, "$VALUES", "[L" + definition.name + ";");
+		}
+
+
+		clinitStatementVisitor.end();
+	}
 }