Merge remote-tracking branch 'kindlich/development' into development

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/ExpressionFormatter.java

 
 	@Override
 	public ExpressionString visitConstantDouble(ConstantDoubleExpression expression) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	    return new ExpressionString(Double.toString(expression.value), ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 	public ExpressionString visitConstantFloat(ConstantFloatExpression expression) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        return new ExpressionString(Float.toString(expression.value), ZenScriptOperator.PRIMARY);
 	}
 
 	@Override

JavaAnnotations/src/main/java/org/openzen/zencode/java/StorageTagType.java

+package org.openzen.zencode.java;
+
+public enum StorageTagType {
+    STATIC
+}

JavaAnnotations/src/main/java/org/openzen/zencode/java/ZenCodeStorageTag.java

+package org.openzen.zencode.java;
+
+import java.lang.annotation.*;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE_USE)
+public @interface ZenCodeStorageTag {
+    
+    StorageTagType value();
+    
+}

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

 import java.util.StringJoiner;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void>, JavaNativeTranslator<Void> {
+    private static final JavaMethod OBJECTS_TOSTRING = JavaMethod.getNativeStatic(new JavaClass("java.util", "Objects", JavaClass.Kind.CLASS), "toString", "(Ljava/lang/Object;)Ljava/lang/String;");
+    
 	private static final JavaMethod BOOLEAN_PARSE = JavaMethod.getNativeStatic(JavaClass.BOOLEAN, "parseBoolean", "(Ljava/lang/String;)Z");
 	private static final JavaMethod BOOLEAN_TO_STRING = JavaMethod.getNativeStatic(JavaClass.BOOLEAN, "toString", "(Z)Ljava/lang/String;");
 	private static final JavaMethod BYTE_PARSE = JavaMethod.getNativeStatic(JavaClass.BYTE, "parseByte", "(Ljava/lang/String;)B");
 	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) {
 
 		switch (builtin) {
 			case BOOL_TO_STRING:
-				javaWriter.invokeStatic(BOOLEAN_TO_STRING);
+                if(expression.target.type.isOptional()) {
+                    javaWriter.invokeStatic(OBJECTS_TOSTRING);
+                } else {
+                    javaWriter.invokeStatic(BOOLEAN_TO_STRING);
+                }
 				break;
 			case BYTE_TO_SBYTE:
 				javaWriter.i2b();
 				javaWriter.iAnd();
 				break;
 			case BYTE_TO_STRING:
-				javaWriter.constant(0xFF);
-				javaWriter.iAnd();
-				javaWriter.invokeStatic(INTEGER_TO_STRING);
+                if(expression.target.type.isOptional()) {
+                    javaWriter.invokeStatic(OBJECTS_TOSTRING);
+                } else {
+                    javaWriter.constant(0xFF);
+                    javaWriter.iAnd();
+                    javaWriter.invokeStatic(INTEGER_TO_STRING);
+                }
 				break;
 			case SBYTE_TO_BYTE:
 			case SBYTE_TO_SHORT:
 			case SBYTE_TO_CHAR:
 				break;
 			case SBYTE_TO_STRING:
-				javaWriter.invokeStatic(INTEGER_TO_STRING);
+                if(expression.target.type.isOptional()) {
+                    javaWriter.invokeStatic(OBJECTS_TOSTRING);
+                } else {
+                    javaWriter.invokeStatic(INTEGER_TO_STRING);
+                }
 				break;
 			case SHORT_TO_BYTE:
 				break;
 			case SHORT_TO_CHAR:
 				break;
 			case SHORT_TO_STRING:
-				javaWriter.invokeStatic(SHORT_TO_STRING);
+                if(expression.target.type.isOptional()) {
+                    javaWriter.invokeStatic(OBJECTS_TOSTRING);
+                } else {
+                    javaWriter.invokeStatic(SHORT_TO_STRING);
+                }
 				break;
 			case USHORT_TO_BYTE:
 				break;
 				javaWriter.iAnd();
 				break;
 			case USHORT_TO_STRING:
-				javaWriter.constant(0xFFFFL);
-				javaWriter.iAnd();
-				javaWriter.invokeStatic(INTEGER_TO_STRING);
-				break;
+                if(expression.target.type.isOptional()) {
+                    javaWriter.invokeStatic(OBJECTS_TOSTRING);
+                } else {
+                    javaWriter.constant(0xFFFFL);
+                    javaWriter.iAnd();
+                    javaWriter.invokeStatic(INTEGER_TO_STRING);
+                }
+                break;
 			case INT_TO_BYTE:
 			case USIZE_TO_BYTE:
 				break;
 				break;
 			case INT_TO_STRING:
 			case USIZE_TO_STRING:
-				javaWriter.invokeStatic(INTEGER_TO_STRING);
+			    if(expression.target.type.isOptional()) {
+                    javaWriter.invokeStatic(OBJECTS_TOSTRING);
+                } else {
+                    javaWriter.invokeStatic(INTEGER_TO_STRING);
+                }
 				break;
 			case UINT_TO_BYTE:
 				break;
 				javaWriter.i2s();
 				break;
 			case UINT_TO_STRING:
-				javaWriter.invokeStatic(INTEGER_TO_UNSIGNED_STRING);
+                if(expression.target.type.isOptional()) {
+                    javaWriter.invokeStatic(OBJECTS_TOSTRING);
+                } else {
+                    javaWriter.invokeStatic(INTEGER_TO_UNSIGNED_STRING);
+                }
 				break;
 			case LONG_TO_BYTE:
 				javaWriter.l2i();
 				javaWriter.i2s();
 				break;
 			case LONG_TO_STRING:
-				javaWriter.invokeStatic(LONG_TO_STRING);
+                if(expression.target.type.isOptional()) {
+                    javaWriter.invokeStatic(OBJECTS_TOSTRING);
+                } else {
+                    javaWriter.invokeStatic(LONG_TO_STRING);
+                }
 				break;
 			case ULONG_TO_BYTE:
 				javaWriter.l2i();
 				javaWriter.i2s();
 				break;
 			case ULONG_TO_STRING:
-				javaWriter.invokeStatic(LONG_TO_UNSIGNED_STRING);
+                if(expression.target.type.isOptional()) {
+                    javaWriter.invokeStatic(OBJECTS_TOSTRING);
+                } else {
+                    javaWriter.invokeStatic(LONG_TO_UNSIGNED_STRING);
+                }
 				break;
 			case FLOAT_TO_BYTE:
 				javaWriter.f2i();
 				javaWriter.f2d();
 				break;
 			case FLOAT_TO_STRING:
-				javaWriter.invokeStatic(FLOAT_TO_STRING);
+                if(expression.target.type.isOptional()) {
+                    javaWriter.invokeStatic(OBJECTS_TOSTRING);
+                } else {
+                    javaWriter.invokeStatic(FLOAT_TO_STRING);
+                }
 				break;
 			case DOUBLE_TO_BYTE:
 				javaWriter.d2i();
 				javaWriter.d2f();
 				break;
 			case DOUBLE_TO_STRING:
-				javaWriter.invokeStatic(DOUBLE_TO_STRING);
+                if(expression.target.type.isOptional()) {
+                    javaWriter.invokeStatic(OBJECTS_TOSTRING);
+                } else {
+                    javaWriter.invokeStatic(DOUBLE_TO_STRING);
+                }
 				break;
 			case CHAR_TO_BYTE:
 				break;
 				javaWriter.i2l();
 				break;
 			case CHAR_TO_STRING:
-				javaWriter.invokeStatic(CHARACTER_TO_STRING);
+                if(expression.target.type.isOptional()) {
+                    javaWriter.invokeStatic(OBJECTS_TOSTRING);
+                } else {
+                    javaWriter.invokeStatic(CHARACTER_TO_STRING);
+                }
 				break;
 			case ENUM_TO_STRING:
 				javaWriter.invokeVirtual(ENUM_NAME);
 		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;
 	}
 
 				}
 			}
 			
-			bridgeWriter.invokeVirtual(new JavaMethod(JavaClass.fromInternalName(className, JavaClass.Kind.CLASS), methodInfo.kind, methodInfo.name, methodInfo.compile, signature, methodInfo.modifiers, methodInfo.genericResult));
+			bridgeWriter.invokeVirtual(new JavaMethod(JavaClass.fromInternalName(className, JavaClass.Kind.CLASS), JavaMethod.Kind.INSTANCE, methodInfo.name, methodInfo.compile, signature, methodInfo.modifiers, methodInfo.genericResult));
 			if(expression.header.getReturnType().type != BasicTypeID.VOID) {
 				bridgeWriter.returnType(context.getType(expression.header.getReturnType()));
 			}
 		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;
+    }
+}

JavaIntegration/src/main/java/org/openzen/zencode/java/JavaNativeModule.java

 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageType;
 import org.openzen.zenscript.javashared.*;
-import org.openzen.zenscript.lexer.ParseException;
-import org.openzen.zenscript.lexer.ZSTokenParser;
+import org.openzen.zenscript.lexer.*;
 import org.openzen.zenscript.parser.BracketExpressionParser;
 import org.openzen.zenscript.parser.expression.ParsedExpression;
 import org.openzen.zenscript.parser.type.IParsedType;
 import stdlib.Strings;
 
 import java.io.IOException;
-import java.lang.reflect.AnnotatedType;
-import java.lang.reflect.Field;
-import java.lang.reflect.Member;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.lang.reflect.Parameter;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.lang.reflect.TypeVariable;
+import java.lang.reflect.*;
 import java.util.*;
-import java.util.stream.Collectors;
+
 
 /**
  * @author Stan Hebben
 		boolean nullable = annotatedType.isAnnotationPresent(ZenCodeType.Nullable.class);
 		boolean unsigned = annotatedType.isAnnotationPresent(ZenCodeType.Unsigned.class);
 		
-		Type type = annotatedType.getType();
-		return loadType(context, type, nullable, unsigned);
+		return loadType(context, annotatedType, nullable, unsigned);
 	}
 	
-	private StoredType loadType(TypeVariableContext context, Type type, boolean nullable, boolean unsigned) {
+	private StoredType loadType(TypeVariableContext context, AnnotatedElement type, boolean nullable, boolean unsigned) {
 		StoredType result = loadType(context, type, unsigned);
 		if (nullable)
 			result = new StoredType(registry.getOptional(result.type), result.getSpecifiedStorage());
 		return result;
 	}
 	
-	private StoredType loadType(TypeVariableContext context, Type type, boolean unsigned) {
+	@SuppressWarnings("ChainOfInstanceofChecks")
+    private StoredType loadType(TypeVariableContext context, AnnotatedElement type, boolean unsigned) {
 		if (type instanceof Class) {
-			Class<?> classType = (Class<?>) type;
+            Class<?> classType = (Class<?>) type;
 			if (unsigned) {
-				if (unsignedByClass.containsKey(classType))
-					return unsignedByClass.get(classType).stored();
-				else
-					throw new IllegalArgumentException("This class cannot be used as unsigned: " + classType);
+				if (unsignedByClass.containsKey(classType)) {
+                    return unsignedByClass.get(classType).stored();
+                } else {
+                    throw new IllegalArgumentException("This class cannot be used as unsigned: " + classType);
+                }
 			} else if (classType.isArray()) {
 				return registry.getArray(loadType(context, classType.getComponentType(), false, false), 1).stored();
 			} else if (classType.isAnnotationPresent(FunctionalInterface.class)) {
-				return loadFunctionalInterface(context, classType, new Type[0]);
+				return loadFunctionalInterface(context, classType, new AnnotatedElement[0]);
 			}
 			
 			if (typeByClass.containsKey(classType))
 			ParameterizedType parameterizedType = (ParameterizedType) type;
 			Class<?> rawType = (Class) parameterizedType.getRawType();
 			if (rawType.isAnnotationPresent(FunctionalInterface.class))
-				return loadFunctionalInterface(context, rawType, parameterizedType.getActualTypeArguments());
+				return loadFunctionalInterface(context, rawType, (AnnotatedElement[]) parameterizedType.getActualTypeArguments());
 			
-			HighLevelDefinition definition = addClass(rawType);
 			Type[] parameters = parameterizedType.getActualTypeArguments();
 			StoredType[] codeParameters = new StoredType[parameters.length];
 			for (int i = 0; i < parameters.length; i++)
-				codeParameters[i] = loadType(context, parameters[i], false, false);
-			
-			return registry.getForDefinition(definition, codeParameters).stored();
+			    codeParameters[i] = loadType(context, (AnnotatedElement) parameters[i], false, false);
+       
+			if(rawType == Map.class) {
+                return registry.getAssociative(codeParameters[0], codeParameters[1]).stored();
+            }
+            
+            HighLevelDefinition definition = addClass(rawType);
+            return registry.getForDefinition(definition, codeParameters).stored();
 		} else if (type instanceof TypeVariable) {
-			TypeVariable variable = (TypeVariable)type;
-			return registry.getGeneric(context.get(variable)).stored();
-		} else {
+            TypeVariable variable = (TypeVariable) type;
+            return registry.getGeneric(context.get(variable)).stored();
+        }else if(type instanceof AnnotatedType){
+		    final StoredType storedType;
+		    if(type instanceof AnnotatedParameterizedType) {
+                AnnotatedParameterizedType parameterizedType = (AnnotatedParameterizedType) type;
+                final Type rawType = ((ParameterizedType) parameterizedType.getType()).getRawType();
+                final AnnotatedType[] actualTypeArguments = parameterizedType.getAnnotatedActualTypeArguments();
+                final StoredType[] codeParameters = new StoredType[actualTypeArguments.length];
+                for(int i = 0; i < actualTypeArguments.length; i++) {
+                    codeParameters[i] = loadType(context, actualTypeArguments[i], false, false);
+                }
+            
+                if(rawType == Map.class) {
+                    storedType = registry.getAssociative(codeParameters[0], codeParameters[1]).stored();
+                } else {
+                    HighLevelDefinition definition = addClass((Class<?>) rawType);
+                    storedType = registry.getForDefinition(definition, codeParameters).stored();
+                }
+            } else {
+		        storedType = loadType(context, (AnnotatedElement) ((AnnotatedType) type).getType(), unsigned);
+            }
+            
+		    if(type.isAnnotationPresent(ZenCodeStorageTag.class)) {
+		        //Replace with switch if more StorageTagTypes are added
+                if(type.getAnnotation(ZenCodeStorageTag.class).value() == StorageTagType.STATIC) {
+                    return storedType.type.stored(StorageTag.union(CodePosition.BUILTIN, storedType.getSpecifiedStorage(), StaticStorageTag.INSTANCE));
+                }
+            }
+		    return storedType;
+		    
+        } else {
 			throw new IllegalArgumentException("Could not analyze type: " + type);
 		}
 	}
 	
-	private StoredType loadFunctionalInterface(TypeVariableContext loadContext, Class<?> cls, Type[] parameters) {
+	private StoredType loadFunctionalInterface(TypeVariableContext loadContext, Class<?> cls, AnnotatedElement[] parameters) {
 		Method functionalInterfaceMethod = getFunctionalInterfaceMethod(cls);
 		TypeVariableContext context = convertTypeParameters(cls);
 		FunctionHeader header = getHeader(context, functionalInterfaceMethod);

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionArray.java

 
 package org.openzen.zenscript.parser.expression;
 
+import java.util.ArrayList;
 import java.util.List;
+import java.util.function.BiFunction;
+
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
  * @author Stanneke
  */
 public class ParsedExpressionArray extends ParsedExpression {
-	private final List<ParsedExpression> contents;
+    
+    public static final List<BiFunction<ParsedExpressionArray, ExpressionScope, IPartialExpression>> compileOverrides = new ArrayList<>(0);
+    public final List<ParsedExpression> contents;
 
 	public ParsedExpressionArray(CodePosition position, List<ParsedExpression> contents) {
 		super(position);
 
 	@Override
 	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
+        
+        for(BiFunction<ParsedExpressionArray, ExpressionScope, IPartialExpression> compileOverride : compileOverrides) {
+            final IPartialExpression apply = compileOverride.apply(this, scope);
+            if(apply != null)
+                return apply;
+        }
+        
 		StoredType asBaseType = null;
 		StoredType asType = null;
 		boolean couldHintType = false;

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionMap.java

 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
  * @author Stanneke
  */
 public class ParsedExpressionMap extends ParsedExpression {
-	private final List<ParsedExpression> keys;
-	private final List<ParsedExpression> values;
+    
+    public static final List<BiFunction<ParsedExpressionMap, ExpressionScope, ? extends IPartialExpression>> compileOverrides = new ArrayList<>(0);
+    
+	public final List<ParsedExpression> keys;
+	public final List<ParsedExpression> values;
 
 	public ParsedExpressionMap(
 			CodePosition position,
 
 	@Override
 	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
+        for(BiFunction<ParsedExpressionMap, ExpressionScope, ? extends IPartialExpression> compileOverride : compileOverrides) {
+            final IPartialExpression apply = compileOverride.apply(this, scope);
+            if(apply != null)
+                return apply;
+        }
+	    
 		StoredType usedHint = null;
 		List<StoredType> keyHints = new ArrayList<>();
 		List<StoredType> valueHints = new ArrayList<>();

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedStorageTag.java

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
-import org.openzen.zenscript.lexer.ParseException;
-import org.openzen.zenscript.lexer.ZSTokenParser;
-import org.openzen.zenscript.lexer.ZSTokenType;
+import org.openzen.zenscript.lexer.*;
 
 /**
  *
 		if (parser.optional(ZSTokenType.T_BACKTICK) == null)
 			return NULL;
 		
-		String name = parser.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
+		ZSToken token = parser.optional(ZSTokenType.K_STATIC);
+		String name = token != null ? token.content : parser.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		List<String> arguments = new ArrayList<>();
 		while (parser.optional(ZSTokenType.T_COLON) != null)
 			arguments.add(parser.next().content);

Validator/src/main/java/org/openzen/zenscript/validator/visitors/ExpressionValidator.java

 				validator.logError(
 					ValidationLogEntry.Code.INVALID_OPERAND_TYPE,
 					expression.position,
-					"array element expression type doesn't match array type");
+					"array element expression type " + element.type + " doesn't match array type " + expression.arrayType.elementType);
 			}
 			element.accept(this);
 		}
 			key.accept(this);
 			value.accept(this);
 			if (!key.type.equals(type.keyType)) {
-				validator.logError(ValidationLogEntry.Code.INVALID_OPERAND_TYPE, key.position, "Key type must match the associative array key type");
+				validator.logError(ValidationLogEntry.Code.INVALID_OPERAND_TYPE, key.position, "Key type " + key.type + " must match the associative array key type " + type.keyType);
 			}
 			if (!value.type.equals(type.valueType)) {
-				validator.logError(ValidationLogEntry.Code.INVALID_OPERAND_TYPE, key.position, "Value type must match the associative array value type");
+				validator.logError(ValidationLogEntry.Code.INVALID_OPERAND_TYPE, key.position, "Value type " + value.type + " must match the associative array value type " + type.valueType);
 			}
 		}
 		return null;