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

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

 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Modifier;
-import java.util.*;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Objects;
+import java.util.StringJoiner;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void>, JavaNativeTranslator<Void> {
 	private static final JavaMethod BOOLEAN_PARSE = JavaMethod.getNativeStatic(JavaClass.BOOLEAN, "parseBoolean", "(Ljava/lang/String;)Z");
 		BuiltinID builtin = expression.member.getBuiltin();
 		if (builtin == null) {
 			expression.target.accept(this);
-			
+
 			JavaMethod methodInfo = context.getJavaMethod(expression.member);
 			for (int i = 0; i < expression.arguments.typeArguments.length; i++) {
 				if (methodInfo.typeParameterArguments[i]) {
 					StoredType arguments = expression.arguments.typeArguments[i];
-					
+
 				}
 			}
 			for (Expression argument : expression.arguments.arguments) {
 			getJavaWriter().invokeInterface(methodInfo);
 		} else if (methodInfo.kind == JavaMethod.Kind.COMPILED) {
 			Objects.requireNonNull(methodInfo.translation).translate(expression, this);
+		} else if (methodInfo.cls.kind == JavaClass.Kind.INTERFACE) {
+			getJavaWriter().invokeInterface(methodInfo);
 		} else {
 			getJavaWriter().invokeVirtual(methodInfo);
 		}

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

 import stdlib.Strings;
 
 /**
- *
  * @author Stan Hebben
  */
 public class JavaNativeModule {
 			String name,
 			String basePackage,
 			GlobalTypeRegistry registry,
-			JavaNativeModule[] dependencies)
-	{
+			JavaNativeModule[] dependencies) {
 		this.pkg = pkg;
 		this.basePackage = basePackage;
 		module = new Module(name);
 	}
 	
 	private ZSPackage getPackage(String className) {
-		if (!className.contains("."))
+		//TODO make a lang package?
+		if (!className.contains(".") || className.startsWith("java.lang"))
 			return pkg;
 		
 		if (className.startsWith("."))
 				continue;
 			if (!isPublic(field.getModifiers()))
 				continue;
-
-			String fieldName = field.getName();
-			if (annotation != null && !annotation.value().isEmpty())
-				fieldName = annotation.value();
+			
+			final String fieldName = annotation.value().isEmpty() ? field.getName() : annotation.value();
 			
 			StoredType fieldType = loadStoredType(field.getAnnotatedType());
 			FieldMember member = new FieldMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC, fieldName, thisType, fieldType, registry, 0, 0, null);
 		
 		boolean hasConstructor = false;
 		for (java.lang.reflect.Constructor constructor : cls.getConstructors()) {
-			ZenCodeType.Constructor constructorAnnotation = (ZenCodeType.Constructor)constructor.getAnnotation(ZenCodeType.Constructor.class);
+			ZenCodeType.Constructor constructorAnnotation = (ZenCodeType.Constructor) constructor.getAnnotation(ZenCodeType.Constructor.class);
 			if (constructorAnnotation != null) {
 				ConstructorMember member = asConstructor(definition, constructor);
 				definition.addMember(member);
 			AnnotatedType javaReturnType,
 			AnnotatedType[] parameterTypes,
 			TypeVariable<Method>[] javaTypeParameters,
-			AnnotatedType[] exceptionTypes)
-	{
+			AnnotatedType[] exceptionTypes) {
 		StoredType returnType = javaReturnType == null ? BasicTypeID.VOID.stored : loadStoredType(javaReturnType);
 		
 		FunctionParameter[] parameters = new FunctionParameter[parameterTypes.length];
 	
 	private TypeID loadType(Type type, boolean nullable, boolean unsigned) {
 		if (type instanceof Class) {
-			Class<?> classType = (Class<?>)type;
+			Class<?> classType = (Class<?>) type;
 			if (unsigned) {
 				if (unsignedByClass.containsKey(classType))
 					return unsignedByClass.get(classType);
 			HighLevelDefinition definition = addClass(classType);
 			return registry.getForDefinition(definition);
 		} else if (type instanceof ParameterizedType) {
-			ParameterizedType parameterizedType = (ParameterizedType)type;
-			Class<?> rawType = (Class)parameterizedType.getRawType();
+			ParameterizedType parameterizedType = (ParameterizedType) type;
+			Class<?> rawType = (Class) parameterizedType.getRawType();
 			
 			HighLevelDefinition definition = addClass(rawType);
 			Type[] parameters = parameterizedType.getActualTypeArguments();