Properly implement expressions without return value. Also fixed some bugs in expressions that do return a values. Also added a position to the JavaWriter for easier debugging.

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

@@ -8,6 +8,7 @@ package org.openzen.zenscript.javabytecode;
 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.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
@@ -101,7 +102,7 @@ public class JavaBytecodeContext extends JavaContext {
 		rangeWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "to", getDescriptor(range.baseType), null, null).visitEnd();
 		
 		JavaMethod method = JavaMethod.getConstructor(range.cls, "(" + getDescriptor(range.baseType) + getDescriptor(range.baseType) + ")V", Opcodes.ACC_PUBLIC);
-		JavaWriter constructorWriter = new JavaWriter(rangeWriter, method, null, method.descriptor, null);
+		JavaWriter constructorWriter = new JavaWriter(CodePosition.GENERATED, rangeWriter, method, null, method.descriptor, null);
 		constructorWriter.loadObject(0);
 		constructorWriter.invokeSpecial("java/lang/Object", "<init>", "()V");
 		constructorWriter.loadObject(0);

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

@@ -17,6 +17,7 @@ import java.util.logging.Level;
 import java.util.logging.Logger;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.javabytecode.compiler.JavaClassWriter;
 import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
 import org.openzen.zenscript.javashared.JavaClass;
@@ -77,7 +78,7 @@ public class JavaBytecodeRunUnit {
 		scriptsClassWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Scripts", null, "java/lang/Object", null);
 		
 		JavaMethod runMethod = JavaMethod.getStatic(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);
+		final JavaWriter runWriter = new JavaWriter(CodePosition.GENERATED, scriptsClassWriter, runMethod, null, null, null);
 		runWriter.start();
 		for (JavaMethod method : scripts)
 			runWriter.invokeStatic(method);

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

@@ -9,6 +9,7 @@ import java.util.HashMap;
 import java.util.Map;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.ScriptBlock;
@@ -73,7 +74,7 @@ public class JavaCompiler {
 			JavaMethod method = JavaMethod.getStatic(new JavaClass(context.getPackageName(script.pkg), className, JavaClass.Kind.CLASS), methodName, "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 			scriptFile.scriptMethods.add(method);
 
-			final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, context.getJavaModule(script.module), new JavaWriter(visitor, method, null, null, null));
+			final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, context.getJavaModule(script.module), new JavaWriter(CodePosition.UNKNOWN, visitor, method, null, null, null));
 			statementVisitor.start();
 			for (Statement statement : script.statements) {
 				statement.accept(statementVisitor);

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

@@ -1746,36 +1746,12 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void>, JavaNativ
 
 	@Override
 	public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
-		javaWriter.loadObject(0);
-		if (javaWriter.method.cls.isEnum()) {
-			javaWriter.loadObject(1);
-			javaWriter.loadInt(2);
-		}
-
-		for (Expression argument : expression.arguments.arguments) {
-			argument.accept(this);
-		}
-		String internalName = context.getInternalName(expression.objectType);
-		javaWriter.invokeSpecial(internalName, "<init>", javaWriter.method.cls.isEnum()
-				? context.getEnumConstructorDescriptor(expression.constructor.getHeader())
-				: context.getMethodDescriptor(expression.constructor.getHeader()));
-		return null;
+		throw new UnsupportedOperationException("Invalid usage");
 	}
 
 	@Override
 	public Void visitConstructorSuperCall(ConstructorSuperCallExpression expression) {
-		javaWriter.loadObject(0);
-		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(
-				context.getInternalName(expression.objectType),
-				"<init>",
-				context.getMethodDescriptor(expression.constructor.getHeader()));
-
-		CompilerUtils.writeDefaultFieldInitializers(context, javaWriter, javaWriter.forDefinition, false);
-		return null;
+		throw new UnsupportedOperationException("Invalid usage");
 	}
 
 	@Override
@@ -1801,7 +1777,7 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void>, JavaNativ
 		final JavaMethod methodInfo = JavaMethod.getNativeVirtual(javaWriter.method.cls, "accept", descriptor);
 		final ClassWriter lambdaCW = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 		lambdaCW.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, name, null, "java/lang/Object", new String[]{context.getInternalName(new FunctionTypeID(null, expression.header).stored(UniqueStorageTag.INSTANCE))});
-		final JavaWriter functionWriter = new JavaWriter(lambdaCW, methodInfo, null, signature, null, "java/lang/Override");
+		final JavaWriter functionWriter = new JavaWriter(expression.position, lambdaCW, methodInfo, null, signature, null, "java/lang/Override");
 
 		javaWriter.newObject(name);
 		javaWriter.dup();
@@ -1809,7 +1785,7 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void>, JavaNativ
 		final String constructorDesc = calcFunctionSignature(expression.closure);
 
 
-		final JavaWriter constructorWriter = new JavaWriter(lambdaCW, JavaMethod.getConstructor(javaWriter.method.cls, constructorDesc, Opcodes.ACC_PUBLIC), null, null, null);
+		final JavaWriter constructorWriter = new JavaWriter(expression.position, lambdaCW, JavaMethod.getConstructor(javaWriter.method.cls, constructorDesc, Opcodes.ACC_PUBLIC), null, null, null);
 		constructorWriter.start();
 		constructorWriter.loadObject(0);
 		constructorWriter.dup();
@@ -3488,6 +3464,7 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void>, JavaNativ
 						javaWriter.constant(255);
 						javaWriter.iAnd();
 					}, PushOption.BEFORE);
+					return null;
 				case SBYTE_INC:
 					modify(expression.target, () -> {
 						javaWriter.iConst1();
@@ -3648,8 +3625,9 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void>, JavaNativ
 
 	@Override
 	public Void visitSetField(SetFieldExpression expression) {
-		expression.target.accept(this);
 		expression.value.accept(this);
+		expression.target.accept(this);
+		javaWriter.dupX1(false, CompilerUtils.isLarge(expression.type));
 		putField(expression.field);
 		return null;
 	}
@@ -3657,6 +3635,7 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void>, JavaNativ
 	@Override
 	public Void visitSetFunctionParameter(SetFunctionParameterExpression expression) {
 		expression.value.accept(this);
+		javaWriter.dup(CompilerUtils.isLarge(expression.value.type));
 		JavaParameterInfo parameter = module.getParameterInfo(expression.parameter);
 		javaWriter.store(context.getType(expression.type), parameter.index);
 		return null;
@@ -3670,14 +3649,15 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void>, JavaNativ
 		final JavaLocalVariableInfo tag = javaWriter.getLocalVariable(expression.variable.variable);
 		tag.end = label;
 
+		javaWriter.dup(CompilerUtils.isLarge(expression.value.type));
 		javaWriter.store(tag.type, tag.local);
-
 		return null;
 	}
 
 	@Override
 	public Void visitSetStaticField(SetStaticFieldExpression expression) {
 		expression.value.accept(this);
+		javaWriter.dup(CompilerUtils.isLarge(expression.value.type));
 		javaWriter.putStaticField(context.getJavaField(expression.field));
 		return null;
 	}

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

@@ -0,0 +1,686 @@
+/*
+ * 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.javabytecode.compiler;
+
+import org.objectweb.asm.Label;
+import org.openzen.zenscript.codemodel.expression.AndAndExpression;
+import org.openzen.zenscript.codemodel.expression.ArrayExpression;
+import org.openzen.zenscript.codemodel.expression.CallExpression;
+import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedClosureExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedDirectExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedParameterExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedThisExpression;
+import org.openzen.zenscript.codemodel.expression.CastExpression;
+import org.openzen.zenscript.codemodel.expression.CheckNullExpression;
+import org.openzen.zenscript.codemodel.expression.CoalesceExpression;
+import org.openzen.zenscript.codemodel.expression.CompareExpression;
+import org.openzen.zenscript.codemodel.expression.ConditionalExpression;
+import org.openzen.zenscript.codemodel.expression.ConstExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantBoolExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantDoubleExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantFloatExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantLongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantSByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUSizeExpression;
+import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
+import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
+import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.ExpressionVisitor;
+import org.openzen.zenscript.codemodel.expression.FunctionExpression;
+import org.openzen.zenscript.codemodel.expression.GetFieldExpression;
+import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
+import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.GetMatchingVariantField;
+import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
+import org.openzen.zenscript.codemodel.expression.GetterExpression;
+import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
+import org.openzen.zenscript.codemodel.expression.GlobalExpression;
+import org.openzen.zenscript.codemodel.expression.InterfaceCastExpression;
+import org.openzen.zenscript.codemodel.expression.IsExpression;
+import org.openzen.zenscript.codemodel.expression.MakeConstExpression;
+import org.openzen.zenscript.codemodel.expression.MapExpression;
+import org.openzen.zenscript.codemodel.expression.MatchExpression;
+import org.openzen.zenscript.codemodel.expression.NewExpression;
+import org.openzen.zenscript.codemodel.expression.NullExpression;
+import org.openzen.zenscript.codemodel.expression.OrOrExpression;
+import org.openzen.zenscript.codemodel.expression.PanicExpression;
+import org.openzen.zenscript.codemodel.expression.PostCallExpression;
+import org.openzen.zenscript.codemodel.expression.RangeExpression;
+import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
+import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
+import org.openzen.zenscript.codemodel.expression.SetFunctionParameterExpression;
+import org.openzen.zenscript.codemodel.expression.SetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.SetStaticFieldExpression;
+import org.openzen.zenscript.codemodel.expression.SetterExpression;
+import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
+import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
+import org.openzen.zenscript.codemodel.expression.StorageCastExpression;
+import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
+import org.openzen.zenscript.codemodel.expression.ThisExpression;
+import org.openzen.zenscript.codemodel.expression.ThrowExpression;
+import org.openzen.zenscript.codemodel.expression.TryConvertExpression;
+import org.openzen.zenscript.codemodel.expression.TryRethrowAsExceptionExpression;
+import org.openzen.zenscript.codemodel.expression.TryRethrowAsResultExpression;
+import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
+import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.member.BuiltinID;
+import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
+import org.openzen.zenscript.javabytecode.JavaBytecodeModule;
+import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
+import org.openzen.zenscript.javabytecode.compiler.JavaModificationExpressionVisitor.PushOption;
+import org.openzen.zenscript.javashared.JavaCompiledModule;
+import org.openzen.zenscript.javashared.JavaParameterInfo;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaNonPushingExpressionVisitor implements ExpressionVisitor<Void> {
+	private final JavaBytecodeContext context;
+	private final JavaCompiledModule module;
+	private final JavaWriter javaWriter;
+	private final JavaExpressionVisitor original;
+	
+	public JavaNonPushingExpressionVisitor(JavaBytecodeContext context, JavaCompiledModule module, JavaWriter javaWriter, JavaExpressionVisitor original) {
+		this.context = context;
+		this.module = module;
+		this.javaWriter = javaWriter;
+		this.original = original;
+	}
+
+	@Override
+	public Void visitAndAnd(AndAndExpression expression) {
+		Label end = new Label();
+		expression.left.accept(original);
+		javaWriter.ifEQ(end);
+		expression.right.accept(this);
+		javaWriter.label(end);
+		return null;
+	}
+	
+	private void fallback(Expression expression) {
+		expression.accept(original);
+		if (expression.type.type != BasicTypeID.VOID)
+			javaWriter.pop(CompilerUtils.isLarge(expression.type));
+	}
+	
+	private void modify(Expression source, Runnable modification) {
+		source.accept(new JavaModificationExpressionVisitor(context, module, javaWriter, original, modification, PushOption.NONE));
+	}
+	
+	private boolean compileIncrementOrDecrement(Expression target, BuiltinID builtin) {
+		if (builtin == null)
+			return false;
+		
+		switch (builtin) {
+			case BYTE_INC:
+				modify(target, () -> {
+					javaWriter.iConst1();
+					javaWriter.iAdd();
+					javaWriter.constant(255);
+					javaWriter.iAnd();
+				});
+				return true;
+			case BYTE_DEC:
+				modify(target, () -> {
+					javaWriter.iConst1();
+					javaWriter.iSub();
+					javaWriter.constant(255);
+					javaWriter.iAnd();
+				});
+				return true;
+			case SBYTE_INC:
+				modify(target, () -> {
+					javaWriter.iConst1();
+					javaWriter.iAdd();
+					javaWriter.i2b();
+				});
+				return true;
+			case SBYTE_DEC:
+				modify(target, () -> {
+					javaWriter.iConst1();
+					javaWriter.iSub();
+					javaWriter.i2b();
+				});
+				return true;
+			case SHORT_INC:
+				modify(target, () -> {
+					javaWriter.iConst1();
+					javaWriter.iAdd();
+					javaWriter.i2s();
+				});
+				return true;
+			case SHORT_DEC:
+				modify(target, () -> {
+					javaWriter.iConst1();
+					javaWriter.iSub();
+					javaWriter.i2s();
+				});
+				return true;
+			case USHORT_INC:
+				modify(target, () -> {
+					javaWriter.iConst1();
+					javaWriter.iAdd();
+					javaWriter.constant(0xFFFF);
+					javaWriter.iAnd();
+				});
+				return true;
+			case USHORT_DEC:
+				modify(target, () -> {
+					javaWriter.iConst1();
+					javaWriter.iSub();
+					javaWriter.constant(0xFFFF);
+					javaWriter.iAnd();
+				});
+				return true;
+			case INT_INC:
+			case UINT_INC:
+			case USIZE_INC:
+				if (target instanceof GetLocalVariableExpression) {
+					JavaLocalVariableInfo local = javaWriter.getLocalVariable(((GetLocalVariableExpression)target).variable.variable);
+					javaWriter.iinc(local.local);
+				} else {
+					modify(target, () -> {
+						javaWriter.iConst1();
+						javaWriter.iAdd();
+					});
+				}
+				return true;
+			case INT_DEC:
+			case UINT_DEC:
+			case USIZE_DEC:
+				if (target instanceof GetLocalVariableExpression) {
+					JavaLocalVariableInfo local = javaWriter.getLocalVariable(((GetLocalVariableExpression)target).variable.variable);
+					javaWriter.iinc(local.local, -1);
+				} else {
+					modify(target, () -> {
+						javaWriter.iConst1();
+						javaWriter.iSub();
+					});
+				}
+				return true;
+			case LONG_INC:
+			case ULONG_INC:
+				modify(target, () -> {
+					javaWriter.constant(1l);
+					javaWriter.lAdd();
+				});
+				return true;
+			case LONG_DEC:
+			case ULONG_DEC:
+				modify(target, () -> {
+					javaWriter.constant(1l);
+					javaWriter.lSub();
+				});
+				return true;
+			case FLOAT_INC:
+				modify(target, () -> {
+					javaWriter.constant(1f);
+					javaWriter.fAdd();
+				});
+				return true;
+			case FLOAT_DEC:
+				modify(target, () -> {
+					javaWriter.constant(1f);
+					javaWriter.fSub();
+				});
+				return true;
+			case DOUBLE_INC:
+				modify(target, () -> {
+					javaWriter.constant(1d);
+					javaWriter.dAdd();
+				});
+				return true;
+			case DOUBLE_DEC:
+				modify(target, () -> {
+					javaWriter.constant(1d);
+					javaWriter.dSub();
+				});
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	@Override
+	public Void visitArray(ArrayExpression expression) {
+		for (Expression value : expression.expressions)
+			value.accept(this);
+		
+		return null;
+	}
+
+	@Override
+	public Void visitCompare(CompareExpression expression) {
+		expression.left.accept(this);
+		expression.right.accept(this);
+		return null;
+	}
+
+	@Override
+	public Void visitCall(CallExpression expression) {
+		if (!compileIncrementOrDecrement(expression.target, expression.member.getBuiltin()))
+			fallback(expression);
+		
+		return null;
+	}
+
+	@Override
+	public Void visitCallStatic(CallStaticExpression expression) {
+		fallback(expression);
+		return null;
+	}
+
+	@Override
+	public Void visitCapturedClosure(CapturedClosureExpression expression) {
+		return expression.value.accept(this);
+	}
+
+	@Override
+	public Void visitCapturedDirect(CapturedDirectExpression expression) {
+		return expression.value.accept(this);
+	}
+
+	@Override
+	public Void visitCapturedLocalVariable(CapturedLocalVariableExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitCapturedParameter(CapturedParameterExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitCapturedThis(CapturedThisExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitCast(CastExpression expression) {
+		return expression.target.accept(this);
+	}
+
+	@Override
+	public Void visitCheckNull(CheckNullExpression expression) {
+		return expression.value.accept(this);
+	}
+
+	@Override
+	public Void visitCoalesce(CoalesceExpression expression) {
+		final Label end = new Label();
+		expression.left.accept(original);
+		javaWriter.ifNonNull(end);
+		expression.right.accept(this);
+		javaWriter.label(end);
+		return null;
+	}
+
+	@Override
+	public Void visitConditional(ConditionalExpression expression) {
+		final Label end = new Label();
+		final Label onElse = new Label();
+		expression.condition.accept(original);
+		javaWriter.ifEQ(onElse);
+		expression.ifThen.accept(this);
+		javaWriter.goTo(end);
+		javaWriter.label(onElse);
+		expression.ifElse.accept(this);
+		javaWriter.label(end);
+		return null;
+	}
+
+	@Override
+	public Void visitConst(ConstExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitConstantBool(ConstantBoolExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitConstantByte(ConstantByteExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitConstantChar(ConstantCharExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitConstantDouble(ConstantDoubleExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitConstantFloat(ConstantFloatExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitConstantInt(ConstantIntExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitConstantLong(ConstantLongExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitConstantSByte(ConstantSByteExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitConstantShort(ConstantShortExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitConstantString(ConstantStringExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitConstantUInt(ConstantUIntExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitConstantULong(ConstantULongExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitConstantUShort(ConstantUShortExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitConstantUSize(ConstantUSizeExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
+		javaWriter.loadObject(0);
+		if (javaWriter.method.cls.isEnum()) {
+			javaWriter.loadObject(1);
+			javaWriter.loadInt(2);
+		}
+
+		for (Expression argument : expression.arguments.arguments) {
+			argument.accept(this);
+		}
+		String internalName = context.getInternalName(expression.objectType);
+		javaWriter.invokeSpecial(internalName, "<init>", javaWriter.method.cls.isEnum()
+				? context.getEnumConstructorDescriptor(expression.constructor.getHeader())
+				: context.getMethodDescriptor(expression.constructor.getHeader()));
+		return null;
+	}
+
+	@Override
+	public Void visitConstructorSuperCall(ConstructorSuperCallExpression expression) {
+		javaWriter.loadObject(0);
+		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(
+				context.getInternalName(expression.objectType),
+				"<init>",
+				context.getMethodDescriptor(expression.constructor.getHeader()));
+
+		CompilerUtils.writeDefaultFieldInitializers(context, javaWriter, javaWriter.forDefinition, false);
+		return null;
+	}
+
+	@Override
+	public Void visitEnumConstant(EnumConstantExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitFunction(FunctionExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitGetField(GetFieldExpression expression) {
+		return expression.target.accept(this);
+	}
+
+	@Override
+	public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitGetMatchingVariantField(GetMatchingVariantField expression) {
+		fallback(expression);
+		return null;
+	}
+
+	@Override
+	public Void visitGetStaticField(GetStaticFieldExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitGetter(GetterExpression expression) {
+		return expression.target.accept(this);
+	}
+
+	@Override
+	public Void visitGlobal(GlobalExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitGlobalCall(GlobalCallExpression expression) {
+		fallback(expression);
+		return null;
+	}
+
+	@Override
+	public Void visitInterfaceCast(InterfaceCastExpression expression) {
+		return expression.value.accept(this);
+	}
+
+	@Override
+	public Void visitIs(IsExpression expression) {
+		return expression.value.accept(this);
+	}
+
+	@Override
+	public Void visitMakeConst(MakeConstExpression expression) {
+		return expression.value.accept(this);
+	}
+
+	@Override
+	public Void visitMap(MapExpression expression) {
+		fallback(expression);
+		return null;
+	}
+
+	@Override
+	public Void visitMatch(MatchExpression expression) {
+		fallback(expression);
+		return null;
+	}
+
+	@Override
+	public Void visitNew(NewExpression expression) {
+		fallback(expression);
+		return null;
+	}
+
+	@Override
+	public Void visitNull(NullExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitOrOr(OrOrExpression expression) {
+		Label end = new Label();
+		expression.left.accept(original);
+		javaWriter.ifNE(end);
+		expression.right.accept(this);
+		javaWriter.label(end);
+		return null;
+	}
+
+	@Override
+	public Void visitPanic(PanicExpression expression) {
+		javaWriter.newObject("java/lang/AssertionError");
+		javaWriter.dup();
+		expression.value.accept(this);
+		javaWriter.invokeSpecial(AssertionError.class, "<init>", "(Ljava/lang/String;)V");
+		javaWriter.aThrow();
+		return null;
+	}
+
+	@Override
+	public Void visitPostCall(PostCallExpression expression) {
+		if (!compileIncrementOrDecrement(expression.target, expression.member.getBuiltin()))
+			fallback(expression);
+		
+		return null;
+	}
+
+	@Override
+	public Void visitRange(RangeExpression expression) {
+		expression.from.accept(this);
+		expression.to.accept(this);
+		return null;
+	}
+
+	@Override
+	public Void visitSameObject(SameObjectExpression expression) {
+		expression.left.accept(this);
+		expression.right.accept(this);
+		return null;
+	}
+
+	@Override
+	public Void visitSetField(SetFieldExpression expression) {
+		expression.target.accept(original);
+		expression.value.accept(original);
+		original.putField(expression.field);
+		return null;
+	}
+
+	@Override
+	public Void visitSetFunctionParameter(SetFunctionParameterExpression expression) {
+		expression.value.accept(original);
+		JavaParameterInfo parameter = module.getParameterInfo(expression.parameter);
+		javaWriter.store(context.getType(expression.type), parameter.index);
+		return null;
+	}
+
+	@Override
+	public Void visitSetLocalVariable(SetLocalVariableExpression expression) {
+		expression.value.accept(original);
+		Label label = new Label();
+		javaWriter.label(label);
+		final JavaLocalVariableInfo tag = javaWriter.getLocalVariable(expression.variable.variable);
+		tag.end = label;
+
+		javaWriter.store(tag.type, tag.local);
+		return null;
+	}
+
+	@Override
+	public Void visitSetStaticField(SetStaticFieldExpression expression) {
+		expression.value.accept(original);
+		javaWriter.putStaticField(context.getJavaField(expression.field));
+		return null;
+	}
+
+	@Override
+	public Void visitSetter(SetterExpression expression) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Void visitStaticGetter(StaticGetterExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitStaticSetter(StaticSetterExpression expression) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Void visitStorageCast(StorageCastExpression expression) {
+		return expression.value.accept(this);
+	}
+
+	@Override
+	public Void visitSupertypeCast(SupertypeCastExpression expression) {
+		return expression.value.accept(this);
+	}
+
+	@Override
+	public Void visitThis(ThisExpression expression) {
+		return null;
+	}
+
+	@Override
+	public Void visitThrow(ThrowExpression expression) {
+		expression.value.accept(this);
+		javaWriter.aThrow();
+		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 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) {
+		fallback(expression);
+		return null;
+	}
+
+	@Override
+	public Void visitWrapOptional(WrapOptionalExpression expression) {
+		return expression.value.accept(this);
+	}
+}

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

@@ -16,6 +16,7 @@ public class JavaStatementVisitor implements StatementVisitor<Boolean> {
     private final JavaWriter javaWriter;
 	private final JavaBytecodeContext context;
     public JavaExpressionVisitor expressionVisitor;
+	public JavaNonPushingExpressionVisitor nonPushingExpressionVisitor;
 
     /**
      * @param javaWriter the method writer that compiles the statement
@@ -24,6 +25,7 @@ public class JavaStatementVisitor implements StatementVisitor<Boolean> {
         this.javaWriter = javaWriter;
 		this.context = context;
         this.expressionVisitor = new JavaExpressionVisitor(context, module, javaWriter);
+		nonPushingExpressionVisitor = new JavaNonPushingExpressionVisitor(context, module, javaWriter, expressionVisitor);
     }
 
     public JavaStatementVisitor(JavaBytecodeContext context, JavaExpressionVisitor expressionVisitor) {
@@ -80,12 +82,7 @@ public class JavaStatementVisitor implements StatementVisitor<Boolean> {
 
 	@Override
 	public Boolean visitExpression(ExpressionStatement statement) {
-		statement.expression.accept(expressionVisitor);
-		
-		// TODO: make the expression not push anything
-		if (statement.expression.type.type != BasicTypeID.VOID)
-			javaWriter.pop(CompilerUtils.isLarge(statement.expression.type));
-		
+		statement.expression.accept(nonPushingExpressionVisitor);
 		return false;
 	}
 

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

@@ -10,7 +10,6 @@ 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.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.statement.VariableID;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 import org.openzen.zenscript.javashared.JavaParameterInfo;
@@ -26,6 +25,7 @@ public class JavaWriter {
 
     public final JavaMethod method;
     public final HighLevelDefinition forDefinition;
+	private final CodePosition position;
 
     private final LocalVariablesSorter visitor;
     private final List<JavaLocalVariableInfo> localVariableInfos = new ArrayList<>();
@@ -37,6 +37,7 @@ public class JavaWriter {
 	private final Map<VariableID, JavaLocalVariableInfo> localVariables = new HashMap<>();
 	
     public JavaWriter(
+			CodePosition position,
             ClassVisitor visitor,
             boolean nameVariables,
             JavaMethod method,
@@ -44,11 +45,12 @@ public class JavaWriter {
             String signature,
             String[] exceptions,
             String... annotations) {
-        this(visitor, nameVariables, method, forDefinition, false, signature, method.descriptor, exceptions, annotations);
+        this(position, visitor, nameVariables, method, forDefinition, false, signature, method.descriptor, exceptions, annotations);
     }
 
 
     public JavaWriter(
+			CodePosition position,
             ClassVisitor visitor,
             boolean nameVariables,
             JavaMethod method,
@@ -61,6 +63,7 @@ public class JavaWriter {
         this.clazzVisitor = visitor;
         this.method = method;
         this.forDefinition = forDefinition;
+		this.position = position;
 
         final MethodVisitor methodVisitor = visitor.visitMethod(isExtension ? method.modifiers | Opcodes.ACC_STATIC : method.modifiers, method.name, descriptor, signature, exceptions);
 
@@ -75,8 +78,8 @@ public class JavaWriter {
 
 
 
-    public JavaWriter(ClassVisitor visitor, JavaMethod method, HighLevelDefinition forDefinition, String signature, String[] exceptions, String... annotations) {
-        this(visitor, true, method, forDefinition, signature, exceptions, annotations);
+    public JavaWriter(CodePosition position, ClassVisitor visitor, JavaMethod method, HighLevelDefinition forDefinition, String signature, String[] exceptions, String... annotations) {
+        this(position, visitor, true, method, forDefinition, signature, exceptions, annotations);
     }
 	
 	public void setLocalVariable(VariableID variable, JavaLocalVariableInfo info) {
@@ -233,6 +236,17 @@ public class JavaWriter {
 
         visitor.visitInsn(DUP_X1);
     }
+	
+	public void dupX1(boolean tosLarge, boolean large) {
+		if (debug)
+            System.out.println("dupx1");
+
+		if (tosLarge) {
+	        visitor.visitInsn(large ? DUP2_X2 : DUP_X2);
+		} else {
+	        visitor.visitInsn(large ? DUP2_X1 : DUP_X1);
+		}
+	}
 
     public void dupX2() {
         if (debug)

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

@@ -105,7 +105,7 @@ public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
         }
 
 		JavaMethod valuesMethod = JavaMethod.getStatic(toClass, "values", "()[L" + toClass.internalName + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-		JavaWriter valuesWriter = new JavaWriter(writer, true, valuesMethod, definition, null, null);
+		JavaWriter valuesWriter = new JavaWriter(definition.position, writer, true, valuesMethod, definition, null, null);
 		valuesWriter.start();
 		valuesWriter.getStaticField(toClass.internalName, "$VALUES", "[L" + toClass.internalName + ";");
 		valuesWriter.invokeVirtual(ARRAY_CLONE);
@@ -114,7 +114,7 @@ public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 		valuesWriter.end();
 
 		JavaMethod valueOfMethod = JavaMethod.getStatic(toClass, "valueOf", "(Ljava/lang/String;)L" + toClass.internalName + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-		JavaWriter valueOfWriter = new JavaWriter(writer, true, valueOfMethod, definition, null, null);
+		JavaWriter valueOfWriter = new JavaWriter(definition.position, writer, true, valueOfMethod, definition, null, null);
 		valueOfWriter.start();
 		valueOfWriter.invokeStatic(CLASS_FORNAME);
 		valueOfWriter.loadObject(0);
@@ -139,7 +139,7 @@ public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
         final String signature = context.getMethodSignature(definition.header);
 		final JavaMethod method = context.getJavaMethod(definition.caller);
 
-		final JavaWriter writer = new JavaWriter(outerWriter, true, method, definition, signature, null);
+		final JavaWriter writer = new JavaWriter(definition.position, outerWriter, true, method, definition, signature, null);
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, context.getJavaModule(definition.module), writer);
         statementVisitor.start();
 		boolean returns = definition.caller.body.accept(statementVisitor);
@@ -261,8 +261,8 @@ public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 			optionInitDescBuilder.append(")V");
 			optionInitSignatureBuilder.append(")V");
 
-JavaMethod constructorMethod = JavaMethod.getConstructor(optionTag.variantOptionClass, optionInitDescBuilder.toString(), JavaModifiers.PUBLIC);
-			final JavaWriter initWriter = new JavaWriter(optionWriter, constructorMethod, variant, optionInitSignatureBuilder.toString(), null);
+			JavaMethod constructorMethod = JavaMethod.getConstructor(optionTag.variantOptionClass, optionInitDescBuilder.toString(), JavaModifiers.PUBLIC);
+			final JavaWriter initWriter = new JavaWriter(option.position, optionWriter, constructorMethod, variant, optionInitSignatureBuilder.toString(), null);
 			initWriter.start();
 			initWriter.loadObject(0);
 			initWriter.dup();
@@ -280,7 +280,7 @@ JavaMethod constructorMethod = JavaMethod.getConstructor(optionTag.variantOption
 
 			//Denominator for switch-cases
 			JavaMethod denominator = JavaMethod.getVirtual(optionTag.variantOptionClass, "getDenominator", "()I", JavaModifiers.PUBLIC);
-			final JavaWriter getDenominator = new JavaWriter(optionWriter, denominator, null, null, null, "java/lang/Override");
+			final JavaWriter getDenominator = new JavaWriter(option.position, optionWriter, denominator, null, null, null, "java/lang/Override");
 			getDenominator.start();
 			getDenominator.constant(option.ordinal);
 			getDenominator.returnInt();
@@ -304,7 +304,7 @@ JavaMethod constructorMethod = JavaMethod.getConstructor(optionTag.variantOption
 			member.accept(visitor);
 		}
 
-		final JavaWriter superInitWriter = new JavaWriter(writer, JavaMethod.getConstructor(toClass, "()V", Opcodes.ACC_PUBLIC), variant, "()V", null);
+		final JavaWriter superInitWriter = new JavaWriter(variant.position, writer, JavaMethod.getConstructor(toClass, "()V", Opcodes.ACC_PUBLIC), variant, "()V", null);
 		superInitWriter.start();
 		superInitWriter.loadObject(0);
 		superInitWriter.invokeSpecial("java/lang/Object", "<init>", "()V");

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

@@ -78,7 +78,7 @@ public class JavaExpansionMemberVisitor implements MemberVisitor<Void> {
 		}
 
 
-		final JavaWriter methodWriter = new JavaWriter(writer, true, method, definition, true, methodSignature, methodSignature, null);
+		final JavaWriter methodWriter = new JavaWriter(member.position, writer, true, method, definition, true, methodSignature, methodSignature, null);
 		methodWriter.label(methodStart);
 
 		if (!isStatic) {

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

@@ -35,7 +35,7 @@ public class JavaMemberVisitor implements MemberVisitor<Void> {
 		this.context = context;
 		javaModule = context.getJavaModule(definition.module);
 
-        final JavaWriter javaWriter = new JavaWriter(writer, new JavaMethod(toClass, JavaMethod.Kind.STATICINIT, "<clinit>", true, "()V", 0, false), definition, null, null);
+        final JavaWriter javaWriter = new JavaWriter(definition.position, writer, new JavaMethod(toClass, JavaMethod.Kind.STATICINIT, "<clinit>", true, "()V", 0, false), definition, null, null);
         this.clinitStatementVisitor = new JavaStatementVisitor(context, javaModule, javaWriter);
         this.clinitStatementVisitor.start();
         CompilerUtils.writeDefaultFieldInitializers(context, javaWriter, definition, true);
@@ -62,7 +62,7 @@ public class JavaMemberVisitor implements MemberVisitor<Void> {
 
         final Label constructorStart = new Label();
         final Label constructorEnd = new Label();
-        final JavaWriter constructorWriter = new JavaWriter(writer, method, definition, context.getMethodSignature(member.header), null);
+        final JavaWriter constructorWriter = new JavaWriter(member.position, writer, method, definition, context.getMethodSignature(member.header), null);
         constructorWriter.label(constructorStart);
         CompilerUtils.tagConstructorParameters(context, javaModule, member.header, isEnum);
         for (FunctionParameter parameter : member.header.parameters) {
@@ -108,7 +108,7 @@ public class JavaMemberVisitor implements MemberVisitor<Void> {
 
 		final Label constructorStart = new Label();
 		final Label constructorEnd = new Label();
-		final JavaWriter destructorWriter = new JavaWriter(writer, method, definition, null, null);
+		final JavaWriter destructorWriter = new JavaWriter(member.position, writer, method, definition, null, null);
 		destructorWriter.label(constructorStart);
 
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, destructorWriter);
@@ -129,7 +129,7 @@ public class JavaMemberVisitor implements MemberVisitor<Void> {
 
 		final Label methodStart = new Label();
 		final Label methodEnd = new Label();
-	    final JavaWriter methodWriter = new JavaWriter(writer, method, definition, context.getMethodSignature(member.header), null);
+	    final JavaWriter methodWriter = new JavaWriter(member.position, writer, method, definition, context.getMethodSignature(member.header), null);
 
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);