- Improved interface validation: allow definition members to be used as implementation

- Added support for INTERFACE calls in java source code generation
- Minor source code generation quality improvements

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ImplementationMember.java

 package org.openzen.zenscript.codemodel.member;
 
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 public class ImplementationMember extends DefinitionMember {
 	public final TypeID type;
 	public final List<IDefinitionMember> members = new ArrayList<>();
+	public final Map<DefinitionMemberRef, IDefinitionMember> definitionBorrowedMembers = new HashMap<>(); // contains members from the outer definition to implement interface members
 	
 	public ImplementationMember(CodePosition position, HighLevelDefinition definition, int modifiers, TypeID type) {
 		super(position, definition, modifiers);
 
 	@Override
 	public void normalize(TypeScope scope) {
-		for (IDefinitionMember member : members)
+		Set<IDefinitionMember> implemented = new HashSet<>();
+		for (IDefinitionMember member : members) {
 			member.normalize(scope);
+			if (member.getOverrides() != null)
+				implemented.add(member.getOverrides().getTarget());
+		}
+		
+		TypeMembers interfaceMembers = scope.getTypeMembers(type.stored());
+		TypeMembers definitionMembers = scope.getTypeMembers(scope.getTypeRegistry().getForMyDefinition(definition).stored());
+		
+		definitionBorrowedMembers.clear();
+		definitionBorrowedMembers.putAll(interfaceMembers.borrowInterfaceMembersFromDefinition(implemented, definitionMembers));
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/TypeMemberGroup.java

 		return this.setter == null ? null : this.setter.member;
 	}
 	
+	public FunctionalMemberRef getMethod(FunctionHeader header) {
+		for (TypeMember<FunctionalMemberRef> method : methods)
+			if (method.member.getHeader().isEquivalentTo(header))
+				return method.member;
+		
+		return null;
+	}
+	
 	public FunctionalMemberRef getUnaryMethod() {
 		for (TypeMember<FunctionalMemberRef> method : methods)
 			if (method.member.getHeader().parameters.length == 0)

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/TypeMembers.java

 		return false;
 	}
 	
+	public Map<DefinitionMemberRef, IDefinitionMember> borrowInterfaceMembersFromDefinition(Set<IDefinitionMember> implemented, TypeMembers definitionMembers) {
+		Map<DefinitionMemberRef, IDefinitionMember> result = new HashMap<>();
+		
+		for (TypeMember<CasterMemberRef> caster : casters) {
+			if (implemented.contains(caster.member.member))
+				continue;
+			
+			CasterMemberRef implementation = definitionMembers.getCaster(caster.member.toType);
+			if (implementation != null)
+				result.put(caster.member, implementation.getTarget());
+		}
+		for (TypeMember<IteratorMemberRef> iterator : iterators) {
+			if (implemented.contains(iterator.member.target))
+				continue;
+			
+			IteratorMemberRef implementation = definitionMembers.getIterator(iterator.member.getLoopVariableCount());
+			if (implementation != null)
+				result.put(iterator.member, implementation.getTarget());
+		}
+		for (Map.Entry<String, TypeMemberGroup> entry : members.entrySet()) {
+			TypeMemberGroup group = entry.getValue();
+			TypeMemberGroup definitionGroup = definitionMembers.getGroup(entry.getKey());
+			if (definitionGroup == null)
+				continue;
+			
+			if (group.getGetter() != null) {
+				if (!implemented.contains(group.getGetter().member)) {
+					GetterMemberRef implementation = definitionGroup.getGetter();
+					if (implementation != null)
+						result.put(group.getGetter(), implementation.getTarget());
+				}
+			}
+			if (group.getSetter() != null) {
+				if (!implemented.contains(group.getSetter().member)) {
+					SetterMemberRef implementation = definitionGroup.getSetter();
+					if (implementation != null)
+						result.put(group.getSetter(), implementation.getTarget());
+				}
+			}
+			for (TypeMember<FunctionalMemberRef> member : group.getMethodMembers()) {
+				if (!implemented.contains(member.member.getTarget())) {
+					FunctionalMemberRef functional = definitionGroup.getMethod(member.member.getHeader());
+					if (functional != null)
+						result.put(member.member, functional.getTarget());
+				}
+			}
+		}
+		for (Map.Entry<OperatorType, TypeMemberGroup> entry : operators.entrySet()) {
+			if (entry.getKey() == OperatorType.DESTRUCTOR)
+				continue; // destructor doesn't have to be implemented; the compiler can do so automatically
+			
+			TypeMemberGroup group = entry.getValue();
+			TypeMemberGroup definitionGroup = definitionMembers.getGroup(entry.getKey());
+			if (definitionGroup == null)
+				continue;
+			
+			for (TypeMember<FunctionalMemberRef> member : group.getMethodMembers()) {
+				if (!implemented.contains(member.member.getTarget())) {
+					FunctionalMemberRef functional = definitionGroup.getMethod(member.member.getHeader());
+					if (functional != null)
+						result.put(member.member, functional.getTarget());
+				}
+			}
+		}
+		
+		return result;
+	}
+	
 	private Expression castEquivalent(CodePosition position, Expression value, StoredType toType) {
 		if (toType.equals(value.type))
 			return value;

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceExpressionFormatter.java

 				FormattingUtils.formatExpansionCall(output, this.target, scope, getValue(target), arguments);
 				return new ExpressionString(output.toString(), JavaOperator.CALL);
 			}
-			case INSTANCE: {
+			case INSTANCE:
+			case INTERFACE: {
 				StringBuilder output = new StringBuilder();
 				output.append(getValue(target).value);
 				output.append('.');
 				return compare(call.left, call.right, call.comparison);
 			case UINT_COMPARE:
 			case USIZE_COMPARE_UINT:
-				return compare(callAsStatic("Integer.compareUnsigned", call.left, call.right), call.comparison);
+				if (call.comparison == CompareType.EQ || call.comparison == CompareType.NE) {
+					return compare(call.left, call.right, call.comparison);
+				} else {
+					return compare(callAsStatic("Integer.compareUnsigned", call.left, call.right), call.comparison);
+				}
 			case LONG_COMPARE:
 			case LONG_COMPARE_INT:
 				return compare(call.left, call.right, call.comparison);

ScriptingExample/scripts/integration.zs

 import example.TestClass;
+import example.TestInterface;
 
 val instance = new TestClass("Instance");
 println("Name: " + instance.name);

Shared/src/main/java/compactio/CompactBytesDataInput.java

 import java.util.Arrays;
 
 public final class CompactBytesDataInput implements CompactDataInput, AutoCloseable {
-    private static final int P6 = 1 << 6;
     private static final int P7 = 1 << 7;
-    private static final int P13 = 1 << 13;
     private static final int P14 = 1 << 14;
-    private static final int P20 = 1 << 20;
     private static final int P21 = 1 << 21;
-    private static final int P27 = 1 << 27;
     private static final int P28 = 1 << 28;
-    private static final long P34 = 1L << 34;
     private static final long P35 = 1L << 35;
-    private static final long P41 = 1L << 41;
     private static final long P42 = 1L << 42;
-    private static final long P48 = 1L << 48;
     private static final long P49 = 1L << 49;
-    private static final long P55 = 1L << 55;
     private static final long P56 = 1L << 56;
+	
     private final byte[] data;
     private int offset;
     

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

 import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 		for (IDefinitionMember member : implementation.members)
 			if (member.getOverrides() != null)
 				implemented.add(member.getOverrides().getTarget());
+		for (DefinitionMemberRef member : implementation.definitionBorrowedMembers.keySet())
+			implemented.add(member.getTarget());
 		
 		TypeMembers members = scope.getTypeMembers(implementation.type.stored(BorrowStorageTag.THIS));
 		List<IDefinitionMember> unimplemented = members.getUnimplementedMembers(implemented);