some minor changes

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

  * @author Hoofdgebruiker
  */
 public class JavaModule {
-	private final Map<String, byte[]> classes = new HashMap<>();
+	public static final Map<String, byte[]> classes = new HashMap<>();
 	
 	public JavaModule() {
 		

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

 
     @Override
     public Void visitCapturedDirect(CapturedDirectExpression expression) {
-        return null;
+        return expression.value.accept(expressionVisitor);
     }
 
     @Override
     public Void visitRecaptured(CapturedClosureExpression expression) {
-        expression.value.accept(this);
-        return null;
+        return expression.value.accept(this);
     }
 }

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

 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.member.DefinitionMember;
+import org.openzen.zenscript.codemodel.member.GetterMember;
 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.shared.CompileExceptionCode;
 
 import java.util.Arrays;
+import java.util.Comparator;
 import java.util.Map;
 import java.util.StringJoiner;
 
     private static final JavaMethodInfo MAP_PUT = JavaMethodInfo.get(Opcodes.ACC_PUBLIC, Map.class, "put", Object.class, Object.class, Object.class);
 
     private final JavaWriter javaWriter;
+    private final JavaCapturedExpressionVisitor capturedExpressionVisitor = new JavaCapturedExpressionVisitor(this);
 
     public JavaExpressionVisitor(JavaWriter javaWriter) {
         this.javaWriter = javaWriter;
 
     @Override
     public Void visitCapturedClosure(CapturedClosureExpression expression) {
-        expression.value.accept(this);
-        return null;
+        return expression.accept(capturedExpressionVisitor);
     }
 
     @Override
     public Void visitCapturedDirect(CapturedDirectExpression expression) {
-        return null;
+        return expression.accept(capturedExpressionVisitor);
     }
 
     @Override
     public Void visitCapturedLocalVariable(CapturedLocalVariableExpression expression) {
-        new GetLocalVariableExpression(expression.position, expression.variable).accept(this);
-        return null;
+        return expression.accept(capturedExpressionVisitor);
     }
 
     @Override
     public Void visitCapturedParameter(CapturedParameterExpression expression) {
-
-        return null;
+        return expression.accept(capturedExpressionVisitor);
     }
 
     @Override
     public Void visitCapturedThis(CapturedThisExpression expression) {
-        return null;
+        return expression.accept(capturedExpressionVisitor);
     }
 
     @Override
     public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
         Type type = expression.objectType.accept(JavaTypeVisitor.INSTANCE);
 
+        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) {
 
     @Override
     public Void visitGetter(GetterExpression expression) {
+        expression.target.accept(this);
+        final GetterMember getter = expression.getter;
+        //TODO check, since I don't know how to declare getters...
+        javaWriter.invokeVirtual(
+                new JavaMethodInfo(
+                        new JavaClassInfo(
+                                expression.target.type.accept(JavaTypeVisitor.INSTANCE).getInternalName(),
+                                false),
+                        getter.name,
+                        CompilerUtils.calcDesc(getter.header, false),
+                        CompilerUtils.calcAccess(getter.modifiers)
+                )
+        );
         return null;
     }
 
         }
 
         JavaSwitchLabel[] sortedSwitchLabels = Arrays.copyOf(switchLabels, switchLabels.length);
-        Arrays.sort(sortedSwitchLabels, (a, b) -> a.key - b.key);
+        Arrays.sort(sortedSwitchLabels, Comparator.comparingInt(a -> a.key));
 
         javaWriter.lookupSwitch(defaultLabel, sortedSwitchLabels);
 
         return null;
     }
 
-    private boolean hasNoDefault(MatchExpression switchStatement) {
+    private static boolean hasNoDefault(MatchExpression switchStatement) {
         for (MatchExpression.Case switchCase : switchStatement.cases)
             if (switchCase.key == null) return false;
         return true;

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
+import org.openzen.zenscript.javabytecode.JavaModule;
 import org.openzen.zenscript.javabytecode.compiler.*;
 
 
 
     @Override
     public byte[] visitAlias(AliasDefinition definition) {
-        return null;
+        //TODO would that work?
+        return JavaModule.classes.get(definition.name);
     }
 
 	@Override