- Continued implementation of interfaces in the bytecode compiler.

- Added support to have a native method both as operator and named method

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

 
 		if (methodInfo.kind == JavaMethod.Kind.STATIC) {
 			getJavaWriter().invokeStatic(methodInfo);
+		} else if (methodInfo.kind == JavaMethod.Kind.INTERFACE) {
+			getJavaWriter().invokeInterface(methodInfo);
 		} else if (methodInfo.kind == JavaMethod.Kind.COMPILED) {
 			Objects.requireNonNull(methodInfo.translation).translate(expression, this);
 		} else {

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

 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.JavaField;
+import org.openzen.zenscript.javashared.JavaImplementation;
 import org.openzen.zenscript.javashared.JavaMethod;
 
 public class JavaMemberVisitor implements MemberVisitor<Void> {
 		final Label constructorEnd = new Label();
 		final JavaWriter destructorWriter = new JavaWriter(member.position, writer, method, definition, null, null);
 		destructorWriter.label(constructorStart);
-
+		
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, destructorWriter);
         statementVisitor.start();
 		// TODO: destruction of members (to be done when memory tags are implemented)
 
         final boolean isAbstract = member.body == null || Modifiers.isAbstract(member.getEffectiveModifiers());
         final JavaMethod method = context.getJavaMethod(member);
-
-		final Label methodStart = new Label();
-		final Label methodEnd = new Label();
-	    final JavaWriter methodWriter = new JavaWriter(member.position, writer, method, definition, context.getMethodSignature(member.header), null);
-
-        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);
+		
+		final JavaWriter methodWriter = new JavaWriter(member.position, writer, method, definition, context.getMethodSignature(member.header), null);
 
 		if (!isAbstract) {
+			if (method.isAbstract() || method.cls.kind == JavaClass.Kind.INTERFACE)
+				throw new IllegalArgumentException();
+			
+			final Label methodStart = new Label();
+			final Label methodEnd = new Label();
+		
+			final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);
+
 			statementVisitor.start();
 			member.body.accept(statementVisitor);
 			methodWriter.label(methodEnd);
 
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
+		JavaImplementation implementation = context.getJavaImplementation(member);
+		if (implementation.inline) {
+			for (IDefinitionMember imember : member.members)
+				imember.accept(this);
+		} else {
+			throw new UnsupportedOperationException("Non-inline interface implementations not yet available");
+		}
 		return null;
 	}
 

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

 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.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.JavaField;
+import org.openzen.zenscript.javashared.JavaImplementation;
 import org.openzen.zenscript.javashared.JavaMethod;
 import stdlib.Strings;
 
 		return methodMember.ref(registry.getForDefinition(definition).stored());
 	}
 	
+	private boolean isInBasePackage(String className) {
+		return className.startsWith(basePackage + ".");
+	}
+	
 	private ZSPackage getPackage(String className) {
 		if (!className.contains("."))
 			return pkg;
 				TypeID type = loadType(bound);
 				parameter.addBound(new ParameterTypeBound(CodePosition.NATIVE, type));
 			}
+			typeParameters[i] = parameter;
 		}
 		
 		HighLevelDefinition definition;
 		} else {
 			definition = new ClassDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC);
 			javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.CLASS);
+			
+			if (cls.getSuperclass() != null && shouldLoadClass(cls.getSuperclass())) {
+				definition.setSuperType(loadType(cls.getSuperclass(), false, false));
+			}
+		}
+		
+		for (Class<?> iface : cls.getInterfaces()) {
+			if (shouldLoadClass(iface)) {
+				TypeID type = loadType(iface, false, false);
+				ImplementationMember member = new ImplementationMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC, type);
+				definition.members.add(member);
+				compiled.setImplementationInfo(member, new JavaImplementation(true, javaClass));
+			}
 		}
 		
 		definition.typeParameters = typeParameters;
 				GetterMember member = asGetter(definition, method, getter);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.getType()));
-				continue;
 			}
 			
 			ZenCodeType.Setter setter = method.getAnnotation(ZenCodeType.Setter.class);
 				SetterMember member = asSetter(definition, method, setter);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, BasicTypeID.VOID.stored));
-				continue;
 			}
 			
 			ZenCodeType.Operator operator = method.getAnnotation(ZenCodeType.Operator.class);
 				OperatorMember member = asOperator(definition, method, operator);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.header.getReturnType()));
-				continue;
 			}
 			
 			ZenCodeType.Caster caster = method.getAnnotation(ZenCodeType.Caster.class);
 				CasterMember member = asCaster(definition, method, caster);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.toType));
-				continue;
 			}
 			
 			/*if (!annotated) {
 		return definition;
 	}
 	
+	private boolean shouldLoadClass(Class<?> cls) {
+		return isInBasePackage(cls.getName());
+	}
+	
 	private boolean isGetterName(String name) {
 		return name.startsWith("get") || name.startsWith("is") || name.startsWith("has");
 	}

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaContext.java

 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 		return getJavaVariantOption(member.getOption());
 	}
 	
+	public JavaImplementation getJavaImplementation(ImplementationMember member) {
+		return getJavaModule(member.definition.module).getImplementationInfo(member);
+	}
+	
 	public void useShared() {
 		if (useShared)
 			return;

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaMethod.java

  */
 package org.openzen.zenscript.javashared;
 
+import org.openzen.zenscript.codemodel.Modifiers;
+
 /**
  *
  * @author Hoofdgebruiker
 	public JavaMethod(JavaClass cls, Kind kind, String name, boolean compile, String descriptor, int modifiers, boolean genericResult, boolean[] typeParameterArguments) {
 		if (descriptor.contains("<")) // fix signature bug
 			throw new IllegalArgumentException("Invalid descriptor!");
+		if (cls.isInterface() && !JavaModifiers.isStatic(modifiers))
+			kind = Kind.INTERFACE;
 		
 		this.cls = cls;
 		this.kind = kind;
 		return result.toString();
 	}
 	
+	public boolean isAbstract() {
+		return (modifiers & Modifiers.ABSTRACT) > 0;
+	}
+	
 	public enum Kind {
 		STATIC,
 		STATICINIT,
 		INSTANCE,
+		INTERFACE,
 		EXPANSION,
 		CONSTRUCTOR,
 		COMPILED

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaModifiers.java

 		return out;
 	}
 	
+	public static boolean isStatic(int modifiers) {
+		return (modifiers & STATIC) > 0;
+	}
+	
 	private JavaModifiers() {}
 }

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareClassMethodVisitor.java

 import org.openzen.zenscript.javashared.JavaNativeClass;
 import org.openzen.zencode.shared.StringExpansion;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.annotations.NativeTag;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 		if (nativeTag != null && nativeClass != null)
 			method = nativeClass.getMethod(nativeTag.value);
 		
+		int modifiers = cls.kind == JavaClass.Kind.INTERFACE ? JavaModifiers.ABSTRACT : 0;
 		if (member.getOverrides() != null) {
 			DefinitionMemberRef base = member.getOverrides();
 			
 					baseMethod.name,
 					true,
 					context.getMethodDescriptor(header),
-					JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
+					modifiers | JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
 					header.getReturnType().type instanceof GenericTypeID,
 					header.useTypeParameters());
 		} else if (method == null) {
 					name,
 					true,
 					context.getMethodDescriptor(header),
-					JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
+					modifiers | JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
 					header.getReturnType().type instanceof GenericTypeID,
 					header.useTypeParameters());
 		}

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedEmptyFunctionBody.java

 	
 	@Override
 	public Statement compile(StatementScope scope, FunctionHeader header) {
-		return new EmptyStatement(position);
+		return null;
 	}
 }

ScriptingExample/scripts/integration.zs

 	//	=> "key " + key;
 }
 
+class TestImplementation {
+	public implements TestInterface {
+		interfaceMethod() => "TestImplementation";
+	}
+}
+
 val testInstance = new TestOperators();
 //testInstance("something");
 
 
 println(<test string>);
 println(<test string>.name);
+println(<test string>.interfaceMethod());
+println(new TestImplementation().interfaceMethod());
 
 var diamond = <item:minecraft:diamond>;
 var dirt = <item:minecraft:dirt>;

ScriptingExample/scripts/interfaces.zs

+public interface MyInterface {
+	interfaceMethod() as string;
+}
+
+public class MyClass {
+	val name as string;
+	
+	public this(name as string) {
+		this.name = name;
+	}
+
+	public implements MyInterface {
+		interfaceMethod() => "InterfaceMethod " + name;
+	}
+}
+
+println(new MyClass("hello").interfaceMethod());

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/Main.java

 		JavaNativeModule example = scriptingEngine.createNativeModule("example", "org.openzen.zenscript.scriptingexample");
 		example.addGlobals(Globals.class);
 		example.addClass(TestClass.class);
+		example.addClass(TestInterface.class);
 		scriptingEngine.registerNativeProvided(example);
 		
 		File inputDirectory = new File("scripts");

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/TestClass.java

  */
 package org.openzen.zenscript.scriptingexample;
 
-import org.openzen.zencode.java.ZenCodeType;
-
 /**
  *
  * @author Hoofdgebruiker
  */
-public class TestClass implements ZenCodeType {
+public class TestClass implements TestInterface {
 	private final String name;
 	
 	@Constructor
 	public String toString() {
 		return name;
 	}
+
+	@Override
+	public String interfaceMethod() {
+		return "Interface method of " + name;
+	}
 }