More work on ExpressionVisitors and added String add method to JavaWriter

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

 		LONG_GET_MIN_VALUE.setTag(JavaFieldInfo.class, new JavaFieldInfo(jLong, "MIN_VALUE", "J"));
 		LONG_GET_MAX_VALUE.setTag(JavaFieldInfo.class, new JavaFieldInfo(jLong, "MAX_VALUE", "J"));
 		
-		implement(BOOL_NOT, writer -> writer.iNot());
-		
-		implement(BYTE_NOT, writer -> writer.iNot());
-		implement(SBYTE_NOT, writer -> writer.iNot());
-		implement(SHORT_NOT, writer -> writer.iNot());
-		implement(USHORT_NOT, writer -> writer.iNot());
-		implement(INT_NOT, writer -> writer.iNot());
-		implement(UINT_NOT, writer -> writer.iNot());
-		implement(LONG_NOT, writer -> writer.lNot());
-		implement(ULONG_NOT, writer -> writer.lNot());
-		
-		implement(BYTE_NEG, writer -> writer.iNeg());
-		implement(SBYTE_NEG, writer -> writer.iNeg());
-		implement(SHORT_NEG, writer -> writer.iNeg());
-		implement(USHORT_NEG, writer -> writer.iNeg());
-		implement(INT_NEG, writer -> writer.iNeg());
-		implement(UINT_NEG, writer -> writer.iNeg());
-		implement(LONG_NEG, writer -> writer.lNeg());
-		implement(ULONG_NEG, writer -> writer.lNeg());
-		implement(FLOAT_NEG, writer -> writer.fNeg());
-		implement(DOUBLE_NEG, writer -> writer.dNeg());
-		
-		implement(BYTE_ADD_BYTE, writer -> writer.iAdd());
-		implement(SBYTE_ADD_SBYTE, writer -> writer.iAdd());
-		implement(SHORT_ADD_SHORT, writer -> writer.iAdd());
-		implement(USHORT_ADD_USHORT, writer -> writer.iAdd());
-		implement(INT_ADD_INT, writer -> writer.iAdd());
-		implement(UINT_ADD_UINT, writer -> writer.iAdd());
-		implement(LONG_ADD_LONG, writer -> writer.lAdd());
-		implement(ULONG_ADD_ULONG, writer -> writer.lAdd());
-		implement(FLOAT_ADD_FLOAT, writer -> writer.fAdd());
-		implement(DOUBLE_ADD_DOUBLE, writer -> writer.dAdd());
+		implement(BOOL_NOT, JavaWriter::iNot);
+		
+		implement(BYTE_NOT, JavaWriter::iNot);
+		implement(SBYTE_NOT, JavaWriter::iNot);
+		implement(SHORT_NOT, JavaWriter::iNot);
+		implement(USHORT_NOT, JavaWriter::iNot);
+		implement(INT_NOT, JavaWriter::iNot);
+		implement(UINT_NOT, JavaWriter::iNot);
+		implement(LONG_NOT, JavaWriter::lNot);
+		implement(ULONG_NOT, JavaWriter::lNot);
+		
+		implement(BYTE_NEG, JavaWriter::iNeg);
+		implement(SBYTE_NEG, JavaWriter::iNeg);
+		implement(SHORT_NEG, JavaWriter::iNeg);
+		implement(USHORT_NEG, JavaWriter::iNeg);
+		implement(INT_NEG, JavaWriter::iNeg);
+		implement(UINT_NEG, JavaWriter::iNeg);
+		implement(LONG_NEG, JavaWriter::lNeg);
+		implement(ULONG_NEG, JavaWriter::lNeg);
+		implement(FLOAT_NEG, JavaWriter::fNeg);
+		implement(DOUBLE_NEG, JavaWriter::dNeg);
+		
+		implement(BYTE_ADD_BYTE, JavaWriter::iAdd);
+		implement(SBYTE_ADD_SBYTE, JavaWriter::iAdd);
+		implement(SHORT_ADD_SHORT, JavaWriter::iAdd);
+		implement(USHORT_ADD_USHORT, JavaWriter::iAdd);
+		implement(INT_ADD_INT, JavaWriter::iAdd);
+		implement(UINT_ADD_UINT, JavaWriter::iAdd);
+		implement(LONG_ADD_LONG, JavaWriter::lAdd);
+		implement(ULONG_ADD_ULONG, JavaWriter::lAdd);
+		implement(FLOAT_ADD_FLOAT, JavaWriter::fAdd);
+		implement(DOUBLE_ADD_DOUBLE, JavaWriter::dAdd);
 		// TODO: STRING_ADD_STRING
-		
-		implement(BYTE_SUB_BYTE, writer -> writer.iSub());
-		implement(SBYTE_SUB_SBYTE, writer -> writer.iSub());
-		implement(SHORT_SUB_SHORT, writer -> writer.iSub());
-		implement(USHORT_SUB_USHORT, writer -> writer.iSub());
-		implement(INT_SUB_INT, writer -> writer.iSub());
-		implement(UINT_SUB_UINT, writer -> writer.iSub());
-		implement(LONG_SUB_LONG, writer -> writer.lSub());
-		implement(ULONG_SUB_ULONG, writer -> writer.lSub());
-		implement(FLOAT_SUB_FLOAT, writer -> writer.fSub());
-		implement(DOUBLE_SUB_DOUBLE, writer -> writer.dSub());
-		
-		implement(BYTE_MUL_BYTE, writer -> writer.iMul());
-		implement(SBYTE_MUL_SBYTE, writer -> writer.iMul());
-		implement(SHORT_MUL_SHORT, writer -> writer.iMul());
-		implement(USHORT_MUL_USHORT, writer -> writer.iMul());
-		implement(INT_MUL_INT, writer -> writer.iMul());
-		implement(UINT_MUL_UINT, writer -> writer.iMul());
-		implement(LONG_MUL_LONG, writer -> writer.lMul());
-		implement(ULONG_MUL_ULONG, writer -> writer.lMul());
-		implement(FLOAT_MUL_FLOAT, writer -> writer.fMul());
-		implement(DOUBLE_MUL_DOUBLE, writer -> writer.dMul());
-		
-		implement(INT_DIV_INT, writer -> writer.iDiv());
-		implement(INT_MOD_INT, writer -> writer.iRem());
-		
-		implement(INT_TO_BYTE, writer -> writer.i2b());
-		implement(INT_TO_SBYTE, writer -> writer.i2b());
-		implement(INT_TO_SHORT, writer -> writer.i2s());
-		implement(INT_TO_USHORT, writer -> writer.i2s());
+
+		implement(STRING_ADD_STRING, JavaWriter::stringAdd);
+		
+		implement(BYTE_SUB_BYTE, JavaWriter::iSub);
+		implement(SBYTE_SUB_SBYTE, JavaWriter::iSub);
+		implement(SHORT_SUB_SHORT, JavaWriter::iSub);
+		implement(USHORT_SUB_USHORT, JavaWriter::iSub);
+		implement(INT_SUB_INT, JavaWriter::iSub);
+		implement(UINT_SUB_UINT, JavaWriter::iSub);
+		implement(LONG_SUB_LONG, JavaWriter::lSub);
+		implement(ULONG_SUB_ULONG, JavaWriter::lSub);
+		implement(FLOAT_SUB_FLOAT, JavaWriter::fSub);
+		implement(DOUBLE_SUB_DOUBLE, JavaWriter::dSub);
+		
+		implement(BYTE_MUL_BYTE, JavaWriter::iMul);
+		implement(SBYTE_MUL_SBYTE, JavaWriter::iMul);
+		implement(SHORT_MUL_SHORT, JavaWriter::iMul);
+		implement(USHORT_MUL_USHORT, JavaWriter::iMul);
+		implement(INT_MUL_INT, JavaWriter::iMul);
+		implement(UINT_MUL_UINT, JavaWriter::iMul);
+		implement(LONG_MUL_LONG, JavaWriter::lMul);
+		implement(ULONG_MUL_ULONG, JavaWriter::lMul);
+		implement(FLOAT_MUL_FLOAT, JavaWriter::fMul);
+		implement(DOUBLE_MUL_DOUBLE, JavaWriter::dMul);
+		
+		implement(INT_DIV_INT, JavaWriter::iDiv);
+		implement(INT_MOD_INT, JavaWriter::iRem);
+		
+		implement(INT_TO_BYTE, JavaWriter::i2b);
+		implement(INT_TO_SBYTE, JavaWriter::i2b);
+		implement(INT_TO_SHORT, JavaWriter::i2s);
+		implement(INT_TO_USHORT, JavaWriter::i2s);
 		implement(INT_TO_UINT, writer -> {});
-		implement(INT_TO_LONG, writer -> writer.i2l());
-		implement(INT_TO_ULONG, writer -> writer.i2l());
-		implement(INT_TO_FLOAT, writer -> writer.i2f());
-		implement(INT_TO_DOUBLE, writer -> writer.i2d());
-		implement(INT_TO_CHAR, writer -> writer.i2s());
+		implement(INT_TO_LONG, JavaWriter::i2l);
+		implement(INT_TO_ULONG, JavaWriter::i2l);
+		implement(INT_TO_FLOAT, JavaWriter::i2f);
+		implement(INT_TO_DOUBLE, JavaWriter::i2d);
+		implement(INT_TO_CHAR, JavaWriter::i2s);
 		INT_TO_STRING.setTag(JavaMethodInfo.class, new JavaMethodInfo(jInteger, "toString", "(I)Ljava/lang/String;", true));
 		
 		implement(LONG_TO_BYTE, writer -> { writer.l2i(); writer.i2b(); });
 		implement(LONG_TO_SBYTE, writer -> { writer.l2i(); writer.i2b(); });
 		implement(LONG_TO_SHORT, writer -> { writer.l2i(); writer.i2s(); });
 		implement(LONG_TO_USHORT, writer -> { writer.l2i(); writer.i2s(); });
-		implement(LONG_TO_INT, writer -> writer.l2i());
-		implement(LONG_TO_UINT, writer -> writer.l2i());
+		implement(LONG_TO_INT, JavaWriter::l2i);
+		implement(LONG_TO_UINT, JavaWriter::l2i);
 		implement(LONG_TO_ULONG, writer -> {});
-		implement(LONG_TO_FLOAT, writer -> writer.l2f());
-		implement(LONG_TO_DOUBLE, writer -> writer.l2d());
+		implement(LONG_TO_FLOAT, JavaWriter::l2f);
+		implement(LONG_TO_DOUBLE, JavaWriter::l2d);
 		implement(LONG_TO_CHAR, writer -> { writer.l2i(); writer.i2s(); });
 		LONG_TO_STRING.setTag(JavaMethodInfo.class, new JavaMethodInfo(jLong, "toString", "(J)Ljava/lang/String;", true));
 		

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

 package org.openzen.zenscript.javabytecode.compiler;
 
+import org.objectweb.asm.Type;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.member.DefinitionMember;
 import org.openzen.zenscript.javabytecode.JavaBytecodeImplementation;
 import org.openzen.zenscript.shared.CompileException;
 import org.openzen.zenscript.shared.CompileExceptionCode;
 
+import java.util.Map;
+
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 
     private JavaWriter javaWriter;
 
     @Override
     public Void visitArray(ArrayExpression expression) {
+        javaWriter.constant(expression.expressions.length);
+        Type type = Type.getType(expression.type.accept(JavaTypeClassVisitor.INSTANCE).getComponentType());
+        javaWriter.newArray(type);
+        for (int i = 0; i < expression.expressions.length; i++) {
+            javaWriter.dup();
+            javaWriter.constant(i);
+            expression.expressions[i].accept(this);
+            javaWriter.arrayStore(type);
+        }
         return null;
     }
 
 
     @Override
     public Void visitGetField(GetFieldExpression expression) {
-        if (!checkAndExecuteFieldInfo(expression.field, false))
+        if (!checkAndGetFieldInfo(expression.field, false))
             throw new IllegalStateException("Missing field info on a field member!");
         return null;
     }
 
     @Override
     public Void visitGetStaticField(GetStaticFieldExpression expression) {
-        if (!checkAndExecuteFieldInfo(expression.field, true))
+        if (!checkAndGetFieldInfo(expression.field, true))
             throw new IllegalStateException("Missing field info on a field member!");
         return null;
     }
 
     @Override
     public Void visitInterfaceCast(InterfaceCastExpression expression) {
+        expression.value.accept(this);
+        javaWriter.checkCast(expression.type.accept(JavaTypeClassVisitor.INSTANCE));
         return null;
     }
 
     @Override
     public Void visitIs(IsExpression expression) {
+        expression.value.accept(this);
+        javaWriter.instanceOf(Type.getDescriptor(expression.isType.accept(JavaTypeClassVisitor.INSTANCE)));
         return null;
     }
 
     @Override
-    public Void visitMakeConst(MakeConstExpression expression) {
+    public Void visitMakeConst(MakeConstExpression expression)
+    {
+
         return null;
     }
 
     @Override
     public Void visitMap(MapExpression expression) {
+        javaWriter.newObject(expression.type.accept(JavaTypeClassVisitor.INSTANCE));
+        javaWriter.dup();
+        javaWriter.invokeSpecial("java/util/Map", "<init>", "()V");
+        for (int i = 0; i < expression.keys.length; i++) {
+            javaWriter.dup();
+            expression.keys[i].accept(this);
+            expression.values[i].accept(this);
+            javaWriter.invokeInterface(Map.class, "put", Object.class, Object.class, Object.class);
+            javaWriter.pop();
+        }
         return null;
     }
 
     @Override
     public Void visitNew(NewExpression expression) {
+        String type = Type.getDescriptor(expression.type.accept(JavaTypeClassVisitor.INSTANCE));
+        javaWriter.newObject(type);
+        javaWriter.dup();
+        StringBuilder signatureBuilder = new StringBuilder("(");
+        for (Expression argument : expression.arguments.arguments) {
+            argument.accept(this);
+            signatureBuilder.append(Type.getDescriptor(argument.type.accept(JavaTypeClassVisitor.INSTANCE)));
+        }
+        signatureBuilder.append(")V");
+        javaWriter.invokeSpecial(type, "<init>", signatureBuilder.toString());
+
         return null;
     }
 
     @Override
     public Void visitNot(NotExpression expression) {
+        expression.value.accept(this);
+        javaWriter.iNeg();
         return null;
     }
 
     @Override
     public Void visitNull(NullExpression expression) {
+        javaWriter.aConstNull();
         return null;
     }
 
 
     @Override
     public Void visitSetField(SetFieldExpression expression) {
+        if (expression.field.isFinal)
+            throw new CompileException(expression.position, CompileExceptionCode.CANNOT_SET_FINAL_VARIABLE, "Cannot set a final field!");
+        expression.value.accept(this);
+        if (!checkAndPutFieldInfo(expression.field, false))
+            throw new IllegalStateException("Missing field info on a field member!");
         return null;
     }
 
 
     @Override
     public Void visitSetLocalVariable(SetLocalVariableExpression expression) {
-        if(expression.variable.isFinal)
+        if (expression.variable.isFinal)
             throw new CompileException(expression.position, CompileExceptionCode.CANNOT_SET_FINAL_VARIABLE, "Cannot set a final variable!");
         expression.value.accept(this);
         final JavaLocalVariableInfo tag = expression.variable.getTag(JavaLocalVariableInfo.class);
 
     @Override
     public Void visitSetStaticField(SetStaticFieldExpression expression) {
+        if (expression.field.isFinal)
+            throw new CompileException(expression.position, CompileExceptionCode.CANNOT_SET_FINAL_VARIABLE, "Cannot set a final field!");
+        expression.value.accept(this);
+        if (!checkAndPutFieldInfo(expression.field, true))
+            throw new IllegalStateException("Missing field info on a field member!");
         return null;
     }
 
 
     //TODO: Should isStatic go to the fieldInfo or stay here?
     //Will return true if a JavaFieldInfo.class tag exists, and will compile that tag
-    private boolean checkAndExecuteFieldInfo(DefinitionMember field, boolean isStatic) {
+    private boolean checkAndPutFieldInfo(DefinitionMember field, boolean isStatic) {
+        JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
+        if (fieldInfo == null)
+            return false;
+        if (isStatic) {
+            getJavaWriter().putStaticField(fieldInfo.javaClass.internalClassName, fieldInfo.name, fieldInfo.signature);
+        } else {
+            getJavaWriter().putField(fieldInfo.javaClass.internalClassName, fieldInfo.name, fieldInfo.signature);
+        }
+        return true;
+    }
+
+    private boolean checkAndGetFieldInfo(DefinitionMember field, boolean isStatic) {
         JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
         if (fieldInfo == null)
             return false;
         if (isStatic) {
-            getJavaWriter().getStaticField(
-                    fieldInfo.javaClass.internalClassName,
-                    fieldInfo.name,
-                    fieldInfo.signature);
+            getJavaWriter().getStaticField(fieldInfo.javaClass.internalClassName, fieldInfo.name, fieldInfo.signature);
         } else {
-            getJavaWriter().getField(
-                    fieldInfo.javaClass.internalClassName,
-                    fieldInfo.name,
-                    fieldInfo.signature);
+            getJavaWriter().getField(fieldInfo.javaClass.internalClassName, fieldInfo.name, fieldInfo.signature);
         }
         return true;
     }

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

 
         return labelNames.get(lbl);
     }
+
+    public void stringAdd() {
+        invokeVirtual(String.class, "concat", String.class, String.class);
+    }
 }