Merge branch 'development_kindlich' into development

# Conflicts:
#	JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaExpressionVisitor.java
#	JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaWriter.java

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

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

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

 		}
 	}
 	
-	private class ScriptClassLoader extends ClassLoader {
+	public class ScriptClassLoader extends ClassLoader {
 		private final Map<String, Class> customClasses = new HashMap<>();
 
 		@Override

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

 package org.openzen.zenscript.javabytecode.compiler;
 
+import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.javabytecode.JavaModule;
 import org.openzen.zenscript.javabytecode.JavaParameterInfo;
 
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
 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(Type.getDescriptor(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
+            descBuilder.append(parameter.type.accept(JavaTypeVisitor.INSTANCE).getDescriptor());
         }
         descBuilder.append(")");
-        descBuilder.append(Type.getDescriptor(header.returnType.accept(JavaTypeClassVisitor.INSTANCE)));
+        descBuilder.append(header.returnType.accept(JavaTypeVisitor.INSTANCE).getDescriptor());
         return descBuilder.toString();
     }
 
         }
     }
 
+    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());

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

 
     @Override
     public Void visitCapturedParameter(CapturedParameterExpression expression) {
-        return null;
+        return new GetFunctionParameterExpression(expression.position, expression.parameter).accept(expressionVisitor);
     }
 
     @Override
     public Void visitCapturedLocal(CapturedLocalVariableExpression expression) {
-        new GetLocalVariableExpression(expression.position, expression.variable)
+        return new GetLocalVariableExpression(expression.position, expression.variable)
                 .accept(expressionVisitor);
-        return null;
     }
 
     @Override

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

 import java.util.Comparator;
 import java.util.Map;
 import java.util.StringJoiner;
+import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Label;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.CompareType;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.implementations.IntRange;
 import org.openzen.zenscript.javabytecode.*;
 
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.*;
+
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 	private static final int PUBLIC = Opcodes.ACC_PUBLIC;
 	private static final int STATIC = Opcodes.ACC_STATIC;
 	private static final int PUBLIC_STATIC = PUBLIC | STATIC;
-	
+
 	private static final JavaClassInfo BOOLEAN = JavaClassInfo.get(Boolean.class);
 	private static final JavaMethodInfo BOOLEAN_PARSE = new JavaMethodInfo(BOOLEAN, "parseBoolean", "(Ljava/lang/String;)Z", PUBLIC_STATIC);
 	private static final JavaMethodInfo BOOLEAN_TO_STRING = new JavaMethodInfo(BOOLEAN, "toString", "(Z)Ljava/lang/String;", PUBLIC_STATIC);
 		} else {
 			if (!checkAndExecuteMethodInfo(expression.operator))
 				throw new IllegalStateException("Call target has no method info!");
-			
+
 			expression.left.accept(this);
 			expression.right.accept(this);
 			compareGeneric(expression.comparison);
 
         return null;
     }
-	
+
 	private void compareInt(CompareType comparator) {
 		Label exit = new Label();
 		Label isTrue = new Label();
 		javaWriter.iConst1();
 		javaWriter.label(exit);
 	}
-	
+
 	private void compareGeneric(CompareType comparator) {
 		Label exit = new Label();
 		Label isTrue = new Label();
 
 			if (!checkAndExecuteMethodInfo(expression.member))
 	            throw new IllegalStateException("Call target has no method info!");
-			
+
 			return null;
 		}
-		
+
 		switch (builtin) {
 			case STRING_RANGEGET:
 			case ARRAY_INDEXGETRANGE:
 					argument.accept(this);
 				}
 		}
-		
+
 		switch (builtin) {
 			case BOOL_NOT:
 				javaWriter.iConst1();
 			case ASSOC_INDEXGET:
 			case ASSOC_GETORDEFAULT: {
 				javaWriter.invokeVirtual(MAP_GET);
-				
+
 				AssocTypeID type = (AssocTypeID) expression.target.type;
 				Type cls = type.valueType.accept(JavaTypeVisitor.INSTANCE);
 				javaWriter.checkCast(cls.getInternalName());
 			}
 			case ARRAY_INDEXGETRANGE: {
 				ArrayTypeID type = (ArrayTypeID) expression.target.type;
-				
+
 				expression.target.accept(this);
 				Expression argument = expression.arguments.arguments[0];
 				if (argument instanceof RangeExpression) {
 					javaWriter.loadInt(tmp);
 					javaWriter.getField("zsynthetic/IntRange", "to", "I");
 				}
-				
+
 				if (type.elementType instanceof BasicTypeID) {
 					switch ((BasicTypeID) type.elementType) {
 						case BOOL:
 				} else {
 					javaWriter.invokeStatic(ARRAYS_EQUALS_OBJECTS);
 				}
-				
+
 				if (builtin == BuiltinID.ARRAY_NOTEQUALS) {
 					javaWriter.iConst1();
 					javaWriter.iXor();
 				break;
 			}
 			case FUNCTION_CALL:
-				throw new UnsupportedOperationException("Not yet supported!");
+				//expression.target.accept(this);
+				//for (Expression argument : expression.arguments.arguments) {
+				//	argument.accept(this);
+				//}
+				javaWriter.invokeInterface(new JavaMethodInfo(new JavaClassInfo(expression.target.type.accept(JavaTypeVisitor.INSTANCE).getInternalName()), "accept", CompilerUtils.calcSign(expression.instancedHeader, false), Opcodes.ACC_PUBLIC));
+				break;
+				//throw new UnsupportedOperationException("Not yet supported!");
 			case AUTOOP_NOTEQUALS:
 				throw new UnsupportedOperationException("Not yet supported!");
 			default:
         return null;
     }
 
-    @Override
+	@Override
     public Void visitCallStatic(CallStaticExpression expression) {
 		for (Expression argument : expression.arguments.arguments)
 			argument.accept(this);
-		
+
 		BuiltinID builtin = expression.member.getBuiltin();
 		if (builtin == null) {
 			if (!checkAndExecuteMethodInfo(expression.member))
 	            throw new IllegalStateException("Call target has no method info!");
-			
+
 			return null;
 		}
-		
+
 		switch (builtin) {
 			case BOOL_PARSE:
 				javaWriter.invokeStatic(BOOLEAN_PARSE);
     @Override
     public Void visitCast(CastExpression expression) {
         expression.target.accept(this);
-		
+
 		BuiltinID builtin = expression.member.member.builtin;
 		if (builtin == null) {
 			if (!checkAndExecuteByteCodeImplementation(expression.member) && !checkAndExecuteMethodInfo(expression.member))
 				throw new IllegalStateException("Call target has no method info!");
-			
+
 			return null;
 		}
-		
+
 		switch (builtin) {
 			case BOOL_TO_STRING:
 				javaWriter.invokeStatic(BOOLEAN_TO_STRING);
 			default:
 				throw new UnsupportedOperationException("Unknown builtin cast: " + builtin);
 		}
-		
+
 		return null;
     }
 
         javaWriter.label(end);
         return null;
     }
-	
+
 	@Override
 	public Void visitConst(ConstExpression expression) {
 		BuiltinID builtin = expression.constant.member.builtin;
 		if (builtin == null) {
 			if (!checkAndGetFieldInfo(expression.constant, true))
 	            throw new IllegalStateException("Call target has no field info!");
-			
+
 			return null;
 		}
-		
+
 		switch (builtin) {
 			case BYTE_GET_MIN_VALUE:
 				javaWriter.iConst0();
 			default:
 				throw new UnsupportedOperationException("Unknown builtin: " + builtin);
 		}
-		
+
 		return null;
 	}
 
 
     @Override
     public Void visitFunction(FunctionExpression expression) {
+		CompilerUtils.tagMethodParameters(expression.header, false);
+
         if (expression.header.parameters.length == 0 && expression.body instanceof ReturnStatement && expression.body.hasTag(MatchExpression.class) && expression.closure.captures.isEmpty()) {
             ((ReturnStatement) expression.body).value.accept(this);
             return null;
         }
-        final String signature = calcFunctionSignature(expression.closure, expression.header.returnType);
-        final String name = "lambda" + expression.hashCode();
+        final String signature = CompilerUtils.calcSign(expression.header, false);
+        //final String name = CompilerUtils.getLambdaInterface(expression.header);
+		final String name = CompilerUtils.getLambdaCounter();
 
-        final JavaMethodInfo methodInfo = new JavaMethodInfo(javaWriter.method.javaClass, name, signature, Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE);
-        JavaWriter functionWriter = new JavaWriter(javaWriter.clazzVisitor, methodInfo, null, signature, null);
+        final JavaMethodInfo methodInfo = new JavaMethodInfo(javaWriter.method.javaClass, "accept", signature, Opcodes.ACC_PUBLIC);
+		final ClassWriter lambdaCW = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+		lambdaCW.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, name, null, "java/lang/Object", new String[]{CompilerUtils.getLambdaInterface(expression.header)});
+		final JavaWriter functionWriter = new JavaWriter(lambdaCW, methodInfo, null, signature, null, "java/lang/Override");
+
+
+
+		javaWriter.newObject(name);
+		javaWriter.dup();
+
+		final String constructorDesc = calcFunctionSignature(expression.closure);
+
+
+		final JavaWriter constructorWriter = new JavaWriter(lambdaCW, new JavaMethodInfo(javaWriter.method.javaClass, "<init>", constructorDesc, Opcodes.ACC_PUBLIC), null, null, null);
+		constructorWriter.start();
+		constructorWriter.loadObject(0);
+		constructorWriter.dup();
+		constructorWriter.invokeSpecial(Object.class, "<init>", "()V");
+
+		int i = 0;
+		for (CapturedExpression capture : expression.closure.captures) {
+			constructorWriter.dup();
+			final Type type = capture.type.accept(JavaTypeVisitor.INSTANCE);
+			lambdaCW.visitField(Opcodes.ACC_FINAL | Opcodes.ACC_PRIVATE, "captured" + ++i, type.getDescriptor(), null, null).visitEnd();
+
+			capture.accept(this);
+
+			constructorWriter.load(type, i);
+			constructorWriter.putField(name, "captured" + i, type.getDescriptor());
+		}
+
+		constructorWriter.pop();
+
+		javaWriter.invokeSpecial(name, "<init>", constructorDesc);
+
+		constructorWriter.ret();
+		constructorWriter.end();
 
-        for (CapturedExpression capture : expression.closure.captures) {
-            capture.accept(new JavaCapturedExpressionVisitor(this));
-        }
 
-        javaWriter.invokeStatic(methodInfo);
 
         functionWriter.start();
-        expression.body.accept(new JavaStatementVisitor(new JavaExpressionVisitor(functionWriter) {
-            @Override
-            public Void visitGetLocalVariable(GetLocalVariableExpression varExpression) {
-                final int position = calculateMemberPosition(varExpression, expression);
-                if (position < 0)
-                    throw new CompileException(varExpression.position, CompileExceptionCode.INTERNAL_ERROR, "Captured Statement error");
-                functionWriter.load(varExpression.variable.type.accept(JavaTypeVisitor.INSTANCE), position);
-                return null;
-            }
-        }));
+
+
+		final JavaStatementVisitor CSV = new JavaStatementVisitor(new JavaExpressionVisitor(functionWriter) {
+			//@Override
+			public Void visitGetLocalVariable(GetLocalVariableExpression varExpression) {
+				final int position = calculateMemberPosition(varExpression, expression) ;
+				if (position < 0)
+					throw new CompileException(varExpression.position, CompileExceptionCode.INTERNAL_ERROR, "Captured Statement error");
+				functionWriter.loadObject(0);
+				functionWriter.getField(name, "captured" + position, varExpression.variable.type.accept(JavaTypeVisitor.INSTANCE).getDescriptor());
+				return null;
+			}
+		});
+
+
+		expression.body.accept(CSV);
 
 
         functionWriter.ret();
-        functionWriter.end();
 
-        return null;
+
+
+		functionWriter.end();
+        lambdaCW.visitEnd();
+
+        JavaModule.classes.putIfAbsent(name, lambdaCW.toByteArray());
+
+        try (FileOutputStream out = new FileOutputStream(name + ".class")){
+        	out.write(lambdaCW.toByteArray());
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+
+		return null;
     }
 
     //TODO replace with visitor?
     private static int calculateMemberPosition(GetLocalVariableExpression localVariableExpression, FunctionExpression expression) {
-        int h = expression.header.parameters.length;
+        int h = 1;//expression.header.parameters.length;
         for (CapturedExpression capture : expression.closure.captures) {
             if (capture instanceof CapturedLocalVariableExpression && ((CapturedLocalVariableExpression) capture).variable == localVariableExpression.variable)
                 return h;
         return -1;
     }
 
-    private String calcFunctionSignature(LambdaClosure closure, ITypeID type) {
-        StringJoiner joiner = new StringJoiner("", "(", ")");
+    private String calcFunctionSignature(LambdaClosure closure) {
+        StringJoiner joiner = new StringJoiner("", "(", ")V");
 
         for (CapturedExpression capture : closure.captures) {
             String descriptor = capture.type.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
             joiner.add(descriptor);
         }
-        return joiner.toString() + type.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+        return joiner.toString();
     }
 
     @Override
     @Override
     public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
         JavaParameterInfo parameter = expression.parameter.getTag(JavaParameterInfo.class);
-        javaWriter.load(Type.getType(expression.parameter.type.accept(JavaTypeClassVisitor.INSTANCE)), parameter.index);
+
+        if(parameter == null) {
+			System.err.println("NULL PARAMETER!!!");
+			//FIXME
+			parameter = new JavaParameterInfo(1, Type.INT_TYPE);
+		}
+
+        javaWriter.load(expression.parameter.type.accept(JavaTypeVisitor.INSTANCE), parameter.index);
         return null;
     }
 
     @Override
     public Void visitGetter(GetterExpression expression) {
 		expression.target.accept(this);
-		
+
 		BuiltinID builtin = expression.getter.member.builtin;
 		if (builtin == null) {
 			if (!checkAndExecuteMethodInfo(expression.getter))
 	            throw new IllegalStateException("Call target has no method info!");
-			
+
 			return null;
 		}
-		
+
 		switch (builtin) {
 			case INT_HIGHEST_ONE_BIT:
 			case UINT_HIGHEST_ONE_BIT:
 				AssocTypeID type = (AssocTypeID) expression.target.type;
 				ArrayTypeID result = new ArrayTypeID(type.keyType, 1);
 				Type resultType = result.accept(JavaTypeVisitor.INSTANCE);
-				
+
 				javaWriter.invokeVirtual(MAP_KEYS);
 				javaWriter.dup();
 				javaWriter.invokeVirtual(COLLECTION_SIZE);
 				AssocTypeID type = (AssocTypeID) expression.target.type;
 				ArrayTypeID result = new ArrayTypeID(type.valueType, 1);
 				Type resultType = result.accept(JavaTypeVisitor.INSTANCE);
-				
+
 				javaWriter.invokeVirtual(MAP_VALUES);
 				javaWriter.dup();
 				javaWriter.invokeVirtual(COLLECTION_SIZE);
 			case ARRAY_ISEMPTY:
 				Label isTrue = new Label();
 				Label exit = new Label();
-				
+
 				javaWriter.arrayLength();
 				javaWriter.ifEQ(isTrue);
 				javaWriter.iConst0();
 
         return null;
     }
-	
+
 	@Override
 	public Void visitPanic(PanicExpression expression) {
 		// TODO: compile to: throw new AssertionError(expression.value)
 		throw new UnsupportedOperationException("Not yet supported");
 	}
-	
+
 	@Override
 	public Void visitPostCall(PostCallExpression expression) {
 		expression.target.accept(this);
         return null;
     }
 
-	
+
 	@Override
 	public Void visitSameObject(SameObjectExpression expression) {
 		expression.left.accept(this);
 		expression.right.accept(this);
-		
+
 		Label end = new Label();
 		Label equal = new Label();
-		
+
 		if (expression.inverted)
 			javaWriter.ifACmpNe(equal);
 		else
 			javaWriter.ifACmpEq(equal);
-		
+
 		javaWriter.iConst0();
 		javaWriter.goTo(end);
 		javaWriter.label(equal);
     public Void visitSetStaticField(SetStaticFieldExpression expression) {
         if (expression.field.isFinal())
             throw new CompileException(expression.position, CompileExceptionCode.CANNOT_SET_FINAL_VARIABLE, "Cannot set a final field!");
-		
+
         expression.value.accept(this);
         if (!checkAndPutFieldInfo(expression.field, true))
             throw new IllegalStateException("Missing field info on a field member!");
 		if (builtin == null) {
 			if (!checkAndExecuteMethodInfo(expression.getter))
 	            throw new IllegalStateException("Call target has no method info!");
-			
+
 			return null;
 		}
-		
+
 		switch (builtin) {
 			case BYTE_GET_MIN_VALUE:
 				javaWriter.iConst0();
 			default:
 				throw new UnsupportedOperationException("Unknown builtin: " + builtin);
 		}
-		
+
 		throw new UnsupportedOperationException("Unknown builtin: " + builtin);
     }
 
         JavaMethodInfo methodInfo = member.getTag(JavaMethodInfo.class);
         if (methodInfo == null)
             return false;
-		
+
         if (methodInfo.isStatic()) {
             getJavaWriter().invokeStatic(methodInfo);
         } else {
         JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
         if (fieldInfo == null)
             return false;
-		
+
         getJavaWriter().getStaticField(fieldInfo);
         return true;
     }
         JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
         if (fieldInfo == null)
             return false;
-		
+
         //TODO Remove isStatic
         if (field.isStatic() || isStatic) {
             getJavaWriter().getStaticField(fieldInfo);

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

     @Override
     public Void visitIntRange() {
         javaWriter.dup();
-        javaWriter.getField("org/openzen/zenscript/implementations/IntRange", "max", "I");
+        javaWriter.getField("org/openzen/zenscript/implementations/IntRange", "to", "I");
         javaWriter.swap();
-        javaWriter.getField("org/openzen/zenscript/implementations/IntRange", "min", "I");
+        javaWriter.getField("org/openzen/zenscript/implementations/IntRange", "from", "I");
 
         final int z = variables[0].getTag(JavaLocalVariableInfo.class).local;
         javaWriter.storeInt(z);

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

 
     @Override
     public Boolean visitVar(VarStatement statement) {
-        Type type = statement.type.accept(JavaTypeVisitor.INSTANCE);
-        int local = javaWriter.local(type);
+
         if (statement.initializer != null) {
             statement.initializer.accept(expressionVisitor);
-            javaWriter.store(type, local);
         }
+
+        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);

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

 package org.openzen.zenscript.javabytecode.compiler;
 
 import org.openzen.zenscript.codemodel.type.*;
+import org.openzen.zenscript.javabytecode.JavaModule;
 
 import java.lang.reflect.Array;
 import java.util.Iterator;
 
     @Override
     public Class visitFunction(FunctionTypeID function) {
-        return null;
+        try {
+            return new JavaModule().new ScriptClassLoader().loadClass(CompilerUtils.getLambdaInterface(function.header));
+        } catch (ClassNotFoundException e) {
+            return null;
+        }
+        //return function.header.returnType.accept(this);
     }
 
     @Override

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

 
     @Override
     public Type visitFunction(FunctionTypeID function) {
-        return Type.getType(function.accept(JavaTypeClassVisitor.INSTANCE));
+        Class clazz = function.accept(JavaTypeClassVisitor.INSTANCE);
+        return clazz != null ? Type.getType(clazz) : Type.getType("L" + CompilerUtils.getLambdaInterface(function.header) + ";");
     }
 
     @Override

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

 package org.openzen.zenscript.javabytecode.compiler;
 
+import org.objectweb.asm.*;
+import org.objectweb.asm.commons.LocalVariablesSorter;
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.javabytecode.*;
+
 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.HashMap;

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

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

Shared/src/main/java/zsynthetic/ArrayHelpers.java

 public class ArrayHelpers {
     public static <T> boolean contains(T[] haystack, T needle) {
         for (int i = 0; i < haystack.length; i++)
-            if (haystack[i].equals(needle))
+            if (java.util.Objects.equals(haystack[i], needle))
                 return true;
         return false;
     }