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

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/ExpressionFormatter.java

 		result.append("match ");
 		result.append(expression.value.accept(this));
 		result.append(" {\n");
-		
-		throw new UnsupportedOperationException();
+
+		return new ExpressionString(result.toString(), ZenScriptOperator.PRIMARY);
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/DummyExpression.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.expression;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DummyExpression extends Expression {
+	public DummyExpression(ITypeID type) {
+		super(CodePosition.BUILTIN, type, null);
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		throw new UnsupportedOperationException("This is a dummy expression");
+	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		throw new UnsupportedOperationException("This is a dummy expression");
+	}
+}

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

  * @author Hoofdgebruiker
  */
 public class JavaModule {
-	private final Map<String, byte[]> classes = new HashMap<>();
+	public static final Map<String, byte[]> classes = new HashMap<>();
 	
 	public JavaModule() {
 		

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

+package org.openzen.zenscript.javabytecode.compiler;
+
+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 null;
+    }
+
+    @Override
+    public Void visitCapturedLocal(CapturedLocalVariableExpression expression) {
+        new GetLocalVariableExpression(expression.position, expression.variable)
+                .accept(expressionVisitor);
+        return null;
+    }
+
+    @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/JavaExpressionVisitor.java

 
 import java.util.Arrays;
 import java.util.Collection;
-import org.objectweb.asm.Label;
-import org.objectweb.asm.Type;
-import org.openzen.zenscript.codemodel.CompareType;
-import org.openzen.zenscript.codemodel.expression.*;
-import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.implementations.IntRange;
-import org.openzen.zenscript.javabytecode.*;
-
+import java.util.Comparator;
 import java.util.Map;
+import java.util.StringJoiner;
+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.expression.*;
 import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
-import org.openzen.zenscript.codemodel.type.ArrayTypeID;
-import org.openzen.zenscript.codemodel.type.AssocTypeID;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.statement.ReturnStatement;
+import org.openzen.zenscript.codemodel.type.*;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
+import org.openzen.zenscript.implementations.IntRange;
+import org.openzen.zenscript.javabytecode.*;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 	private static final int PUBLIC = Opcodes.ACC_PUBLIC;
 	private static final JavaClassInfo COLLECTION = JavaClassInfo.get(Collection.class);
 	private static final JavaMethodInfo COLLECTION_SIZE = new JavaMethodInfo(COLLECTION, "size", "()I", PUBLIC);
 	private static final JavaMethodInfo COLLECTION_TOARRAY = new JavaMethodInfo(COLLECTION, "toArray", "([Ljava/lang/Object;)[Ljava/lang/Object;", PUBLIC);
-	
+
     private final JavaWriter javaWriter;
-	
+    private final JavaCapturedExpressionVisitor capturedExpressionVisitor = new JavaCapturedExpressionVisitor(this);
+
     public JavaExpressionVisitor(JavaWriter javaWriter) {
         this.javaWriter = javaWriter;
     }
 
     @Override
     public Void visitCapturedClosure(CapturedClosureExpression expression) {
-        return null;
+        return expression.accept(capturedExpressionVisitor);
     }
 
     @Override
     public Void visitCapturedDirect(CapturedDirectExpression expression) {
-        return null;
+        return expression.accept(capturedExpressionVisitor);
     }
 
     @Override
     public Void visitCapturedLocalVariable(CapturedLocalVariableExpression expression) {
-        return null;
+        return expression.accept(capturedExpressionVisitor);
     }
 
     @Override
     public Void visitCapturedParameter(CapturedParameterExpression expression) {
-        return null;
-    }
+        return expression.accept(capturedExpressionVisitor);
+	}
 
     @Override
     public Void visitCapturedThis(CapturedThisExpression expression) {
-        return null;
+        return expression.accept(capturedExpressionVisitor);
     }
 
     @Override
     @Override
     public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
         Type type = expression.objectType.accept(JavaTypeVisitor.INSTANCE);
-		
-		if (javaWriter.method.javaClass.isEnum) {
-			javaWriter.loadObject(0);
-			javaWriter.loadObject(1);
-			javaWriter.loadInt(2);
-		} else {
-			javaWriter.loadObject(0);
-		}
-		
+
+        javaWriter.loadObject(0);
+        if (javaWriter.method.javaClass.isEnum) {
+            javaWriter.loadObject(1);
+            javaWriter.loadInt(2);
+        }
+
         for (Expression argument : expression.arguments.arguments) {
             argument.accept(this);
         }
         }
         //No super calls in enums possible, and that's already handled in the enum constructor itself.
         javaWriter.invokeSpecial(expression.objectType.accept(JavaTypeClassVisitor.INSTANCE), "<init>", CompilerUtils.calcDesc(expression.constructor.header, false));
-		
-		CompilerUtils.writeDefaultFieldInitializers(javaWriter, javaWriter.forDefinition, false);
+
+        CompilerUtils.writeDefaultFieldInitializers(javaWriter, javaWriter.forDefinition, false);
         return null;
     }
 
 
     @Override
     public Void visitFunction(FunctionExpression expression) {
+        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 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);
+
+        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;
+            }
+        }));
+
+
+        functionWriter.ret();
+        functionWriter.end();
+
         return null;
     }
 
+    //TODO replace with visitor?
+    private static int calculateMemberPosition(GetLocalVariableExpression localVariableExpression, FunctionExpression expression) {
+        int h = expression.header.parameters.length;
+        for (CapturedExpression capture : expression.closure.captures) {
+            if (capture instanceof CapturedLocalVariableExpression && ((CapturedLocalVariableExpression) capture).variable == localVariableExpression.variable)
+                return h;
+            if (capture instanceof CapturedClosureExpression && ((CapturedClosureExpression) capture).value instanceof CapturedLocalVariableExpression && ((CapturedLocalVariableExpression) ((CapturedClosureExpression) capture).value).variable == localVariableExpression.variable)
+                return h;
+            h++;
+        }
+        return -1;
+    }
+
+    private String calcFunctionSignature(LambdaClosure closure, ITypeID type) {
+        StringJoiner joiner = new StringJoiner("", "(", ")");
+
+        for (CapturedExpression capture : closure.captures) {
+            String descriptor = capture.type.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+            joiner.add(descriptor);
+        }
+        return joiner.toString() + type.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+    }
+
     @Override
     public Void visitGetField(GetFieldExpression expression) {
-		expression.accept(this);
+        expression.accept(this);
         if (!checkAndGetFieldInfo(expression.field, false))
             throw new IllegalStateException("Missing field info on a field member!");
         return null;
 
     @Override
     public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
-		JavaParameterInfo parameter = expression.parameter.getTag(JavaParameterInfo.class);
+        JavaParameterInfo parameter = expression.parameter.getTag(JavaParameterInfo.class);
         javaWriter.load(Type.getType(expression.parameter.type.accept(JavaTypeClassVisitor.INSTANCE)), parameter.index);
         return null;
     }
 				javaWriter.getField(IntRange.class, "to", int.class);
 				break;
 		}
-		
+
         return null;
     }
 
         }
         return null;
     }
-	
-	@Override
-	public Void visitMatch(MatchExpression expression) {
-		throw new UnsupportedOperationException();
-	}
+
+    @Override
+    public Void visitMatch(MatchExpression expression) {
+
+        final Label start = new Label();
+        final Label end = new Label();
+
+
+        javaWriter.label(start);
+        expression.value.accept(this);
+        if (expression.value.type == BasicTypeID.STRING)
+            javaWriter.invokeVirtual(new JavaMethodInfo(new JavaClassInfo("java/lang/Object"), "hashCode", "()I", 0));
+
+        final boolean hasNoDefault = hasNoDefault(expression);
+
+        final MatchExpression.Case[] cases = expression.cases;
+        final JavaSwitchLabel[] switchLabels = new JavaSwitchLabel[hasNoDefault ? cases.length : cases.length - 1];
+        final Label defaultLabel = new Label();
+
+        int i = 0;
+        for (final MatchExpression.Case matchCase : cases) {
+            if (matchCase.key != null) {
+                switchLabels[i++] = new JavaSwitchLabel(CompilerUtils.getKeyForSwitch(matchCase.key), new Label());
+            }
+        }
+
+        JavaSwitchLabel[] sortedSwitchLabels = Arrays.copyOf(switchLabels, switchLabels.length);
+        Arrays.sort(sortedSwitchLabels, Comparator.comparingInt(a -> a.key));
+
+        javaWriter.lookupSwitch(defaultLabel, sortedSwitchLabels);
+
+        i = 0;
+        for (final MatchExpression.Case switchCase : cases) {
+            if (hasNoDefault || switchCase.key != null) {
+                javaWriter.label(switchLabels[i++].label);
+            } else {
+                javaWriter.label(defaultLabel);
+            }
+            //switchCase.value.body.setTag(MatchExpression.class, expression);
+            switchCase.value.accept(this);
+            javaWriter.goTo(end);
+        }
+
+        if (hasNoDefault) {
+            javaWriter.label(defaultLabel);
+        }
+
+        javaWriter.label(end);
+
+
+        //throw new UnsupportedOperationException("Not yet implemented!");
+        return null;
+    }
+
+    private static boolean hasNoDefault(MatchExpression switchStatement) {
+        for (MatchExpression.Case switchCase : switchStatement.cases)
+            if (switchCase.key == null) return false;
+        return true;
+    }
 
     @Override
     public Void visitNew(NewExpression expression) {
 		javaWriter.dup(expression.type.accept(new JavaTypeVisitor()));
         if (!checkAndExecuteByteCodeImplementation(expression.member) && !checkAndExecuteMethodInfo(expression.member))
             throw new IllegalStateException("Call target has no method info!");
-		
-		return null;
-	}
+
+        return null;
+    }
 
     @Override
     public Void visitRange(RangeExpression expression) {
-		// TODO: there are other kinds of ranges also; there should be a Range<T, T> type with creation of synthetic types
+        // TODO: there are other kinds of ranges also; there should be a Range<T, T> type with creation of synthetic types
         if (expression.from.type.accept(JavaTypeClassVisitor.INSTANCE) != int.class)
             throw new CompileException(expression.position, CompileExceptionCode.INTERNAL_ERROR, "Only integer ranges supported");
-		
+
         javaWriter.newObject(IntRange.class);
         javaWriter.dup();
         expression.from.accept(this);
 
         return null;
     }
+
 	
 	@Override
 	public Void visitSameObject(SameObjectExpression expression) {
     @Override
     public Void visitSetFunctionParameter(SetFunctionParameterExpression expression) {
         expression.value.accept(this);
-		JavaParameterInfo parameter = expression.parameter.getTag(JavaParameterInfo.class);
+        JavaParameterInfo parameter = expression.parameter.getTag(JavaParameterInfo.class);
         javaWriter.store(expression.type.accept(JavaTypeVisitor.INSTANCE), parameter.index);
         return null;
     }
     public Void visitStaticSetter(StaticSetterExpression expression) {
         return null;
     }
-	
-	@Override
-	public Void visitSupertypeCast(SupertypeCastExpression expression) {
-		return null; // nothing to do
-	}
+
+    @Override
+    public Void visitSupertypeCast(SupertypeCastExpression expression) {
+        return null; // nothing to do
+    }
 
     @Override
     public Void visitThis(ThisExpression expression) {
 		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
 	}
 
-	@Override
-	public Void visitTryRethrowAsException(TryRethrowAsExceptionExpression expression) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-	}
+    @Override
+    public Void visitTryRethrowAsException(TryRethrowAsExceptionExpression expression) {
+        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+    }
 
-	@Override
-	public Void visitTryRethrowAsResult(TryRethrowAsResultExpression expression) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-	}
-	
-	@Override
-	public Void visitVariantValue(VariantValueExpression expression) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-	}
+    @Override
+    public Void visitTryRethrowAsResult(TryRethrowAsResultExpression expression) {
+        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+    }
+
+    @Override
+    public Void visitVariantValue(VariantValueExpression expression) {
+        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+    }
 
     @Override
     public Void visitWrapOptional(WrapOptionalExpression expression) {
-		// TODO: convert basic types (char, int, float, ...) to their boxed (Character, Integer, Float, ...) counterparts
-		// -- any object type values can just be passed as-is
+        // TODO: convert basic types (char, int, float, ...) to their boxed (Character, Integer, Float, ...) counterparts
+        // -- any object type values can just be passed as-is
         expression.value.accept(this);
         return null;
     }

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

 
 public class JavaStatementVisitor implements StatementVisitor<Boolean> {
     private final JavaWriter javaWriter;
-    public final JavaExpressionVisitor expressionVisitor;
+    public JavaExpressionVisitor expressionVisitor;
 
     /**
      * @param javaWriter the method writer that compiles the statement
         this.expressionVisitor = new JavaExpressionVisitor(javaWriter);
     }
 
+    public JavaStatementVisitor(JavaExpressionVisitor expressionVisitor) {
+        this.javaWriter = expressionVisitor.getJavaWriter();
+        this.expressionVisitor = expressionVisitor;
+    }
+
     @Override
     public Boolean visitBlock(BlockStatement statement) {
         Boolean returns = false;
 
         javaWriter.label(start);
         statement.value.accept(expressionVisitor);
-        if(statement.value.type == BasicTypeID.STRING)
+        if (statement.value.type == BasicTypeID.STRING)
             javaWriter.invokeVirtual(new JavaMethodInfo(new JavaClassInfo("java/lang/Object"), "hashCode", "()I", 0));
         boolean out = false;
 
         final boolean hasNoDefault = hasNoDefault(statement);
 
         final List<SwitchCase> cases = statement.cases;
-		final JavaSwitchLabel[] switchLabels = new JavaSwitchLabel[hasNoDefault ? cases.size() : cases.size() - 1];
+        final 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);
+                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);
 
             }
         }
 
-        if(hasNoDefault)
+        if (hasNoDefault)
             javaWriter.label(defaultLabel);
 
         javaWriter.label(end);
         for (SwitchCase switchCase : switchStatement.cases)
             if (switchCase.value == null) return false;
         return true;
-	}
+    }
 
     @Override
     public Boolean visitThrow(ThrowStatement statement) {

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.zenscript.javabytecode.JavaLocalVariableInfo;
-
 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-
+import org.objectweb.asm.*;
 import static org.objectweb.asm.Opcodes.*;
+import org.objectweb.asm.commons.LocalVariablesSorter;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaFieldInfo;
+import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 import org.openzen.zenscript.javabytecode.JavaParameterInfo;
 
 public class JavaWriter {
-	private static final JavaClassInfo T_STRING = new JavaClassInfo("java/lang/String");
-	private static final JavaMethodInfo STRING_CONCAT = new JavaMethodInfo(
-			T_STRING,
-			"concat",
-			"(Ljava/lang/String;)Ljava/lang/String;",
-			Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
-	
-	public final JavaMethodInfo method;
-	public final HighLevelDefinition forDefinition;
-	
+    private static final JavaClassInfo T_STRING = new JavaClassInfo("java/lang/String");
+    private static final JavaMethodInfo STRING_CONCAT = new JavaMethodInfo(
+            T_STRING,
+            "concat",
+            "(Ljava/lang/String;)Ljava/lang/String;",
+            Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+
+    public final JavaMethodInfo method;
+    public final HighLevelDefinition forDefinition;
+
     private final LocalVariablesSorter visitor;
     private final List<JavaLocalVariableInfo> localVariableInfos = new ArrayList<>();
+    public final ClassVisitor clazzVisitor;
     private boolean debug = true;
     private boolean nameVariables = true;
     private int labelIndex = 1;
     private Map<Label, String> labelNames = new HashMap<>();
 
     public JavaWriter(
-			ClassVisitor visitor,
-			boolean nameVariables,
-			JavaMethodInfo method,
-			HighLevelDefinition forDefinition,
-			String signature,
-			String[] exceptions,
-			String... annotations)
-	{
-		this.method = method;
-		this.forDefinition = forDefinition;
-		
+            ClassVisitor visitor,
+            boolean nameVariables,
+            JavaMethodInfo method,
+            HighLevelDefinition forDefinition,
+            String signature,
+            String[] exceptions,
+            String... annotations) {
+        this.clazzVisitor = visitor;
+        this.method = method;
+        this.forDefinition = forDefinition;
+
         final MethodVisitor methodVisitor = visitor.visitMethod(method.modifiers, method.name, method.descriptor, signature, exceptions);
 
         for (String annotation : annotations) {
 
         visitor.visitInsn(DUP);
     }
-	
-	public void dup(Type type) {
+
+    public void dup(Type type) {
         if (debug)
             System.out.println("dup");
-		
-		visitor.visitInsn(type.getSize() == 2 ? DUP2 : DUP);
-	}
+
+        visitor.visitInsn(type.getSize() == 2 ? DUP2 : DUP);
+    }
 
     public void dup(boolean large) {
         if (debug)
 
         visitor.visitVarInsn(type.getOpcode(ILOAD), local);
     }
-	
-	public void load(JavaParameterInfo parameter) {
+
+    public void load(JavaParameterInfo parameter) {
         if (debug)
             System.out.println("load " + parameter.index);
 
         visitor.visitVarInsn(parameter.type.getOpcode(ILOAD), parameter.index);
-	}
-	
-	public void load(JavaLocalVariableInfo localVariable) {
+    }
+
+    public void load(JavaLocalVariableInfo localVariable) {
         if (debug)
             System.out.println("load " + localVariable.local);
 
         visitor.visitVarInsn(localVariable.type.getOpcode(ILOAD), localVariable.local);
-	}
-	
-	public void store(JavaParameterInfo parameter) {
+    }
+
+    public void store(JavaParameterInfo parameter) {
         if (debug)
             System.out.println("store " + parameter.index);
 
         visitor.visitVarInsn(parameter.type.getOpcode(ISTORE), parameter.index);
-	}
-	
-	public void store(JavaLocalVariableInfo localVariable) {
+    }
+
+    public void store(JavaLocalVariableInfo localVariable) {
         if (debug)
             System.out.println("store " + localVariable.local);
 
         visitor.visitVarInsn(localVariable.type.getOpcode(ISTORE), localVariable.local);
-	}
+    }
 
     public void storeInt(int local) {
         if (debug)
     public void iinc(int local) {
         iinc(local, 1);
     }
-	
-	public void idec(int local) {
-		iinc(local, -1);
-	}
+
+    public void idec(int local) {
+        iinc(local, -1);
+    }
 
     public void iinc(int local, int increment) {
         if (debug)
     public void invokeSpecial(Class owner, String name, String descriptor) {
         invokeSpecial(Type.getInternalName(owner), name, descriptor);
     }
-	
-	public void invokeVirtual(JavaMethodInfo method) {
+
+    public void invokeVirtual(JavaMethodInfo method) {
         if (debug)
             System.out.println("invokeVirtual " + method.javaClass.internalClassName + '.' + method.name + method.descriptor);
 
         visitor.visitMethodInsn(INVOKEVIRTUAL, method.javaClass.internalClassName, method.name, method.descriptor, false);
-	}
+    }
 
     public void invokeInterface(JavaMethodInfo method) {
         if (debug)
     }
 
     public void lookupSwitch(Label defaultLabel, JavaSwitchLabel[] switchLabels) {
-		int[] keys = new int[switchLabels.length];
-		Label[] labels = new Label[switchLabels.length];
-		for (int i = 0; i < switchLabels.length; i++) {
-			keys[i] = switchLabels[i].key;
-			labels[i] = switchLabels[i].label;
-		}
-		
+        int[] keys = new int[switchLabels.length];
+        Label[] labels = new Label[switchLabels.length];
+        for (int i = 0; i < switchLabels.length; i++) {
+            keys[i] = switchLabels[i].key;
+            labels[i] = switchLabels[i].label;
+        }
+
         visitor.visitLookupSwitchInsn(defaultLabel, keys, labels);
     }
 

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
+import org.openzen.zenscript.javabytecode.JavaModule;
 import org.openzen.zenscript.javabytecode.compiler.*;
 
 
 
     @Override
     public byte[] visitAlias(AliasDefinition definition) {
-        return null;
+        //TODO would that work?
+        return JavaModule.classes.get(definition.name);
     }
 
 	@Override

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedFunction.java

 package org.openzen.zenscript.parser.definitions;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
 import static org.openzen.zenscript.lexer.ZSTokenType.*;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.scope.FunctionScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.ParsedDefinition;
 import org.openzen.zenscript.parser.PrecompilationState;
 		FunctionScope innerScope = new FunctionScope(scope, compiled.header);
 		compiled.setCode(body.compile(innerScope, compiled.header));
 		
-		if (compiled.header.returnType == BasicTypeID.UNDETERMINED)
-			compiled.header = compiled.header.withReturnType(body.precompileForResultType(new FunctionScope(scope, compiled.header), state));
+		if (compiled.header.returnType == BasicTypeID.UNDETERMINED) {
+			ITypeID result = body.precompileForResultType(new FunctionScope(scope, compiled.header), state);
+			if (result == null)
+				throw new CompileException(position, CompileExceptionCode.PRECOMPILE_FAILED, "Could not determine return type for method " + compiled.name);
+			compiled.header = compiled.header.withReturnType(result);
+		}
 	}
 }

ScriptingExample/scripts/functions.zs

-function test() {
+function test() as void {
 	println("functions.zs; test1");
 }
 

ScriptingExample/scripts/match.zs

+val test as int = 10;
+val tt1 = "tt";
+val tt2 = "tt3";
+val tt4 = "tt5";
+
+
+println(match 10 {
+	1 => "one",
+	10 => "yo",
+	//tt1 === "tt1" for some compiler issue it takes the variable as string input?
+	100 => match tt1 {
+		"10" => "t",
+		"tt1" => tt1,
+		"tt2" => tt1 + tt4,
+		default => tt4
+	},
+	default => tt2
+});
+
+
+println(tt1);
+
+//println(match test {
+//	case 1 : "tt",
+//	default : "kk"
+//});