Better be save than sorry and commit before something happens again...

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

 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 
 public class CompilerUtils {
     public static String calcDesc(FunctionHeader header, boolean isEnum) {
         signatureBuilder.append(")").append(header.returnType.accept(JavaTypeVisitor.INSTANCE).getDescriptor());
         return signatureBuilder.toString();
     }
+
+    public static boolean isPrimitive(ITypeID id) {
+        if(id instanceof BasicTypeID) {
+            switch ((BasicTypeID) id) {
+                case BOOL:
+                case BYTE:
+                case SBYTE:
+                case SHORT:
+                case USHORT:
+                case INT:
+                case UINT:
+                case LONG:
+                case ULONG:
+                case FLOAT:
+                case DOUBLE:
+                case CHAR:
+                    return true;
+            }
+        }
+        return false;
+    }
 }

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

 
 import org.objectweb.asm.Label;
 import org.objectweb.asm.Type;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
-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.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.implementations.IntRange;
 import org.openzen.zenscript.javabytecode.*;
 import org.openzen.zenscript.shared.CompileException;
 import org.openzen.zenscript.shared.CompileExceptionCode;
 
-
 import java.util.Map;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
         this.isInit = isInit;
     }
 
+    private static Class<?> getForEquals(ITypeID id) {
+        if (CompilerUtils.isPrimitive(id))
+            return id.accept(JavaTypeClassVisitor.INSTANCE);
+        return Object.class;
+    }
+
     @Override
     public Void visitAndAnd(AndAndExpression expression) {
+        Label end = new Label();
+        Label onFalse = new Label();
+
+        expression.left.accept(this);
+
+        javaWriter.ifEQ(onFalse);
+        expression.right.accept(this);
+
+        // //these two calls are redundant but make decompiled code look better. Keep?
+        // javaWriter.ifEQ(onFalse);
+        // javaWriter.iConst1();
+
+        javaWriter.goTo(end);
+
+        javaWriter.label(onFalse);
+        javaWriter.iConst0();
+
+
+        javaWriter.label(end);
+
         return null;
     }
 
 
     @Override
     public Void visitCompare(BasicCompareExpression expression) {
+        expression.left.accept(this);
+        expression.right.accept(this);
+        javaWriter.constant(expression.operator.name());
+
+        javaWriter.invokeStatic(ZenUtils.class, "compare", boolean.class, getForEquals(expression.left.type), getForEquals(expression.right.type), String.class);
+
         return null;
     }
 
 
     @Override
     public Void visitCallStatic(CallStaticExpression expression) {
+        for (Expression argument : expression.arguments.arguments) {
+            argument.accept(this);
+        }
+        //TODO: Test with actual static method
+        final JavaMethodInfo info = expression.member.getTag(JavaMethodInfo.class);
+        javaWriter.invokeStatic(info.javaClass.internalClassName, info.name, info.signature);
         return null;
     }
 
     public Void visitCapturedThis(CapturedThisExpression expression) {
         return null;
     }
-	
-	@Override
+
+    @Override
     public Void visitCast(CastExpression expression) {
-		expression.target.accept(this);
+        expression.target.accept(this);
         if (!checkAndExecuteByteCodeImplementation(expression.member) && !checkAndExecuteMethodInfo(expression.member))
             throw new IllegalStateException("Call target has no method info!");
-		
+
         return null;
-	}
+    }
 
     @Override
     public Void visitCheckNull(CheckNullExpression expression) {
+        final Label end = new Label();
+        expression.value.accept(this);
+        javaWriter.dup();
+        javaWriter.ifNonNull(end);
+        javaWriter.pop();
+        javaWriter.newObject(NullPointerException.class);
+        javaWriter.dup();
+        javaWriter.constant("Tried to convert a null value to nonnull type " + expression.type.accept(JavaTypeClassVisitor.INSTANCE).getSimpleName());
+        javaWriter.invokeSpecial(NullPointerException.class, "<init>", "(Ljava/lang/String;)V");
+        javaWriter.aThrow();
+        javaWriter.label(end);
+
         return null;
     }
 
     @Override
     public Void visitCoalesce(CoalesceExpression expression) {
+        final Label end = new Label();
+        expression.left.accept(this);
+        javaWriter.dup();
+        javaWriter.ifNonNull(end);
+        javaWriter.pop();
+        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(this);
+        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 visitConstantBool(ConstantBoolExpression expression) {
-        getJavaWriter().constant(expression.value);
+        if (expression.value)
+            javaWriter.iConst1();
+        else
+            javaWriter.iConst0();
         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(expression.objectType.accept(JavaTypeClassVisitor.INSTANCE), "<init>", CompilerUtils.calcDesc(expression.constructor.header, false));
         return null;
     }
 
     @Override
     public Void visitEnumConstant(EnumConstantExpression expression) {
+        final Type type = expression.type.accept(JavaTypeVisitor.INSTANCE);
+        javaWriter.getStaticField(type.getInternalName(), expression.value.name, type.getDescriptor());
         return null;
     }
 
     @Override
     public Void visitEquals(EqualsExpression expression) {
+        expression.left.accept(this);
+        expression.right.accept(this);
+        javaWriter.constant(CompareType.EQ.name());
+        javaWriter.invokeStatic(ZenUtils.class, "compare", boolean.class, getForEquals(expression.left.type), getForEquals(expression.right.type), String.class);
+
         return null;
     }
 
 
     @Override
     public Void visitGenericCompare(GenericCompareExpression expression) {
+        //TODO: What am I supposed to do here?
         return null;
     }
 
 
     @Override
     public Void visitMakeConst(MakeConstExpression expression) {
-
+        //TODO: What am I supposed to do here?
         return null;
     }
 
     @Override
     public Void visitNew(NewExpression expression) {
         final String type;
-        if(expression.type instanceof DefinitionTypeID)
+        if (expression.type instanceof DefinitionTypeID)
             type = ((DefinitionTypeID) expression.type).definition.name;
         else
             type = Type.getDescriptor(expression.type.accept(JavaTypeClassVisitor.INSTANCE));
 
     @Override
     public Void visitOrOr(OrOrExpression expression) {
+        Label end = new Label();
+        Label onTrue = new Label();
+
+        expression.left.accept(this);
+
+        javaWriter.ifNE(onTrue);
+        expression.right.accept(this);
+
+        // //these two calls are redundant but make decompiled code look better. Keep?
+        // javaWriter.ifNE(onTrue);
+        // javaWriter.iConst0();
+
+        javaWriter.goTo(end);
+
+        javaWriter.label(onTrue);
+        javaWriter.iConst1();
+
+
+        javaWriter.label(end);
+
         return null;
     }
 
 
     @Override
     public Void visitSetFunctionParameter(SetFunctionParameterExpression expression) {
+        //TODO is static?
+        final boolean isStatic = false;
+        expression.value.accept(this);
+        javaWriter.store(expression.type.accept(JavaTypeVisitor.INSTANCE), isStatic ? expression.parameter.index : expression.parameter.index + 1);
         return null;
     }
 
 
     @Override
     public Void visitWrapOptional(WrapOptionalExpression expression) {
+        //TODO What am I supposed to do here?
+        expression.value.accept(this);
         return null;
     }
 

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

 
     @Override
     public Class visitOptional(OptionalTypeID optional) {
-        return null;
+        return optional.baseType.accept(this);
     }
 }

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

         visitor.visitMethodInsn(INVOKESPECIAL, owner, name, descriptor, false);
     }
 
+    public void invokeSpecial(Class owner, String name, String descriptor) {
+        invokeSpecial(Type.getInternalName(owner), name, descriptor);
+    }
+
     public void invoke(Class owner, String name, Class result, Class... arguments) {
         if (owner.isInterface()) {
             invokeInterface(owner, name, result, arguments);

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

+package org.openzen.zenscript.javabytecode.compiler;
+
+import org.openzen.zenscript.codemodel.CompareType;
+
+import java.util.Objects;
+
+public class ZenUtils {
+
+    // ###############
+    // ### Compare ###
+    // ###############
+
+    //TODO how to compare them?
+    public static boolean compare(Object a, Object b, String compareType) {
+        CompareType type = CompareType.valueOf(compareType);
+        if (type == CompareType.SAME || type == CompareType.NOTSAME) {
+            final boolean same = a == b;
+            return (type == CompareType.SAME) == same;
+        }
+
+        if (a instanceof Comparable)
+            return checkCompareReturn(((Comparable) a).compareTo(b), type);
+        return false;
+    }
+
+
+    public static boolean compare(boolean a, boolean b, String compareType) {
+        return checkCompareReturn(Boolean.compare(a, b), CompareType.valueOf(compareType));
+    }
+
+    public static boolean compare(int a, int b, String compareType) {
+        return checkCompareReturn(Integer.compare(a, b), CompareType.valueOf(compareType));
+    }
+
+    public static boolean compare(char a, char b, String compareType) {
+        return checkCompareReturn(Character.compare(a, b), CompareType.valueOf(compareType));
+    }
+
+    public static boolean compare(byte a, byte b, String compareType) {
+        return checkCompareReturn(Byte.compare(a, b), CompareType.valueOf(compareType));
+    }
+
+    public static boolean compare(short a, short b, String compareType) {
+        return checkCompareReturn(Short.compare(a, b), CompareType.valueOf(compareType));
+    }
+
+    public static boolean compare(long a, long b, String compareType) {
+        return checkCompareReturn(Long.compare(a, b), CompareType.valueOf(compareType));
+    }
+
+    public static boolean compare(float a, float b, String compareType) {
+        return checkCompareReturn(Float.compare(a, b), CompareType.valueOf(compareType));
+    }
+
+    public static boolean compare(double a, double b, String compareType) {
+        return checkCompareReturn(Double.compare(a, b), CompareType.valueOf(compareType));
+    }
+
+    private static boolean checkCompareReturn(int compareResult, CompareType type) {
+        switch (type) {
+            case LT:
+                return compareResult < 0;
+            case GT:
+                return compareResult > 0;
+            case EQ:
+            case SAME:
+                return compareResult == 0;
+            case NOTSAME:
+            case NE:
+                return compareResult != 0;
+            case LE:
+                return compareResult <= 0;
+            case GE:
+                return compareResult >= 0;
+            default:
+                return false;
+        }
+    }
+}