Merge remote-tracking branch 'remotes/kindlich/development' into development

# Conflicts:
#	JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaCompiler.java
#	JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaFieldInfo.java
#	JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/CompilerUtils.java
#	JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaExpressionVisitor.java
#	JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaOptionalTypeClassVisitor.java
#	JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaPreDecrementVisitor.java
#	JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaPreIncrementVisitor.java
#	JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaStatementVisitor.java
#	JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaTypeClassVisitor.java
#	JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaTypeVisitor.java
#	JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaWriter.java
#	JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaDefinitionVisitor.java
#	JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaMemberVisitor.java

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/VariantOptionRef.java

@@ -32,4 +32,12 @@ public class VariantOptionRef {
 	public <T> T getTag(Class<T> type) {
 		return option.getTag(type);
 	}
+
+	public int getOrdinal() {
+		return option.ordinal;
+	}
+
+	public VariantDefinition.Option getOption() {
+		return option;
+	}
 }

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

@@ -11,7 +11,6 @@ import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.compiler.Target;
 
 /**
- *
  * @author Hoofdgebruiker
  */
 public class JavaBytecodeJarTarget implements Target {
@@ -19,14 +18,14 @@ public class JavaBytecodeJarTarget implements Target {
 	private final String name;
 	private final File file;
 	private final boolean debugCompiler;
-	
+
 	public JavaBytecodeJarTarget(JSONObject definition) {
 		module = definition.getString("module");
 		name = definition.getString("name");
 		file = new File(definition.getString("output"));
 		debugCompiler = definition.optBoolean("debugCompiler", false);
 	}
-	
+
 	@Override
 	public JavaCompiler createCompiler(SemanticModule module) {
 		return new JavaCompiler(debugCompiler, file);

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.getString("name");
 		debugCompiler = definition.optBoolean("debugCompiler", false);
 	}
-	
+
 	@Override
 	public JavaCompiler createCompiler(SemanticModule module) {
 		return new JavaCompiler(debugCompiler, null);

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/JavaCompiler.java

@@ -16,17 +16,18 @@ 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;
 import org.openzen.zenscript.javashared.JavaClass;
 
 /**
- *
  * @author Hoofdgebruiker
  */
 public class JavaCompiler implements ZenCodeCompiler {
@@ -41,7 +42,7 @@ public class JavaCompiler implements ZenCodeCompiler {
 	public JavaCompiler(File jarFile) {
 		this(false, jarFile);
 	}
-	
+
 	public JavaCompiler(boolean debug, File jarFile) {
 		target = new JavaModule();
 		this.jarFile = jarFile;
@@ -50,20 +51,20 @@ public class JavaCompiler implements ZenCodeCompiler {
 		scriptsClassWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 		scriptsClassWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Scripts", null, "java/lang/Object", null);
 	}
-	
+
 	@Override
 	public void addDefinition(HighLevelDefinition definition, SemanticModule module) {
 		String className = getClassName(definition.position.getFilename());
 		JavaScriptFile scriptFile = getScriptFile(className);
 		target.register(definition.name, definition.accept(new JavaDefinitionVisitor(context, scriptFile.classWriter)));
 	}
-	
+
 	@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?)
@@ -71,7 +72,7 @@ public class JavaCompiler implements ZenCodeCompiler {
 		final JavaClassWriter visitor = scriptFile.classWriter;
 		JavaMethodInfo method = new JavaMethodInfo(new JavaClass(script.pkg.fullName, className, JavaClass.Kind.CLASS), methodName, "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 		scriptFile.scriptMethods.add(method);
-		
+
 		final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, new JavaWriter(visitor, method, null, null, null));
 		statementVisitor.start();
 		for (Statement statement : script.statements) {
@@ -80,7 +81,7 @@ public class JavaCompiler implements ZenCodeCompiler {
 		target.register("Scripts", scriptsClassWriter.toByteArray());
 		statementVisitor.end();
 	}
-	
+
 	private String getClassName(String filename) {
 		if (filename == null) {
 			return "generatedBlock" + (generatedScriptBlockCounter++);
@@ -90,26 +91,26 @@ 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() {
 		JavaModule module = finishAndGetModule();
-		
+
 		if (jarFile != null) {
 			// TODO: write module to a Jar file
 		}
 	}
-	
+
 	@Override
 	public void run() {
 		if (!finished)
@@ -117,26 +118,26 @@ public class JavaCompiler implements ZenCodeCompiler {
 		
 		// TODO: execute this
 	}
-	
+
 	public JavaModule finishAndGetModule() {
 		if (finished)
 			throw new IllegalStateException("Already finished!");
 		
 		finished = true;
-		
+
 		JavaMethodInfo runMethod = new JavaMethodInfo(new JavaClass("script", "Scripts", JavaClass.Kind.CLASS), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 		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/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

@@ -10,33 +10,32 @@ import org.objectweb.asm.Type;
 import org.openzen.zenscript.javashared.JavaClass;
 
 /**
- *
  * @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(JavaCompileUtils.get(owner), name, descriptor.toString(), modifiers);
-    }
-	
+	}
+
 	public final JavaClass javaClass;
 	public final String name;
 	public final String descriptor;
 	public final int modifiers;
-	
+
 	public JavaMethodInfo(JavaClass 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,36 +15,35 @@ 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<>();
 

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;
@@ -34,47 +28,47 @@ import org.openzen.zenscript.javashared.JavaSynthesizedClassNamer;
 public class CompilerUtils {
 	private CompilerUtils() {}
 
-    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 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 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.getFilename().substring(0, position.getFilename().lastIndexOf('.')).replace("/", "_");
-    }
+	public static String calcClasName(CodePosition position) {
+		return position.getFilename().substring(0, position.getFilename().lastIndexOf('.')).replace("/", "_");
+	}
 
     public static void tagMethodParameters(JavaContext context, FunctionHeader header, boolean isStatic) {
         for (int i = 0; i < header.parameters.length; i++) {
@@ -153,10 +147,10 @@ public class CompilerUtils {
         return "lambda" + ++lambdaCounter;
     }
 
-    public static int getKeyForSwitch(SwitchValue expression) {
+	public static int getKeyForSwitch(SwitchValue expression) {
 		return expression.accept(new SwitchKeyVisitor());
-    }
-	
+	}
+
 	private static class SwitchKeyVisitor implements SwitchValueVisitor<Integer> {
 
 		@Override
@@ -166,7 +160,7 @@ public class CompilerUtils {
 
 		@Override
 		public Integer acceptChar(CharSwitchValue value) {
-			return (int)value.value;
+			return (int) value.value;
 		}
 
 		@Override
@@ -181,7 +175,7 @@ public class CompilerUtils {
 
 		@Override
 		public Integer acceptVariantOption(VariantOptionSwitchValue value) {
-			throw new UnsupportedOperationException("Not there yet");
+			return value.option.getOrdinal();
 		}
 	}
 }

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

@@ -0,0 +1,115 @@
+package org.openzen.zenscript.javabytecode.compiler;
+
+import org.openzen.zenscript.codemodel.type.*;
+import org.openzen.zenscript.javabytecode.JavaMethodInfo;
+import org.openzen.zenscript.javashared.JavaClass;
+
+public class JavaBoxingTypeVisitor implements ITypeVisitor<JavaMethodInfo> {
+
+	private final JavaWriter writer;
+
+	public JavaBoxingTypeVisitor(JavaWriter writer) {
+		this.writer = writer;
+	}
+
+	@Override
+	public JavaMethodInfo visitBasic(BasicTypeID basic) {
+		final JavaMethodInfo info;
+		switch (basic) {
+			case BOOL:
+				writer.newObject(Boolean.class);
+				info = new JavaMethodInfo(new JavaClass("java.lang", "Boolean", JavaClass.Kind.CLASS), "<init>", "(Z)V", -1);
+				break;
+			case BYTE:
+			case SBYTE:
+				writer.newObject(Byte.class);
+				info = new JavaMethodInfo(new JavaClass("java.lang", "Byte", JavaClass.Kind.CLASS), "<init>", "(B)V", -1);
+				break;
+			case SHORT:
+			case USHORT:
+				writer.newObject(Short.class);
+				info = new JavaMethodInfo(new JavaClass("java.lang", "Short", JavaClass.Kind.CLASS), "<init>", "(S)V", -1);
+				break;
+			case INT:
+			case UINT:
+				writer.newObject(Byte.class);
+				info = new JavaMethodInfo(new JavaClass("java.lang", "Byte", JavaClass.Kind.CLASS), "<init>", "(B)V", -1);
+				break;
+			case LONG:
+			case ULONG:
+				writer.newObject(Long.class);
+				info = new JavaMethodInfo(new JavaClass("java.lang", "Long", JavaClass.Kind.CLASS), "<init>", "(S)V", -1);
+				break;
+			case FLOAT:
+				writer.newObject(Float.class);
+				info = new JavaMethodInfo(new JavaClass("java.lang", "Float", JavaClass.Kind.CLASS), "<init>", "(F)V", -1);
+				break;
+			case DOUBLE:
+				writer.newObject(Double.class);
+				info = new JavaMethodInfo(new JavaClass("java.lang", "Double", JavaClass.Kind.CLASS), "<init>", "(D)V", -1);
+				break;
+			case CHAR:
+				writer.newObject(Character.class);
+				info = new JavaMethodInfo(new JavaClass("java.lang", "Character", JavaClass.Kind.CLASS), "<init>", "(C)V", -1);
+				break;
+			default:
+				return null;
+		}
+		writer.dup();
+		return info;
+	}
+
+	@Override
+	public JavaMethodInfo visitArray(ArrayTypeID array) {
+		//NO-OP
+		return null;
+	}
+
+	@Override
+	public JavaMethodInfo visitAssoc(AssocTypeID assoc) {
+		//NO-OP
+		return null;
+	}
+
+	@Override
+	public JavaMethodInfo visitGenericMap(GenericMapTypeID map) {
+		//NO-OP
+		return null;
+	}
+
+	@Override
+	public JavaMethodInfo visitIterator(IteratorTypeID iterator) {
+		//NO-OP
+		return null;
+	}
+
+	@Override
+	public JavaMethodInfo visitFunction(FunctionTypeID function) {
+		//NO-OP
+		return null;
+	}
+
+	@Override
+	public JavaMethodInfo visitDefinition(DefinitionTypeID definition) {
+		//NO-OP
+		return null;
+	}
+
+	@Override
+	public JavaMethodInfo visitGeneric(GenericTypeID generic) {
+		//NO-OP
+		return null;
+	}
+
+	@Override
+	public JavaMethodInfo visitRange(RangeTypeID range) {
+		//NO-OP
+		return null;
+	}
+
+	@Override
+	public JavaMethodInfo visitModified(ModifiedTypeID type) {
+		//NO-OP
+		return null;
+	}
+}

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

@@ -32,72 +32,72 @@ public class JavaStatementVisitor implements StatementVisitor<Boolean> {
         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);
+	@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) {
@@ -109,219 +109,218 @@ public class JavaStatementVisitor implements StatementVisitor<Boolean> {
             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(context.getType(statement.value.type));
-        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(JavaClass.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 = context.getType(catchClause.exceptionVariable.type);
-            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 = context.getType(statement.type);
-        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;
-    }
+		//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(context.getType(statement.value.type));
+		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(JavaClass.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 = context.getType(catchClause.exceptionVariable.type);
+			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 = context.getType(statement.type);
+		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/JavaWriter.java

@@ -830,6 +830,10 @@ public class JavaWriter {
         invokeSpecial(Type.getInternalName(owner), name, descriptor);
     }
 
+	public void invokeSpecial (JavaMethodInfo method) {
+		invokeSpecial(method.javaClass.internalName, method.name, method.descriptor);
+	}
+
     public void invokeVirtual(JavaMethodInfo method) {
         if (debug)
             System.out.println("invokeVirtual " + method.javaClass.internalName + '.' + method.name + method.descriptor);

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

@@ -3,6 +3,7 @@ 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.Modifiers;
 import org.openzen.zenscript.codemodel.definition.*;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
@@ -13,30 +14,36 @@ import org.openzen.zenscript.javabytecode.JavaModule;
 import org.openzen.zenscript.javabytecode.compiler.*;
 import org.openzen.zenscript.javashared.JavaClass;
 
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.List;
+
+
 public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 	private static final JavaMethodInfo CLASS_FORNAME = new JavaMethodInfo(
 			JavaClass.CLASS,
 			"forName",
 			"(Ljava/lang/String;)Ljava/lang/Class;",
 			Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-	
+
+
 	private static final JavaMethodInfo ENUM_VALUEOF = new JavaMethodInfo(
 			JavaClass.ENUM,
 			"valueOf",
 			"(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;",
 			Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
 
-    private final JavaClassWriter outerWriter;
+	private final JavaClassWriter outerWriter;
 	private final JavaContext context;
 
     public JavaDefinitionVisitor(JavaContext context, JavaClassWriter outerWriter) {
 		this.context = context;
-        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.getSuperType() == null)
@@ -45,7 +52,7 @@ public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
             superType = context.getType(definition.getSuperType());
 
 		JavaClass toClass = new JavaClass(definition.pkg.fullName, definition.name, JavaClass.Kind.CLASS);
-        JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
+		JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
         //TODO: Calculate signature from generic parameters
         //TODO: Interfaces?
@@ -57,30 +64,30 @@ public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
             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) {
 		JavaClass toClass = new JavaClass(definition.pkg.fullName, definition.name, JavaClass.Kind.INTERFACE);
-        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(context, 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.getFilename());
 		
         final Type superType;
@@ -89,14 +96,14 @@ public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
         else
             superType = context.getType(definition.getSuperType());
 
-        ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+		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);
 
 		JavaClass toClass = new JavaClass(definition.pkg.fullName, definition.name, JavaClass.Kind.ENUM);
 
-        //Enum Stuff(required!)
-        writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC, "$VALUES", "[L" + definition.name + ";", null, null).visitEnd();
+		//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(context, writer, toClass, definition);
         for (IDefinitionMember member : definition.members) {
@@ -107,36 +114,36 @@ public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 		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(context, definition.header, true);
 		
         final String signature = context.getMethodSignature(definition.header);
@@ -155,28 +162,138 @@ public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 			else if (type != BasicTypeID.VOID)
 				writer.aConstNull();
 			writer.returnType(context.getType(type));
-        }
+		}
 
-        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) {
+		throw new AssertionError("Aliases shouldn't exist here...");
+	}
 
 	@Override
 	public byte[] visitVariant(VariantDefinition variant) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+
+		final String variantName = variant.name;
+		final JavaClass toClass = new JavaClass("", variantName, JavaClass.Kind.CLASS);
+		final JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
+
+		writer.visit(Opcodes.V1_8, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, variantName, null, "java/lang/Object", null);
+		writer.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, "getDenominator", "()I", null, null).visitEnd();
+
+
+		final JavaMemberVisitor visitor = new JavaMemberVisitor(writer, toClass, variant);
+
+		final List<VariantDefinition.Option> options = variant.options;
+		//Each option is one of the possible child classes
+		for (final VariantDefinition.Option option : options) {
+			final String optionClassName = variantName + "$" + option.name;
+			final JavaClass optionClass = new JavaClass("", optionClassName, JavaClass.Kind.CLASS);
+			final JavaClassWriter optionWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
+
+			writer.visitInnerClass(optionClassName, variantName, option.name, Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL);
+
+
+			option.setTag(JavaClass.class, optionClass);
+
+
+			//Generic option signature
+			final String signature;
+			{
+				StringBuilder builder = new StringBuilder();
+				for (int i = 0; i < option.types.length; ++i) {
+					builder.append("<T").append(i).append(":");
+					builder.append(option.types[i].accept(JavaTypeVisitor.INSTANCE).getDescriptor());
+				}
+				builder.append(">");
+				builder.append("L").append(variantName).append(";");
+
+
+				signature = builder.toString();
+			}
+
+			optionWriter.visit(Opcodes.V1_8, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, optionClassName, signature, variantName, null);
+			final JavaMemberVisitor optionVisitor = new JavaMemberVisitor(optionWriter, optionClass, variant);
+
+
+			final StringBuilder optionInitDescBuilder = new StringBuilder("(");
+
+			ITypeID[] types = option.types;
+			for (int i = 0; i < types.length; ++i) {
+				final Type type = types[i].accept(JavaTypeVisitor.INSTANCE);
+				final String internalName = type.getDescriptor();
+				optionInitDescBuilder.append(internalName);
+				optionWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "Field" + i, internalName, "TT" + i + ";", null).visitEnd();
+			}
+			optionInitDescBuilder.append(")V");
+
+
+			final JavaWriter initWriter = new JavaWriter(optionWriter, new JavaMethodInfo(optionClass, "<init>", optionInitDescBuilder.toString(), Opcodes.ACC_PUBLIC), variant, optionInitDescBuilder.toString(), null);
+			initWriter.start();
+			initWriter.loadObject(0);
+			initWriter.dup();
+			initWriter.invokeSpecial(variantName, "<init>", "()V");
+			for (int i = 0; i < types.length; ++i) {
+				initWriter.dup();
+				initWriter.loadObject(i + 1);
+
+				final Type type = types[i].accept(JavaTypeVisitor.INSTANCE);
+				final String internalName = type.getDescriptor();
+
+				initWriter.putField(optionClassName, "Field" + i, internalName);
+			}
+			initWriter.pop();
+			initWriter.ret();
+			initWriter.end();
+
+
+			//Denominator for switch-cases
+			final JavaWriter getDenominator = new JavaWriter(optionWriter, new JavaMethodInfo(optionClass, "getDenominator", "()I", Modifiers.PUBLIC), null, null, null, "java/lang/Override");
+			getDenominator.start();
+			getDenominator.constant(option.ordinal);
+			getDenominator.returnInt();
+			getDenominator.end();
+
+
+			optionVisitor.end();
+			optionWriter.visitEnd();
+			final byte[] byteArray = optionWriter.toByteArray();
+			JavaModule.classes.put(optionClassName, byteArray);
+
+			//Print the option files, won't be in production
+			try (FileOutputStream out = new FileOutputStream(optionClassName + ".class")) {
+				out.write(byteArray);
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+
+
+		for (final IDefinitionMember member : variant.members) {
+			member.accept(visitor);
+		}
+
+		final JavaWriter superInitWriter = new JavaWriter(writer, new JavaMethodInfo(toClass, "<init>", "()V", Opcodes.ACC_PUBLIC), variant, "()V", null);
+		superInitWriter.start();
+		superInitWriter.loadObject(0);
+		superInitWriter.invokeSpecial("java/lang/Object", "<init>", "()V");
+		superInitWriter.ret();
+		superInitWriter.end();
+
+		visitor.end();
+		writer.visitEnd();
+
+
+		return writer.toByteArray();
 	}
 }

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

@@ -49,8 +49,8 @@ public class JavaMemberVisitor implements MemberVisitor<Void> {
         return null;
 	}
 
-    @Override
-    public Void visitField(FieldMember member) {
+	@Override
+	public Void visitField(FieldMember member) {
 
         //TODO calc signature
         String signature = null;
@@ -83,46 +83,45 @@ public class JavaMemberVisitor implements MemberVisitor<Void> {
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, 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.getSuperType() == null) {
-                System.out.println("Writing regular constructor");
-                constructorWriter.load(Type.getType(Object.class), 0);
-                constructorWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
-            }
-
-            CompilerUtils.writeDefaultFieldInitializers(context, constructorWriter, definition, false);
+		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.getSuperType() == null) {
+				System.out.println("Writing regular constructor");
+				constructorWriter.load(Type.getType(Object.class), 0);
+				constructorWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
+			}
+
         }
 
-        member.body.accept(statementVisitor);
-        constructorWriter.label(constructorEnd);
-        statementVisitor.end();
-        return null;
-    }
-	
+		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(context, 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;
+		member.body.accept(statementVisitor);
+		destructorWriter.label(constructorEnd);
+		statementVisitor.end();
+		return null;
 	}
 
     @Override
@@ -151,66 +150,66 @@ public class JavaMemberVisitor implements MemberVisitor<Void> {
 
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, methodWriter);
 
-        if (!isAbstract) {
-            statementVisitor.start();
-            member.body.accept(statementVisitor);
-            methodWriter.label(methodEnd);
-            statementVisitor.end();
-        }
+		if (!isAbstract) {
+			statementVisitor.start();
+			member.body.accept(statementVisitor);
+			methodWriter.label(methodEnd);
+			statementVisitor.end();
+		}
 
-        member.setTag(JavaMethodInfo.class, method);
-        return null;
-    }
+		member.setTag(JavaMethodInfo.class, method);
+		return null;
+	}
 
-    @Override
-    public Void visitGetter(GetterMember member) {
-        return null;
-    }
+	@Override
+	public Void visitGetter(GetterMember member) {
+		return null;
+	}
 
-    @Override
-    public Void visitSetter(SetterMember member) {
-        return null;
-    }
+	@Override
+	public Void visitSetter(SetterMember member) {
+		return null;
+	}
 
-    @Override
-    public Void visitOperator(OperatorMember member) {
-        return null;
-    }
+	@Override
+	public Void visitOperator(OperatorMember member) {
+		return null;
+	}
 
-    @Override
-    public Void visitCaster(CasterMember member) {
-        return null;
-    }
+	@Override
+	public Void visitCaster(CasterMember member) {
+		return null;
+	}
 
-    @Override
-    public Void visitCustomIterator(CustomIteratorMember member) {
-        return null;
-    }
+	@Override
+	public Void visitCustomIterator(CustomIteratorMember member) {
+		return null;
+	}
 
-    @Override
-    public Void visitCaller(CallerMember member) {
-        return null;
-    }
+	@Override
+	public Void visitCaller(CallerMember member) {
+		return null;
+	}
 
-    @Override
-    public Void visitImplementation(ImplementationMember member) {
-        return null;
-    }
+	@Override
+	public Void visitImplementation(ImplementationMember member) {
+		return null;
+	}
 
-    @Override
-    public Void visitInnerDefinition(InnerDefinitionMember member) {
-        return null;
-    }
+	@Override
+	public Void visitInnerDefinition(InnerDefinitionMember member) {
+		return null;
+	}
 
-    @Override
-    public Void visitStaticInitializer(StaticInitializerMember member) {
-        member.body.accept(clinitStatementVisitor);
-        return null;
-    }
+	@Override
+	public Void visitStaticInitializer(StaticInitializerMember member) {
+		member.body.accept(clinitStatementVisitor);
+		return null;
+	}
 
-    public void end() {
+	public void end() {
 
-        if (enumDefinition != null) {
+		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 = context.getInternalName(constant.constructor.type);
@@ -225,25 +224,25 @@ public class JavaMemberVisitor implements MemberVisitor<Void> {
 
 				clinitWriter.invokeSpecial(internalName, "<init>", context.getEnumConstructorDescriptor(constant.constructor.constructor.getHeader()));
 				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.ordinal);
-                clinitWriter.getStaticField(definition.name, enumConstant.name, "L" + definition.name + ";");
-                clinitWriter.arrayStore(Type.getType("L" + definition.name + ";"));
-            }
-            clinitWriter.putStaticField(definition.name, "$VALUES", "[L" + definition.name + ";");
-        }
 
+			final JavaWriter clinitWriter = clinitStatementVisitor.getJavaWriter();
+			final List<EnumConstantMember> enumConstants = enumDefinition.enumConstants;
+			clinitWriter.constant(enumConstants.size());
+			clinitWriter.newArray(Type.getType("L" + definition.name + ";"));
 
-        clinitStatementVisitor.end();
-    }
+			for (EnumConstantMember enumConstant : enumConstants) {
+				clinitWriter.dup();
+				clinitWriter.constant(enumConstant.ordinal);
+				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();
+	}
 }

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

@@ -0,0 +1,9 @@
+package org.openzen.zenscript.javabytecode.compiler.definitions;
+
+public class JavaOptionInfoTag {
+	public final int number;
+
+	public JavaOptionInfoTag(int number) {
+		this.number = number;
+	}
+}

ScriptingExample/scripts/ttt/functions_lambdas.zs

@@ -0,0 +1,22 @@
+val outOfScope = 10;
+val fun1 = (a as int, b as int) as int => a + b * outOfScope;
+val fun2 = (a as int, c as int) as int => 13;
+
+
+
+function apply(fn as function(value as int) as int, scale as int) as int {
+    return fn(scale);
+}
+
+
+println(fun1(30, 20));
+println(fun2(30, 20));
+
+
+
+
+function scale(value as int, scale as int) as int {
+    return apply(v => v * scale, value);
+}
+
+println("Value: " + scale(10, 5));

ScriptingExample/scripts/match.zs → ScriptingExample/scripts/ttt/match.zs

@@ -23,4 +23,29 @@ println(tt1);
 //println(match test {
 //	case 1 : "tt",
 //	default : "kk"
-//});
+//});
+
+
+
+function myFunc (par1 as int) as void {
+
+    val v0 = par1 - 1;
+	println(match par1 {
+		10 => v0,
+		default => match(v0) {
+			10 => 99,
+			default => v0
+		}
+	});
+}
+
+
+myFunc(10);
+myFunc(11);
+myFunc(12);
+
+
+val t = (a as int) as int => a;
+
+
+println(t(10));