Added unboxingTypeVisitor and fixed primitives in Iterators

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

 	}
 
 	public static boolean isLarge(StoredType type) {
-		return type.type == BasicTypeID.DOUBLE || type.type == BasicTypeID.DOUBLE;
+		return type.type == BasicTypeID.DOUBLE || type.type == BasicTypeID.LONG;
 	}
 	
 	public static int calcAccess(int modifiers) {

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

 			default:
 				return null;
 		}
-		writer.dup();
 		
 		if (method != null)
 			writer.invokeStatic(method);

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

 	private static final JavaMethod SHARED_ADDREF = JavaMethod.getNativeVirtual(JavaClass.SHARED, "addRef", "()V");
 	private static final JavaMethod SHARED_RELEASE = JavaMethod.getNativeVirtual(JavaClass.SHARED, "release", "()V");
 
-	protected final JavaWriter javaWriter;
-	private final JavaCapturedExpressionVisitor capturedExpressionVisitor = new JavaCapturedExpressionVisitor(this);
-	private final JavaBytecodeContext context;
-	private final JavaCompiledModule module;
+	final JavaWriter javaWriter;
+    private final JavaBoxingTypeVisitor boxingTypeVisitor;
+    private final JavaUnboxingTypeVisitor unboxingTypeVisitor;
+    private final JavaCapturedExpressionVisitor capturedExpressionVisitor = new JavaCapturedExpressionVisitor(this);
+    private final JavaBytecodeContext context;
+    private final JavaCompiledModule module;
 
 	public JavaExpressionVisitor(JavaBytecodeContext context, JavaCompiledModule module, JavaWriter javaWriter) {
 		this.javaWriter = javaWriter;
 		this.context = context;
 		this.module = module;
-	}
+        boxingTypeVisitor = new JavaBoxingTypeVisitor(javaWriter);
+        unboxingTypeVisitor = new JavaUnboxingTypeVisitor(javaWriter);
+    }
 
 	@Override
 	public Void visitAndAnd(AndAndExpression expression) {
 		javaWriter.ifNonNull(end);
 		javaWriter.pop();
 		expression.right.accept(this);
+		expression.right.type.type.accept(expression.right.type, boxingTypeVisitor);
 		javaWriter.label(end);
+		expression.type.type.accept(expression.type, unboxingTypeVisitor);
 		return null;
 	}
 
 		javaWriter.newObject("java/util/HashMap");
 		javaWriter.dup();
 		javaWriter.invokeSpecial("java/util/HashMap", "<init>", "()V");
+        final AssocTypeID type = (AssocTypeID) expression.type.type;
 		for (int i = 0; i < expression.keys.length; i++) {
 			javaWriter.dup();
 			expression.keys[i].accept(this);
-			expression.values[i].accept(this);
-			javaWriter.invokeInterface(MAP_PUT);
+            type.keyType.type.accept(type.keyType, boxingTypeVisitor);
+            expression.values[i].accept(this);
+            type.valueType.type.accept(type.valueType, boxingTypeVisitor);
+            javaWriter.invokeInterface(MAP_PUT);
 			javaWriter.pop();
 		}
 		return null;
 	public Void visitWrapOptional(WrapOptionalExpression expression) {
 		//Does nothing if not required to be wrapped
 		expression.value.accept(this);
-		expression.value.type.type.accept(expression.value.type, new JavaBoxingTypeVisitor(javaWriter));
+		expression.value.type.type.accept(expression.value.type, boxingTypeVisitor);
 		return null;
 	}
 

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

 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaModifiers;
 
 import java.util.HashMap;
 import java.util.Map;
-
+@SuppressWarnings("Duplicates")
 public class JavaForeachWriter {
 
 	private final JavaWriter javaWriter;
 	private final Label startLabel;
 	private final Label endLabel;
 	private final JavaStatementVisitor statementVisitor;
+	private final JavaUnboxingTypeVisitor unboxingTypeVisitor;
 
 	public JavaForeachWriter(JavaStatementVisitor statementVisitor, VarStatement[] variables, Statement content, Label start, Label end) {
 		this.statementVisitor = statementVisitor;
 		this.content = content;
 		this.startLabel = start;
 		this.endLabel = end;
-	}
+        this.unboxingTypeVisitor = new JavaUnboxingTypeVisitor(this.javaWriter);
+    }
 
 	public void visitIntRange() {
 		javaWriter.dup();
 	}
 
 	public void visitStringCharacterIterator() {
-		//TODO UNTESTED!
-		javaWriter.invokeSpecial("java/lang/String", "toCharArray()", "()[C");
+        javaWriter.invokeVirtual(JavaMethod.getVirtual(JavaClass.STRING, "toCharArray", "()[C", JavaModifiers.PUBLIC));
 		handleArray(javaWriter.local(int.class), javaWriter.getLocalVariable(variables[0].variable));
 	}
 
 
 		javaWriter.label(startLabel);
 		javaWriter.dup();
-		javaWriter.dup();
 		javaWriter.arrayLength();
-		javaWriter.loadInt(z);
-
-		javaWriter.ifICmpLE(endLabel);
-		javaWriter.loadInt(z);
+        javaWriter.loadInt(z);
+        
+        javaWriter.ifICmpLE(endLabel);
+        javaWriter.dup();
+        javaWriter.loadInt(z);
 
 
 		javaWriter.arrayLoad(arrayTypeInfo.type);
 	}
 
 	public void visitAssocKeyIterator() {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	    javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.MAP, "keySet", "()Ljava/util/Set;", 0));
+        javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.COLLECTION, "iterator", "()Ljava/util/Iterator;", 0));
+        
+        javaWriter.label(startLabel);
+        javaWriter.dup();
+        javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.ITERATOR, "hasNext", "()Z", 0));
+        javaWriter.ifEQ(endLabel);
+        javaWriter.dup();
+        javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.ITERATOR, "next", "()Ljava/lang/Object;", 0));
+        
+        final JavaLocalVariableInfo keyVariable = javaWriter.getLocalVariable(variables[0].variable);
+        this.downCast(0, keyVariable.type);
+        javaWriter.store(keyVariable.type, keyVariable.local);
+        
+        content.accept(statementVisitor);
 	}
 
 	public void visitAssocKeyValueIterator() {
 		javaWriter.dup();
 		javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.ITERATOR, "hasNext", "()Z", 0));
 		javaWriter.ifEQ(endLabel);
+		javaWriter.dup();
 		javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.ITERATOR, "next", "()Ljava/lang/Object;", 0));
 		javaWriter.checkCast(Type.getType(Map.Entry.class));
 		javaWriter.dup(false);
 		final JavaLocalVariableInfo valueVariable = javaWriter.getLocalVariable(variables[1].variable);
 
 		javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.fromInternalName("java/util/Map$Entry", JavaClass.Kind.INTERFACE), "getKey", "()Ljava/lang/Object;", 0));
+		this.downCast(0, keyVariable.type);
 		javaWriter.store(keyVariable.type, keyVariable.local);
-
+		
 		javaWriter.invokeInterface(JavaMethod.getVirtual(JavaClass.fromInternalName("java/util/Map$Entry", JavaClass.Kind.INTERFACE), "getValue", "()Ljava/lang/Object;", 0));
+        this.downCast(1, valueVariable.type);
 		javaWriter.store(valueVariable.type, valueVariable.local);
+		
 		content.accept(statementVisitor);
-
-
-		//throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
 	}
+	
+	private void downCast(int typeNumber, Type t) {
+        if(CompilerUtils.isPrimitive(variables[typeNumber].type.type)) {
+            variables[typeNumber].type.type.accept(variables[typeNumber].type, unboxingTypeVisitor);
+        } else {
+            javaWriter.checkCast(t);
+        }
+    }
 }

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

 		
 		javaWriter.goTo(start);
 		javaWriter.label(end);
+		javaWriter.pop();
 		return false;
 	}
 

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

+package org.openzen.zenscript.javabytecode.compiler;
+
+import org.objectweb.asm.Type;
+import org.openzen.zenscript.codemodel.type.*;
+import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaMethod;
+
+public class JavaUnboxingTypeVisitor implements TypeVisitorWithContext<StoredType, Void, RuntimeException> {
+    
+    private static final JavaMethod UNBOX_BOOLEAN = JavaMethod.getNativeVirtual(JavaClass.BOOLEAN, "booleanValue", "()Z");
+    private static final JavaMethod UNBOX_BYTE = JavaMethod.getNativeVirtual(JavaClass.BYTE, "byteValue", "()B");
+    private static final JavaMethod UNBOX_SHORT = JavaMethod.getNativeVirtual(JavaClass.SHORT, "shortValue", "()S");
+    private static final JavaMethod UNBOX_INTEGER = JavaMethod.getNativeVirtual(JavaClass.INTEGER, "intValue", "()I");
+    private static final JavaMethod UNBOX_LONG = JavaMethod.getNativeVirtual(JavaClass.LONG, "longValue", "()J");
+    private static final JavaMethod UNBOX_FLOAT = JavaMethod.getNativeVirtual(JavaClass.FLOAT, "floatValue", "()F");
+    private static final JavaMethod UNBOX_DOUBLE = JavaMethod.getNativeVirtual(JavaClass.DOUBLE, "doubleValue", "()D");
+    private static final JavaMethod UNBOX_CHARACTER = JavaMethod.getNativeVirtual(JavaClass.CHARACTER, "charValue", "()C");
+    
+    private final JavaWriter writer;
+    
+    public JavaUnboxingTypeVisitor(JavaWriter writer) {
+        this.writer = writer;
+    }
+    
+    
+    @Override
+    public Void visitBasic(StoredType context, BasicTypeID basic) throws RuntimeException {
+        final JavaMethod method;
+        
+        switch(basic) {
+            case BOOL:
+                writer.checkCast(JavaClass.BOOLEAN.internalName);
+                method = UNBOX_BOOLEAN;
+                break;
+            case BYTE:
+            case SBYTE:
+                writer.checkCast(JavaClass.BYTE.internalName);
+                method = UNBOX_BYTE;
+                break;
+            case SHORT:
+            case USHORT:
+                writer.checkCast(JavaClass.SHORT.internalName);
+                method = UNBOX_SHORT;
+                break;
+            case INT:
+            case UINT:
+                writer.checkCast(JavaClass.INTEGER.internalName);
+                method = UNBOX_INTEGER;
+                break;
+            case LONG:
+            case ULONG:
+            case USIZE:
+                writer.checkCast(JavaClass.LONG.internalName);
+                method = UNBOX_LONG;
+                break;
+            case FLOAT:
+                writer.checkCast(JavaClass.FLOAT.internalName);
+                method = UNBOX_FLOAT;
+                break;
+            case DOUBLE:
+                writer.checkCast(JavaClass.DOUBLE.internalName);
+                method = UNBOX_DOUBLE;
+                break;
+            case CHAR:
+                writer.checkCast(JavaClass.CHARACTER.internalName);
+                method = UNBOX_CHARACTER;
+                break;
+            case VOID:
+            case UNDETERMINED:
+            case NULL:
+            default:
+                return null;
+        }
+        writer.invokeVirtual(method);
+        return null;
+    }
+    
+    @Override
+    public Void visitString(StoredType context, StringTypeID string) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitArray(StoredType context, ArrayTypeID array) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitAssoc(StoredType context, AssocTypeID assoc) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitGenericMap(StoredType context, GenericMapTypeID map) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitIterator(StoredType context, IteratorTypeID iterator) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitFunction(StoredType context, FunctionTypeID function) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitDefinition(StoredType context, DefinitionTypeID definition) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitGeneric(StoredType context, GenericTypeID generic) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitRange(StoredType context, RangeTypeID range) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+    
+    @Override
+    public Void visitOptional(StoredType context, OptionalTypeID type) throws RuntimeException {
+        //NO-OP
+        return null;
+    }
+}