[WIP, I have no idea what I'm doing]Get types declared in StdLibs from the registry

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/NativeDefinitionAnnotation.java

 	public void serialize(CodeSerializationOutput output, HighLevelDefinition definition, TypeContext context) {
 		output.writeString(identifier);
 	}
+
+	public String getIdentifier() {
+		return identifier;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/GlobalTypeRegistry.java

  */
 package org.openzen.zenscript.codemodel.type;
 
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 			return id;
 		}
 	}
+
+	public Collection<DefinitionTypeID> getDefinitions() {
+		return definitionTypes.keySet();
+	}
 }

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

 import org.openzen.zencode.shared.LiteralSourceFile;
 import org.openzen.zenscript.codemodel.*;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
+import org.openzen.zenscript.codemodel.annotations.DefinitionAnnotation;
+import org.openzen.zenscript.codemodel.annotations.NativeDefinitionAnnotation;
 import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.FileResolutionContext;
 import org.openzen.zenscript.codemodel.context.ModuleTypeResolutionContext;
-import org.openzen.zenscript.codemodel.definition.ClassDefinition;
-import org.openzen.zenscript.codemodel.definition.EnumDefinition;
-import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
-import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
-import org.openzen.zenscript.codemodel.definition.StructDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantDoubleExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantFloatExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantLongExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantSByteExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantShortExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
-import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.ExpressionSymbol;
-import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
-import org.openzen.zenscript.codemodel.expression.StorageCastExpression;
+import org.openzen.zenscript.codemodel.definition.*;
+import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.member.CasterMember;
-import org.openzen.zenscript.codemodel.member.ConstructorMember;
-import org.openzen.zenscript.codemodel.member.FieldMember;
-import org.openzen.zenscript.codemodel.member.GetterMember;
-import org.openzen.zenscript.codemodel.member.ImplementationMember;
-import org.openzen.zenscript.codemodel.member.MethodMember;
-import org.openzen.zenscript.codemodel.member.OperatorMember;
-import org.openzen.zenscript.codemodel.member.SetterMember;
+import org.openzen.zenscript.codemodel.member.*;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.partial.PartialStaticMemberGroupExpression;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 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.*;
+import org.openzen.zenscript.lexer.ParseException;
+import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.parser.BracketExpressionParser;
 import org.openzen.zenscript.parser.expression.ParsedExpression;
 import org.openzen.zenscript.parser.type.IParsedType;
 	private final GlobalTypeRegistry registry;
 	private final PackageDefinitions definitions = new PackageDefinitions();
 	private final JavaCompiledModule compiled;
-	
+
 	private final Map<Class<?>, HighLevelDefinition> definitionByClass = new HashMap<>();
 	private final Map<Class<?>, TypeID> typeByClass = new HashMap<>();
 	private final Map<Class<?>, TypeID> unsignedByClass = new HashMap<>();
 	private final TypeVariableContext context = new TypeVariableContext();
-	
+
 	public final Map<String, ISymbol> globals = new HashMap<>();
 	private BracketExpressionParser bep;
 
 		this.basePackage = basePackage;
 		module = new Module(name);
 		this.registry = registry;
-		
+
 		for (JavaNativeModule dependency : dependencies) {
 			definitionByClass.putAll(dependency.definitionByClass);
 		}
-		
+
 		compiled = new JavaCompiledModule(module, FunctionParameter.NONE);
-		
+
 		typeByClass.put(void.class, BasicTypeID.VOID);
 		typeByClass.put(boolean.class, BasicTypeID.BOOL);
 		typeByClass.put(byte.class, BasicTypeID.SBYTE);
 		typeByClass.put(Long.class, registry.getOptional(BasicTypeID.LONG));
 		typeByClass.put(Float.class, registry.getOptional(BasicTypeID.FLOAT));
 		typeByClass.put(Double.class, registry.getOptional(BasicTypeID.DOUBLE));
-		
+
 		unsignedByClass.put(byte.class, BasicTypeID.BYTE);
 		unsignedByClass.put(short.class, BasicTypeID.USHORT);
 		unsignedByClass.put(int.class, BasicTypeID.UINT);
 		unsignedByClass.put(Integer.class, registry.getOptional(BasicTypeID.INT));
 		unsignedByClass.put(Long.class, registry.getOptional(BasicTypeID.LONG));
 	}
-	
+
 	public SemanticModule toSemantic(ModuleSpace space) {
 		return new SemanticModule(
 				module,
 				space.getAnnotations(),
 				space.getStorageTypes());
 	}
-	
+
 	public JavaCompiledModule getCompiled() {
 		return compiled;
 	}
-	
+
 	public HighLevelDefinition addClass(Class<?> cls) {
-		if (definitionByClass.containsKey(cls))
+		if (definitionByClass.containsKey(cls)) {
 			return definitionByClass.get(cls);
-        
+		}
         return convertClass(cls);
 	}
-	
+
 	public void addGlobals(Class<?> cls) {
 		HighLevelDefinition definition = new ClassDefinition(CodePosition.NATIVE, module, pkg, "__globals__", Modifiers.PUBLIC);
 		JavaClass jcls = JavaClass.fromInternalName(getInternalName(cls), JavaClass.Kind.CLASS);
 		compiled.setClassInfo(definition, jcls);
 		StoredType thisType = registry.getForMyDefinition(definition).stored();
 		//TypeVariableContext context = new TypeVariableContext();
-		
+
 		for (Field field : cls.getDeclaredFields()) {
 			if (!field.isAnnotationPresent(ZenCodeGlobals.Global.class))
 				continue;
 			if (!isStatic(field.getModifiers()))
 				continue;
-			
+
 			ZenCodeGlobals.Global global = field.getAnnotation(ZenCodeGlobals.Global.class);
 			StoredType type = loadStoredType(context, field.getAnnotatedType());
 			String name = global.value().isEmpty() ? field.getName() : global.value();
 			compiled.setFieldInfo(fieldMember.autoGetter, javaField);
 			globals.put(name, new ExpressionSymbol((position, scope) -> new StaticGetterExpression(CodePosition.BUILTIN, fieldMember.autoGetter.ref(thisType, GenericMapper.EMPTY))));
 		}
-		
+
 		for (Method method : cls.getDeclaredMethods()) {
 			if (!method.isAnnotationPresent(ZenCodeGlobals.Global.class))
 				continue;
 			if (!isStatic(method.getModifiers()))
 				continue;
-			
+
 			ZenCodeGlobals.Global global = method.getAnnotation(ZenCodeGlobals.Global.class);
 			String name = global.value().isEmpty() ? method.getName() : global.value();
 			MethodMember methodMember = new MethodMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC | Modifiers.STATIC, name, getHeader(context, method), null);
 			definition.addMember(methodMember);
-			
+
 			boolean isGenericResult = methodMember.header.getReturnType().isGeneric();
 			compiled.setMethodInfo(methodMember, new JavaMethod(jcls, JavaMethod.Kind.STATIC, method.getName(), false, getMethodDescriptor(method), method.getModifiers(), isGenericResult));
 			globals.put(name, new ExpressionSymbol((position, scope) -> {
 			}));
 		}
 	}
-	
+
 	public FunctionalMemberRef loadStaticMethod(Method method) {
 		if (!isStatic(method.getModifiers()))
 			throw new IllegalArgumentException("Method \"" + method.toString() + "\" is not static");
-		
+
 		HighLevelDefinition definition = addClass(method.getDeclaringClass());
 		JavaClass jcls = JavaClass.fromInternalName(getInternalName(method.getDeclaringClass()), JavaClass.Kind.CLASS);
-		
+
 		//TypeVariableContext context = new TypeVariableContext();
 		MethodMember methodMember = new MethodMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC | Modifiers.STATIC, method.getName(), getHeader(context, method), null);
 		definition.addMember(methodMember);
 	private boolean isInBasePackage(String className) {
 		return className.startsWith(basePackage + ".");
 	}
-	
+
 	private ZSPackage getPackage(String className) {
 		//TODO validate
 		if(this.basePackage == null || this.basePackage.isEmpty())
 		//TODO make a lang package?
 		if (!className.contains(".") || className.startsWith("java.lang"))
 			return pkg;
-		
+
 		if (className.startsWith("."))
 			className = className.substring(1);
 		else if (className.startsWith(basePackage + "."))
 			className = className.substring(basePackage.length() + 1);
 		else
             throw new IllegalArgumentException("Invalid class name: \"" + className + "\" not in the given base package: \"" + basePackage + "\"");
-		
+
 		String[] classNameParts = Strings.split(className, '.');
 		ZSPackage classPkg = pkg;
 		for (int i = 0; i < classNameParts.length - 1; i++)
 			classPkg = classPkg.getOrCreatePackage(classNameParts[i]);
-		
+
 		return classPkg;
 	}
-	
+
+	private <T> HighLevelDefinition checkRegistry(Class<T> cls) {
+		String name = cls.getCanonicalName();
+		if (!name.startsWith("java.lang.") && !name.startsWith("java.util.")) {
+			return null;
+		}
+
+		name = name.substring("java.lang.".length());
+		for (DefinitionTypeID definition : registry.getDefinitions()) {
+			final HighLevelDefinition highLevelDefinition = definition.definition;
+			for (DefinitionAnnotation annotation : highLevelDefinition.annotations) {
+				if (annotation instanceof NativeDefinitionAnnotation) {
+					final String identifier = ((NativeDefinitionAnnotation) annotation).getIdentifier();
+					if (identifier.equals(name) || identifier.equals("stdlib::" + name)) {
+						return highLevelDefinition;
+					}
+				}
+			}
+		}
+
+		return null;
+	}
+
 	private <T> HighLevelDefinition convertClass(Class<T> cls) {
 		if ((cls.getModifiers() & Modifier.PUBLIC) == 0)
 			throw new IllegalArgumentException("Class \" " + cls.getName() + "\" must be public");
 
 		String className = cls.getName();
         boolean isStruct = cls.isAnnotationPresent(ZenCodeType.Struct.class);
-        
-        ZSPackage classPkg;
-        ZenCodeType.Name nameAnnotation = cls.getDeclaredAnnotation(ZenCodeType.Name.class);
-		className = className.contains(".") ? className.substring(className.lastIndexOf('.') + 1) : className;
-        if (nameAnnotation == null) {
-            classPkg = getPackage(className);
-        } else {
-            String specifiedName = nameAnnotation.value();
-			if (specifiedName.startsWith(".")) {
-				classPkg = getPackage(specifiedName);
-				className = specifiedName.substring(specifiedName.lastIndexOf('.') + 1);
-			} else if (specifiedName.indexOf('.') >= 0) {
-				if (!specifiedName.startsWith(pkg.fullName))
-					throw new IllegalArgumentException("Specified @Name as \"" + specifiedName + "\" for class: \"" + cls.toString() + "\" but it's not in the module root package");
-
-				classPkg = getPackage(basePackage + specifiedName.substring(pkg.fullName.length()));
-				className = specifiedName.substring(specifiedName.lastIndexOf('.') + 1);
-			} else {
-                classPkg = getPackage(specifiedName);
-                className = nameAnnotation.value();
-			}
-		}
-
 
-		
-		HighLevelDefinition definition;
+		HighLevelDefinition definition = checkRegistry(cls);
+		final boolean foundRegistry = definition != null;
 		String internalName = getInternalName(cls);
 		JavaClass javaClass;
-		if (cls.isInterface()) {
-			definition = new InterfaceDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC, null);
-			javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.INTERFACE);
-		} else if (cls.isEnum()) {
-			definition = new EnumDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC, null);
-			javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.ENUM);
-		} else if (isStruct) {
-			definition = new StructDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC, null);
-			javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.CLASS);
+
+		if (foundRegistry) {
+			javaClass = JavaClass.fromInternalName(internalName, definition.isInterface() ? JavaClass.Kind.INTERFACE : JavaClass.Kind.CLASS);
 		} else {
-			definition = new ClassDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC);
-			javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.CLASS);
+			ZSPackage classPkg;
+			ZenCodeType.Name nameAnnotation = cls.getDeclaredAnnotation(ZenCodeType.Name.class);
+			className = className.contains(".") ? className.substring(className.lastIndexOf('.') + 1) : className;
+			if (nameAnnotation == null) {
+				classPkg = getPackage(className);
+			} else {
+				String specifiedName = nameAnnotation.value();
+				if (specifiedName.startsWith(".")) {
+					classPkg = getPackage(specifiedName);
+					className = specifiedName.substring(specifiedName.lastIndexOf('.') + 1);
+				} else if (specifiedName.indexOf('.') >= 0) {
+					if (!specifiedName.startsWith(pkg.fullName))
+						throw new IllegalArgumentException("Specified @Name as \"" + specifiedName + "\" for class: \"" + cls
+								.toString() + "\" but it's not in the module root package");
+
+					classPkg = getPackage(basePackage + specifiedName.substring(pkg.fullName.length()));
+					className = specifiedName.substring(specifiedName.lastIndexOf('.') + 1);
+				} else {
+					classPkg = getPackage(specifiedName);
+					className = nameAnnotation.value();
+				}
+			}
+
+
+			if (cls.isInterface()) {
+				definition = new InterfaceDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC, null);
+				javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.INTERFACE);
+			} else if (cls.isEnum()) {
+				definition = new EnumDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC, null);
+				javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.ENUM);
+			} else if (isStruct) {
+				definition = new StructDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC, null);
+				javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.CLASS);
+			} else {
+				definition = new ClassDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC);
+				javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.CLASS);
 
+			}
 		}
 
 		//Moved up here so that circular dependencies are caught (hopefully)
 			typeParameters[i] = parameter;
 		}
 
-		if (definition instanceof ClassDefinition && cls.getAnnotatedSuperclass() != null && shouldLoadType(cls.getAnnotatedSuperclass().getType())) {
+		if (!foundRegistry && definition instanceof ClassDefinition && cls.getAnnotatedSuperclass() != null && shouldLoadType(cls.getAnnotatedSuperclass().getType())) {
 			definition.setSuperType(loadType(context, cls.getAnnotatedSuperclass()).type);
 		}
 
-		if (definition.getSuperType() == null && cls != Object.class) {
+		if (!foundRegistry && definition.getSuperType() == null && cls != Object.class) {
 			definition.setSuperType(loadType(context, Object.class, false, false).type);
 		}
 
 		}
 
 		compiled.setClassInfo(definition, javaClass);
-		
+
 		StoredType thisType = new StoredType(registry.getForMyDefinition(definition), AutoStorageTag.INSTANCE);
 		for (Field field : cls.getDeclaredFields()) {
 			ZenCodeType.Field annotation = field.getAnnotation(ZenCodeType.Field.class);
 				continue;
 			if (!isPublic(field.getModifiers()))
 				continue;
-			
+
 			final String fieldName = annotation.value().isEmpty() ? field.getName() : annotation.value();
-			
+
 			StoredType fieldType = loadStoredType(context, field.getAnnotatedType());
 			FieldMember member = new FieldMember(CodePosition.NATIVE, definition, getMethodModifiers(field), fieldName, thisType, fieldType, registry, 0, 0, null);
 			definition.addMember(member);
 			compiled.setFieldInfo(member, new JavaField(javaClass, field.getName(), getDescriptor(field.getType())));
 		}
-		
+
 		boolean hasConstructor = false;
 		for (java.lang.reflect.Constructor<?> constructor : cls.getConstructors()) {
 			ZenCodeType.Constructor constructorAnnotation = (ZenCodeType.Constructor) constructor.getAnnotation(ZenCodeType.Constructor.class);
 				hasConstructor = true;
 			}
 		}
-		
-		if (!hasConstructor) {
+
+		if (!hasConstructor && !foundRegistry) {
 			// no constructor! make a private constructor so the compiler doesn't add one
 			ConstructorMember member = new ConstructorMember(CodePosition.BUILTIN, definition, Modifiers.PRIVATE, new FunctionHeader(BasicTypeID.VOID), BuiltinID.CLASS_DEFAULT_CONSTRUCTOR);
 			definition.addMember(member);
 		}
-		
+
 		for (Method method : cls.getDeclaredMethods()) {
 			ZenCodeType.Method methodAnnotation = method.getAnnotation(ZenCodeType.Method.class);
 			if (methodAnnotation != null) {
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.header.getReturnType()));
 				continue;
 			}
-			
+
 			ZenCodeType.Getter getter = method.getAnnotation(ZenCodeType.Getter.class);
 			if (getter != null) {
 				GetterMember member = asGetter(context, definition, method, getter);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.getType()));
 			}
-			
+
 			ZenCodeType.Setter setter = method.getAnnotation(ZenCodeType.Setter.class);
 			if (setter != null) {
 				SetterMember member = asSetter(context, definition, method, setter);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, BasicTypeID.VOID.stored));
 			}
-			
+
 			ZenCodeType.Operator operator = method.getAnnotation(ZenCodeType.Operator.class);
 			if (operator != null) {
 				OperatorMember member = asOperator(context, definition, method, operator);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.header.getReturnType()));
 			}
-			
+
 			ZenCodeType.Caster caster = method.getAnnotation(ZenCodeType.Caster.class);
 			if (caster != null) {
 				CasterMember member = asCaster(context, definition, method, caster);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.toType));
 			}
-			
+
 			/*if (!annotated) {
 				MethodMember member = asMethod(definition, method, null);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.header.getReturnType()));
 			}*/
 		}
-		
+
 		return definition;
 	}
 
 		return null;
 	}
 
-	
+
 	private boolean shouldLoadType(Type type) {
 		if (type instanceof Class)
 			return definitionByClass.containsKey(type) || shouldLoadClass((Class<?>)type);
 		if (type instanceof ParameterizedType)
 			return shouldLoadType(((ParameterizedType)type).getRawType());
-		
+
 		return false;
 	}
-	
+
 	private String getClassName(Class<?> cls) {
 	    return cls.isAnnotationPresent(ZenCodeType.Name.class) ? cls.getAnnotation(ZenCodeType.Name.class).value() : cls.getName();
     }
 	private boolean shouldLoadClass(Class<?> cls) {
 	    return isInBasePackage(getClassName(cls));
     }
-	
+
 	private boolean isGetterName(String name) {
 		return name.startsWith("get") || name.startsWith("is") || name.startsWith("has");
 	}
-	
+
 	private String translateGetterName(String name) {
 		if (name.startsWith("get"))
 			return name.substring(3, 4).toLowerCase() + name.substring(4);
-		
+
 		return name;
 	}
-	
+
 	private String translateSetterName(String name) {
 		if (name.startsWith("set"))
 			return name.substring(3, 4).toLowerCase() + name.substring(4);
-		
+
 		return name;
 	}
-	
+
 	private ConstructorMember asConstructor(TypeVariableContext context, HighLevelDefinition definition, java.lang.reflect.Constructor method) {
 		FunctionHeader header = getHeader(context, method);
 		return new ConstructorMember(
 				header,
 				null);
 	}
-	
+
 	private MethodMember asMethod(TypeVariableContext context, HighLevelDefinition definition, Method method, ZenCodeType.Method annotation) {
 		String name = annotation != null && !annotation.value().isEmpty() ? annotation.value() : method.getName();
 		FunctionHeader header = getHeader(context, method);
 				header,
 				null);
 	}
-	
+
 	private OperatorMember asOperator(TypeVariableContext context, HighLevelDefinition definition, Method method, ZenCodeType.Operator annotation) {
 		FunctionHeader header = getHeader(context, method);
 		if (isStatic(method.getModifiers()))
 			throw new IllegalArgumentException("operator method \"" + method.toString() + "\"cannot be static");
-		
+
 		// TODO: check number of parameters
 		//if (header.parameters.length != annotation.value().parameters)
-		
+
 		return new OperatorMember(
 				CodePosition.NATIVE,
 				definition,
 				header,
 				null);
 	}
-	
+
 	private GetterMember asGetter(TypeVariableContext context, HighLevelDefinition definition, Method method, ZenCodeType.Getter annotation) {
 		StoredType type = loadStoredType(context, method.getAnnotatedReturnType());
 		String name = null;
 			name = annotation.value();
 		if (name == null)
 			name = translateGetterName(method.getName());
-		
+
 		return new GetterMember(CodePosition.NATIVE, definition, getMethodModifiers(method), name, type, null);
 	}
-	
+
 	private SetterMember asSetter(TypeVariableContext context, HighLevelDefinition definition, Method method, ZenCodeType.Setter annotation) {
 		if (method.getParameterCount() != 1)
 			throw new IllegalArgumentException("Illegal setter: \"" + method.toString() + "\"must have exactly 1 parameter");
-		
+
 		StoredType type = loadStoredType(context, method.getAnnotatedParameterTypes()[0]);
 		String name = null;
 		if (annotation != null && !annotation.value().isEmpty())
 			name = annotation.value();
 		if (name == null)
 			name = translateSetterName(method.getName());
-		
+
 		return new SetterMember(CodePosition.NATIVE, definition, getMethodModifiers(method), name, type, null);
 	}
-	
+
 	private CasterMember asCaster(TypeVariableContext context, HighLevelDefinition definition, Method method, ZenCodeType.Caster annotation) {
 		boolean implicit = annotation != null && annotation.implicit();
 		int modifiers = Modifiers.PUBLIC;
 		if (implicit)
 			modifiers |= Modifiers.IMPLICIT;
-		
+
 		StoredType toType = loadStoredType(context, method.getAnnotatedReturnType());
 		return new CasterMember(CodePosition.NATIVE, definition, modifiers, toType, null);
 	}
-	
+
 	private FunctionHeader getHeader(TypeVariableContext context, java.lang.reflect.Constructor constructor) {
 		return getHeader(
 				context,
 				constructor.getTypeParameters(),
 				constructor.getAnnotatedExceptionTypes());
 	}
-	
+
 	private FunctionHeader getHeader(TypeVariableContext context, Method method) {
 		return getHeader(
 				context,
 				method.getTypeParameters(),
 				method.getAnnotatedExceptionTypes());
 	}
-	
+
 	protected Expression getDefaultValue(Parameter parameter, StoredType type) {
 		if (parameter.isAnnotationPresent(ZenCodeType.Optional.class)) {
 				final String s = parameter.getAnnotation(ZenCodeType.Optional.class).value();
 			TypeVariable<Method>[] javaTypeParameters,
 			AnnotatedType[] exceptionTypes) {
 		StoredType returnType = javaReturnType == null ? BasicTypeID.VOID.stored : loadStoredType(context, javaReturnType);
-		
+
 
 		TypeParameter[] typeParameters = new TypeParameter[javaTypeParameters.length];
 		for (int i = 0; i < javaTypeParameters.length; i++) {
 
 		for (int i = 0; i < javaTypeParameters.length; i++) {
 			TypeVariable<Method> javaTypeParameter = javaTypeParameters[i];
-			
+
 			for (AnnotatedType bound : javaTypeParameter.getAnnotatedBounds())
 				typeParameters[i].addBound(new ParameterTypeBound(CodePosition.NATIVE, loadType(context, bound).type));
 		}
 			Expression defaultValue = getDefaultValue(parameter, type);
 			parameters[i] = new FunctionParameter(type, parameter.getName(), defaultValue, parameter.isVarArgs());
 		}
-		
+
 		if (exceptionTypes.length > 1)
 			throw new IllegalArgumentException("A method can only throw a single exception type!");
-		
+
 		StoredType thrownType = exceptionTypes.length == 0 ? null : loadStoredType(context, exceptionTypes[0]);
 		return new FunctionHeader(typeParameters, returnType, thrownType, AutoStorageTag.INSTANCE, parameters);
 	}
-	
+
 	private StoredType loadStoredType(TypeVariableContext context, AnnotatedType annotatedType) {
 		return loadType(context, annotatedType);
 	}
 			return new StoredType(registry.getOptional(type.type), type.getSpecifiedStorage());
 		return type;
 	}
-	
+
 	private StoredType loadType(TypeVariableContext context, AnnotatedType annotatedType) {
 		if (annotatedType.isAnnotationPresent(ZenCodeType.USize.class))
 			return BasicTypeID.USIZE.stored;
 		else if (annotatedType.isAnnotationPresent(ZenCodeType.NullableUSize.class))
 			return registry.getOptional(BasicTypeID.USIZE).stored();
-		
+
 		boolean nullable = annotatedType.isAnnotationPresent(ZenCodeType.Nullable.class);
 		boolean unsigned = annotatedType.isAnnotationPresent(ZenCodeType.Unsigned.class);
-		
+
 		return loadType(context, annotatedType, nullable, 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;
 	}
-	
+
 	@SuppressWarnings("ChainOfInstanceofChecks")
     private StoredType loadType(TypeVariableContext context, AnnotatedElement type, boolean unsigned) {
 		if (type instanceof Class) {
 			} else if (classType.isAnnotationPresent(FunctionalInterface.class)) {
 				return loadFunctionalInterface(context, classType, new AnnotatedElement[0]);
 			}
-			
+
 			if (typeByClass.containsKey(classType))
 				return typeByClass.get(classType).stored();
-			
+
 			HighLevelDefinition definition = addClass(classType);
 			final List<StoredType> s = new ArrayList<>();
 			for (TypeVariable<? extends Class<?>> typeParameter : classType.getTypeParameters()) {
 			Class<?> rawType = (Class<?>) parameterizedType.getRawType();
 			if (rawType.isAnnotationPresent(FunctionalInterface.class))
 				return loadFunctionalInterface(context, rawType, (AnnotatedElement[]) parameterizedType.getActualTypeArguments());
-			
+
 			Type[] parameters = parameterizedType.getActualTypeArguments();
 			StoredType[] codeParameters = new StoredType[parameters.length];
 			for (int i = 0; i < parameters.length; i++)
 			    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<?>) {
                 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 if(rawType instanceof Class<?>){
 					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;
-		    
+
         } else {
 			throw new IllegalArgumentException("Could not analyze type: " + type);
 		}
 	}
-	
+
 	private StoredType loadFunctionalInterface(TypeVariableContext loadContext, Class<?> cls, AnnotatedElement[] parameters) {
 		Method functionalInterfaceMethod = getFunctionalInterfaceMethod(cls);
 		TypeVariableContext context = convertTypeParameters(cls);
 		FunctionHeader header = getHeader(context, functionalInterfaceMethod);
-		
+
 		Map<TypeParameter, StoredType> mapping = new HashMap<>();
 		TypeVariable[] javaParameters = cls.getTypeParameters();
 		for (int i = 0; i < parameters.length; i++)
 			mapping.put(context.get(javaParameters[i]), loadType(loadContext, parameters[i], false, false));
-		
+
 		JavaMethod method = new JavaMethod(
 				JavaClass.fromInternalName(getInternalName(cls), JavaClass.Kind.INTERFACE),
 				JavaMethod.Kind.INTERFACE,
 		StorageTag tag = new JavaFunctionalInterfaceStorageTag(functionalInterfaceMethod, method);
 		return registry.getFunction(header).stored(tag);
 	}
-	
+
 	private <T> TypeVariableContext convertTypeParameters(Class<T> cls) {
 		//TypeVariableContext context = new TypeVariableContext();
 		TypeVariable<Class<T>>[] javaTypeParameters = cls.getTypeParameters();
 		}
 		return context;
 	}
-	
+
 	private Method getFunctionalInterfaceMethod(Class<?> functionalInterface) {
 		for (Method method : functionalInterface.getDeclaredMethods()) {
 			if (!method.isDefault())
 				return method;
 		}
-		
+
 		return null;
 	}
-	
+
 	private int getMethodModifiers(Member method) {
 		int result = Modifiers.PUBLIC;
 		if (isStatic(method.getModifiers()))
 			result |= Modifiers.STATIC;
 		if (isFinal(method.getModifiers()))
 			result |= Modifiers.FINAL;
-		
+
 		return result;
 	}
-	
+
 	private static boolean isPublic(int modifiers) {
 		return (modifiers & Modifier.PUBLIC) > 0;
 	}
-	
+
 	private static boolean isStatic(int modifiers) {
 		return (modifiers & Modifier.STATIC) > 0;
 	}
-	
+
 	private static boolean isFinal(int modifiers) {
 		return (modifiers & Modifier.FINAL) > 0;
 	}
-	
+
 	private static String getInternalName(Class<?> cls) {
 		return org.objectweb.asm.Type.getInternalName(cls);
 	}
-	
+
 	private static String getDescriptor(Class<?> cls) {
 		return org.objectweb.asm.Type.getDescriptor(cls);
 	}
-	
+
 	private static String getMethodDescriptor(java.lang.reflect.Constructor constructor) {
 		return org.objectweb.asm.Type.getConstructorDescriptor(constructor);
 	}
-	
+
 	private static String getMethodDescriptor(Method method) {
 		return org.objectweb.asm.Type.getMethodDescriptor(method);
 	}
-	
+
 	private static JavaMethod getMethod(JavaClass cls, java.lang.reflect.Constructor constructor) {
 		return new JavaMethod(
 				cls,
 				constructor.getModifiers(),
 				false);
 	}
-	
+
 	private static JavaMethod getMethod(JavaClass cls, Method method, StoredType result) {
 		JavaMethod.Kind kind;
 		if (method.getName().equals("<init>"))
 			kind = JavaMethod.Kind.STATIC;
 		else
 			kind = JavaMethod.Kind.INSTANCE;
-		
+
 		return new JavaMethod(cls, kind, method.getName(), false, getMethodDescriptor(method), method.getModifiers(), result.isGeneric());
 	}
 
 
 	private static class TypeVariableContext {
 		private final Map<TypeVariable, TypeParameter> typeVariables = new HashMap<>();
-		
+
 		public void put(TypeVariable variable, TypeParameter parameter) {
 			typeVariables.put(variable, parameter);
 		}
-		
+
 		public TypeParameter get(TypeVariable variable) {
 			if (!typeVariables.containsKey(variable))
 				throw new IllegalStateException("Could not find type variable " + variable.getName());
-			
+
 			return typeVariables.get(variable);
 		}
 	}