Removed Membervisitor

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

 package org.openzen.zenscript.javabytecode.compiler;
 
 import org.openzen.zenscript.codemodel.expression.*;
-import org.openzen.zenscript.codemodel.statement.StatementVisitor;
+import org.openzen.zenscript.codemodel.member.DefinitionMember;
+import org.openzen.zenscript.javabytecode.JavaBytecodeImplementation;
+import org.openzen.zenscript.javabytecode.JavaFieldInfo;
+import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 
-    final StatementVisitor<?> statementVisitor;
-    private final JavaWriter javaWriter;
+    private final JavaStatementVisitor statementVisitor;
 
-    public JavaExpressionVisitor(final JavaWriter javaWriter, StatementVisitor<?> statementVisitor) {
-        this.javaWriter = javaWriter;
+    public JavaExpressionVisitor(JavaStatementVisitor statementVisitor) {
         this.statementVisitor = statementVisitor;
     }
 
         for (Expression argument : expression.arguments.arguments) {
             argument.accept(this);
         }
-        expression.member.accept(new JavaMemberVisitor(javaWriter, this));
+        if (!checkAndExecuteByteCodeImplementation(expression.member) && !checkAndExecuteMethodInfo(expression.member))
+            throw new IllegalStateException("Call target has no method info!");
 
         return null;
     }
 
     @Override
     public Void visitConstantBool(ConstantBoolExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantByte(ConstantByteExpression expression) {
-        javaWriter.biPush(expression.value);
+        getJavaWriter().biPush(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantChar(ConstantCharExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantDouble(ConstantDoubleExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantFloat(ConstantFloatExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantInt(ConstantIntExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantLong(ConstantLongExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantSByte(ConstantSByteExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantShort(ConstantShortExpression expression) {
-        javaWriter.siPush(expression.value);
+        getJavaWriter().siPush(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantString(ConstantStringExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantUInt(ConstantUIntExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantULong(ConstantULongExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
     @Override
     public Void visitConstantUShort(ConstantUShortExpression expression) {
-        javaWriter.constant(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
 
     @Override
     public Void visitGetField(GetFieldExpression expression) {
+        if (!checkAndExecuteFieldInfo(expression.field, false))
+            throw new IllegalStateException("Missing field info on a field member!");
         return null;
     }
 
 
     @Override
     public Void visitGetStaticField(GetStaticFieldExpression expression) {
-        expression.field.accept(new JavaMemberVisitor(javaWriter, this));
+        if (!checkAndExecuteFieldInfo(expression.field, true))
+            throw new IllegalStateException("Missing field info on a field member!");
         return null;
     }
 
     public Void visitWrapOptional(WrapOptionalExpression expression) {
         return null;
     }
+
+    public JavaWriter getJavaWriter() {
+        return statementVisitor.getJavaWriter();
+    }
+
+
+    //Will return true if a JavaBytecodeImplementation.class tag exists, and will compile that tag
+    private boolean checkAndExecuteByteCodeImplementation(DefinitionMember member) {
+        JavaBytecodeImplementation implementation = member.getTag(JavaBytecodeImplementation.class);
+        if (implementation != null) {
+            implementation.compile(getJavaWriter());
+            return true;
+        }
+        return false;
+    }
+
+    //Will return true if a JavaMethodInfo.class tag exists, and will compile that tag
+    private boolean checkAndExecuteMethodInfo(DefinitionMember member) {
+        JavaMethodInfo methodInfo = member.getTag(JavaMethodInfo.class);
+        if (methodInfo == null)
+            return false;
+        if (methodInfo.isStatic) {
+            getJavaWriter().invokeStatic(
+                    methodInfo.javaClass.internalClassName,
+                    methodInfo.name,
+                    methodInfo.signature);
+        } else {
+            getJavaWriter().invokeVirtual(
+                    methodInfo.javaClass.internalClassName,
+                    methodInfo.name,
+                    methodInfo.signature);
+        }
+        return true;
+    }
+
+
+    //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) {
+        JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
+        if (fieldInfo == null)
+            return false;
+        if (isStatic) {
+            getJavaWriter().getStaticField(
+                    fieldInfo.javaClass.internalClassName,
+                    fieldInfo.name,
+                    fieldInfo.signature);
+        } else {
+            getJavaWriter().getField(
+                    fieldInfo.javaClass.internalClassName,
+                    fieldInfo.name,
+                    fieldInfo.signature);
+        }
+        return true;
+    }
 }

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

-package org.openzen.zenscript.javabytecode.compiler;
-
-import org.openzen.zenscript.codemodel.member.*;
-import org.openzen.zenscript.javabytecode.JavaBytecodeImplementation;
-import org.openzen.zenscript.javabytecode.JavaFieldInfo;
-import org.openzen.zenscript.javabytecode.JavaMethodInfo;
-
-public class JavaMemberVisitor implements MemberVisitor<Void> {
-
-    private final JavaWriter javaWriter;
-    private final JavaExpressionVisitor expressionVisitor;
-
-    public JavaMemberVisitor(JavaWriter javaWriter, JavaExpressionVisitor expressionVisitor) {
-        this.javaWriter = javaWriter;
-        this.expressionVisitor = expressionVisitor;
-    }
-
-
-    @Override
-    public Void visitField(FieldMember member) {
-        JavaFieldInfo fieldInfo = member.getTag(JavaFieldInfo.class);
-        if (fieldInfo == null)
-            throw new IllegalStateException("Missing field info on a field member!");
-
-        javaWriter.getStaticField(
-                fieldInfo.javaClass.internalClassName,
-                fieldInfo.name,
-                fieldInfo.signature);
-        return null;
-    }
-
-    @Override
-    public Void visitConstructor(ConstructorMember member) {
-        return null;
-    }
-
-    @Override
-    public Void visitMethod(MethodMember member) {
-        if(!checkAndExecuteByteCodeImplementation(member) && !checkAndExecuteMethodInfo(member))
-            throw new IllegalStateException("Call target has no method info!");
-
-        return null;
-    }
-
-    @Override
-    public Void visitGetter(GetterMember member) {
-        return null;
-    }
-
-    @Override
-    public Void visitSetter(SetterMember member) {
-        return null;
-    }
-
-    @Override
-    public Void visitEnumConstant(EnumConstantMember member) {
-        return null;
-    }
-
-    @Override
-    public Void visitOperator(OperatorMember member) {
-        if(!checkAndExecuteByteCodeImplementation(member) && !checkAndExecuteMethodInfo(member))
-            throw new IllegalStateException("Call target has no method info!");
-        return null;
-    }
-
-    @Override
-    public Void visitCaster(CasterMember member) {
-        if(!checkAndExecuteByteCodeImplementation(member) && !checkAndExecuteMethodInfo(member))
-            throw new IllegalStateException("Call target has no method info!");
-        return null;
-    }
-
-    @Override
-    public Void visitCustomIterator(CustomIteratorMember member) {
-        return null;
-    }
-
-    @Override
-    public Void visitCaller(CallerMember member) {
-        if(!checkAndExecuteByteCodeImplementation(member) && !checkAndExecuteMethodInfo(member))
-            throw new IllegalStateException("Call target has no method info!");
-        return null;
-    }
-
-    @Override
-    public Void visitImplementation(ImplementationMember member) {
-        return null;
-    }
-
-    @Override
-    public Void visitInnerDefinition(InnerDefinitionMember member) {
-        return null;
-    }
-
-
-    private boolean checkAndExecuteByteCodeImplementation(DefinitionMember member) {
-        JavaBytecodeImplementation implementation = member.getTag(JavaBytecodeImplementation.class);
-        if (implementation != null) {
-            implementation.compile(javaWriter);
-            return true;
-        }
-        return false;
-    }
-
-    private boolean checkAndExecuteMethodInfo(DefinitionMember member) {
-        JavaMethodInfo methodInfo = member.getTag(JavaMethodInfo.class);
-        if (methodInfo == null)
-            return false;
-        if (methodInfo.isStatic) {
-            javaWriter.invokeStatic(
-                    methodInfo.javaClass.internalClassName,
-                    methodInfo.name,
-                    methodInfo.signature);
-        } else {
-            javaWriter.invokeVirtual(
-                    methodInfo.javaClass.internalClassName,
-                    methodInfo.name,
-                    methodInfo.signature);
-        }
-        return true;
-    }
-}

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

 
 public class JavaStatementVisitor implements StatementVisitor<Void> {
     private final JavaWriter javaWriter;
+    private final JavaExpressionVisitor expressionVisitor;
 
     public JavaStatementVisitor(final JavaWriter javaWriter) {
 
         this.javaWriter = javaWriter;
+        this.expressionVisitor = new JavaExpressionVisitor( this);
     }
 
     @Override
 
     @Override
     public Void visitExpression(ExpressionStatement statement) {
-        statement.expression.accept(new JavaExpressionVisitor(javaWriter, this));
+        statement.expression.accept(expressionVisitor);
         return null;
     }
 
         javaWriter.ret();
         javaWriter.end();
     }
+
+    public JavaWriter getJavaWriter() {
+        return javaWriter;
+    }
 }