Function stuff, probably

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

@@ -0,0 +1,40 @@
+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 null;
+    }
+
+    @Override
+    public Void visitRecaptured(CapturedClosureExpression expression) {
+        expression.value.accept(this);
+        return null;
+    }
+}

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

@@ -1,10 +1,13 @@
 package org.openzen.zenscript.javabytecode.compiler;
 
 import org.objectweb.asm.Label;
+import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.member.DefinitionMember;
+import org.openzen.zenscript.codemodel.statement.ReturnStatement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.implementations.IntRange;
@@ -12,14 +15,15 @@ import org.openzen.zenscript.javabytecode.*;
 import org.openzen.zenscript.shared.CompileException;
 import org.openzen.zenscript.shared.CompileExceptionCode;
 
+import java.util.Arrays;
 import java.util.Map;
-import org.objectweb.asm.Opcodes;
+import java.util.StringJoiner;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
-	private static final JavaMethodInfo MAP_PUT = JavaMethodInfo.get(Opcodes.ACC_PUBLIC, Map.class, "put", Object.class, Object.class, Object.class);
-	
+    private static final JavaMethodInfo MAP_PUT = JavaMethodInfo.get(Opcodes.ACC_PUBLIC, Map.class, "put", Object.class, Object.class, Object.class);
+
     private final JavaWriter javaWriter;
-	
+
     public JavaExpressionVisitor(JavaWriter javaWriter) {
         this.javaWriter = javaWriter;
     }
@@ -76,15 +80,15 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
         final Type operatorType = Type.getType(CompareType.class);
         javaWriter.getStaticField(operatorType.getInternalName(), expression.operator.name(), operatorType.getDescriptor());
 
-		// TODO: should be implemented properly
-		JavaMethodInfo compareMethod = JavaMethodInfo.get(
-				0,
-				ZenUtils.class,
-				"compare",
-				boolean.class,
-				getForEquals(expression.left.type),
-				getForEquals(expression.right.type),
-				CompareType.class);
+        // TODO: should be implemented properly
+        JavaMethodInfo compareMethod = JavaMethodInfo.get(
+                0,
+                ZenUtils.class,
+                "compare",
+                boolean.class,
+                getForEquals(expression.left.type),
+                getForEquals(expression.right.type),
+                CompareType.class);
         javaWriter.invokeStatic(compareMethod);
 
         return null;
@@ -115,6 +119,7 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 
     @Override
     public Void visitCapturedClosure(CapturedClosureExpression expression) {
+        expression.value.accept(this);
         return null;
     }
 
@@ -125,6 +130,7 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 
     @Override
     public Void visitCapturedLocalVariable(CapturedLocalVariableExpression expression) {
+        new GetLocalVariableExpression(expression.position, expression.variable).accept(this);
         return null;
     }
 
@@ -275,15 +281,15 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
     @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);
-		}
-		
+
+        if (javaWriter.method.javaClass.isEnum) {
+            javaWriter.loadObject(0);
+            javaWriter.loadObject(1);
+            javaWriter.loadInt(2);
+        } else {
+            javaWriter.loadObject(0);
+        }
+
         for (Expression argument : expression.arguments.arguments) {
             argument.accept(this);
         }
@@ -299,8 +305,8 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
         }
         //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;
     }
 
@@ -313,9 +319,64 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 
     @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 visitGenericCompare(GenericCompareExpression expression) {
         //TODO: What am I supposed to do here?
@@ -324,7 +385,7 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 
     @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;
@@ -332,7 +393,7 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 
     @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;
     }
@@ -403,11 +464,65 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
         }
         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, (a, b) -> a.key - b.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 boolean hasNoDefault(MatchExpression switchStatement) {
+        for (MatchExpression.Case switchCase : switchStatement.cases)
+            if (switchCase.key == null) return false;
+        return true;
+    }
 
     @Override
     public Void visitNew(NewExpression expression) {
@@ -460,23 +575,23 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 
         return null;
     }
-	
-	@Override
-	public Void visitPostCall(PostCallExpression expression) {
-		expression.target.accept(this);
-		javaWriter.dup(expression.type.accept(new JavaTypeVisitor()));
+
+    @Override
+    public Void visitPostCall(PostCallExpression expression) {
+        expression.target.accept(this);
+        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);
@@ -486,26 +601,26 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 
         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);
-		javaWriter.iConst1();
-		javaWriter.label(end);
-		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);
+        javaWriter.iConst1();
+        javaWriter.label(end);
+        return null;
+    }
 
     @Override
     public Void visitSetField(SetFieldExpression expression) {
@@ -519,7 +634,7 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
     @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;
     }
@@ -561,11 +676,11 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
     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) {
@@ -573,30 +688,30 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
         return null;
     }
 
-	@Override
-	public Void visitTryConvert(TryConvertExpression expression) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-	}
+    @Override
+    public Void visitTryConvert(TryConvertExpression 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 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 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

@@ -13,7 +13,7 @@ import java.util.List;
 
 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
@@ -23,6 +23,11 @@ public class JavaStatementVisitor implements StatementVisitor<Boolean> {
         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;
@@ -156,25 +161,25 @@ public class JavaStatementVisitor implements StatementVisitor<Boolean> {
 
         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);
 
@@ -190,7 +195,7 @@ public class JavaStatementVisitor implements StatementVisitor<Boolean> {
             }
         }
 
-        if(hasNoDefault)
+        if (hasNoDefault)
             javaWriter.label(defaultLabel);
 
         javaWriter.label(end);
@@ -204,7 +209,7 @@ public class JavaStatementVisitor implements StatementVisitor<Boolean> {
         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

@@ -2,7 +2,11 @@ package org.openzen.zenscript.javabytecode.compiler;
 
 import org.objectweb.asm.*;
 import org.objectweb.asm.commons.LocalVariablesSorter;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
+import org.openzen.zenscript.javabytecode.JavaMethodInfo;
+import org.openzen.zenscript.javabytecode.JavaParameterInfo;
 import org.openzen.zenscript.shared.CodePosition;
 
 import java.lang.reflect.Field;
@@ -12,41 +16,38 @@ import java.util.List;
 import java.util.Map;
 
 import static org.objectweb.asm.Opcodes.*;
-import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.javabytecode.JavaClassInfo;
-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 = false;
     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) {
@@ -174,13 +175,13 @@ public class JavaWriter {
 
         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)
@@ -237,34 +238,34 @@ public class JavaWriter {
 
         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)
@@ -641,10 +642,10 @@ public class JavaWriter {
     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)
@@ -778,15 +779,15 @@ public class JavaWriter {
 
         visitor.visitTypeInsn(INSTANCEOF, clsName);
     }
-	
-	public void invokeStatic(JavaMethodInfo method) {
-		visitor.visitMethodInsn(
-				INVOKESTATIC,
-				method.javaClass.internalClassName,
-				method.name,
-				method.descriptor,
-				false);
-	}
+
+    public void invokeStatic(JavaMethodInfo method) {
+        visitor.visitMethodInsn(
+                INVOKESTATIC,
+                method.javaClass.internalClassName,
+                method.name,
+                method.descriptor,
+                false);
+    }
 
     public void invokeSpecial(String owner, String name, String descriptor) {
         if (debug)
@@ -798,13 +799,13 @@ public class JavaWriter {
     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)
@@ -1129,13 +1130,13 @@ public class JavaWriter {
     }
 
     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);
     }
 

ScriptingExample/scripts/match.zs

@@ -0,0 +1,26 @@
+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"
+//});