- Fixed issues with closeables

- WIP on improving iterable implementations
- Added validation of implementation completeness
- Added definition normalization (now also adds destructors as necessary)
- Fix interfaces with base interfaces

CodeModel/src/main/java/org/openzen/zenscript/codemodel/FunctionHeader.java

 		hasUnknowns = hasUnknowns(parameters, returnType);
 	}
 	
-	public FunctionHeader(TypeParameter[] genericParameters, ITypeID returnType, ITypeID thrownType, FunctionParameter... parameters) {
+	public FunctionHeader(TypeParameter[] typeParameters, ITypeID returnType, ITypeID thrownType, FunctionParameter... parameters) {
 		if (returnType == null)
 			throw new NullPointerException();
-		if (genericParameters == null)
+		if (typeParameters == null)
 			throw new NullPointerException();
 		
-		this.typeParameters = genericParameters;
+		this.typeParameters = typeParameters;
 		this.returnType = returnType;
 		this.parameters = parameters;
 		this.thrownType = thrownType;
 	}
 	
 	public boolean canOverride(TypeScope scope, FunctionHeader other) {
+		if (other == null)
+			throw new NullPointerException();
 		if (parameters.length != other.parameters.length)
 			return false;
 		if (returnType != BasicTypeID.UNDETERMINED && !scope.getTypeMembers(returnType).canCastImplicit(other.returnType))

CodeModel/src/main/java/org/openzen/zenscript/codemodel/HighLevelDefinition.java

 import org.openzen.zenscript.codemodel.annotations.DefinitionAnnotation;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
 import org.openzen.zenscript.codemodel.definition.DefinitionVisitor;
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 	}
 	
 	public void normalize(TypeScope scope) {
+		DestructorMember destructor = null;
+		List<FieldMember> fields = new ArrayList();
+		
 		for (IDefinitionMember member : members) {
 			member.normalize(scope);
+			
+			if (member instanceof DestructorMember)
+				destructor = (DestructorMember)member;
+			if (member instanceof FieldMember)
+				fields.add((FieldMember)member);
+		}
+		
+		if (isDestructible() && destructor == null && !(this instanceof ExpansionDefinition)) {
+			System.out.println("Added destructor to " + position);
+			destructor = new DestructorMember(position, this, Modifiers.PUBLIC);
+			members.add(destructor);
+		}
+		
+		for (FieldMember field : fields) {
+			if (field.autoGetter != null)
+				members.add(field.autoGetter);
+			if (field.autoSetter != null)
+				members.add(field.autoSetter);
 		}
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/InterfaceDefinition.java

 		baseInterfaces.add(baseInterface);
 	}
 	
+	@Override
+	public boolean isDestructible() {
+		for (ITypeID baseInterface : baseInterfaces)
+			if (baseInterface.isDestructible())
+				return true;
+		
+		return super.isDestructible();
+	}
+	
 	@Override
 	public boolean isStatic() {
 		return true;

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
-import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;

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

 		type = type.getNormalized();
 		value = value.normalize(scope);
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

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

 		if (initializer != null)
 			initializer = initializer.normalize(scope);
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

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

 		if (body != null)
 			body = body.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class));
 	}
+	
+	@Override
+	public boolean isAbstract() {
+		return body == null && builtin == null;
+	}
 }

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
+import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 		this.type = type;
 	}
 	
+	@Override
+	public void setBody(Statement body) {
+		super.setBody(body);
+		
+		if (type == BasicTypeID.UNDETERMINED)
+			type = body.getReturnType();
+	}
+	
 	@Override
 	public ITypeID getType() {
 		return type;

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

 	DefinitionMemberRef getOverrides();
 
 	public void normalize(TypeScope scope);
+	
+	boolean isAbstract();
 }

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

  */
 package org.openzen.zenscript.codemodel.member;
 
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
  *
  * @author Hoofdgebruiker
  */
-public interface IPropertyMember {
+public interface IPropertyMember extends IDefinitionMember {
 	ITypeID getType();
 	
-	CodePosition getPosition();
-	
-	String describe();
-
-	<T> T getTag(Class<T> type);
-	
 	boolean isStatic();
 	
 	boolean isFinal();

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

 		for (IDefinitionMember member : members)
 			member.normalize(scope);
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

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

 	public void normalize(TypeScope scope) {
 		innerDefinition.normalize(scope);
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

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

 	public void normalize(TypeScope scope) {
 		body = body.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class));
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/ArrayIteratorKeyValues.java

 	public void normalize(TypeScope scope) {
 		
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/ArrayIteratorValues.java

 	public void normalize(TypeScope scope) {
 		
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/AssocIterator.java

 	public void normalize(TypeScope scope) {
 		
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/RangeIterator.java

 	public void normalize(TypeScope scope) {
 		
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/StringCharIterator.java

 	public void normalize(TypeScope scope) {
 		
 	}
+
+	@Override
+	public boolean isAbstract() {
+		return false;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/CasterMemberRef.java

 import org.openzen.zenscript.codemodel.expression.CastExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.CasterMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 	public MemberAnnotation[] getAnnotations() {
 		return member.annotations;
 	}
+
+	@Override
+	public IDefinitionMember getTarget() {
+		return member;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/DefinitionMemberRef.java

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 
 /**
  *
 	FunctionHeader getHeader();
 	
 	MemberAnnotation[] getAnnotations();
+	
+	IDefinitionMember getTarget();
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/ImplementationMemberRef.java

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 	public MemberAnnotation[] getAnnotations() {
 		return member.annotations;
 	}
+
+	@Override
+	public IDefinitionMember getTarget() {
+		return member;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/IteratorMemberRef.java

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.IIteratorMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 			return null;
 		}
 	}
+
+	@Override
+	public IDefinitionMember getTarget() {
+		return target;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/PropertyRef.java

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.IPropertyMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	public final MemberAnnotation[] getAnnotations() {
 		return member.getAnnotations();
 	}
+	
+	@Override
+	public final IDefinitionMember getTarget() {
+		return member;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/ReturnStatement.java

 
 	@Override
 	public Statement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
-		Expression tValue = value.transform(transformer);
+		Expression tValue = value == null ? null : value.transform(transformer);
 		return tValue == value ? this : new ReturnStatement(position, tValue);
 	}
 
 	@Override
 	public Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
-		Expression tValue = value.transform(transformer);
+		Expression tValue = value == null ? null : value.transform(transformer);
 		return tValue == value ? this : new ReturnStatement(position, tValue);
 	}
 
 	@Override
 	public Statement normalize(TypeScope scope, ConcatMap<LoopStatement, LoopStatement> modified) {
-		return new ReturnStatement(position, value.normalize(scope));
+		return new ReturnStatement(position, value == null ? null : value.normalize(scope));
 	}
 }

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

 				for (ITypeID resultHint : typeHints) {
 					Map<TypeParameter, ITypeID> mapping = new HashMap<>();
 					if (header.returnType.inferTypeParameters(scope.getMemberCache(), resultHint, mapping)) {
-						header = header.withGenericArguments(new GenericMapper(scope.getTypeRegistry(), mapping));
+						header = header.withGenericArguments(scope.getLocalTypeParameters().getInner(mapping));
 						break;
 					}
 				}

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

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.InnerDefinition;
 import org.openzen.zenscript.codemodel.member.ref.CasterMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
 		return null;
 	}
 	
+	public List<IDefinitionMember> getUnimplementedMembers(Set<IDefinitionMember> implemented) {
+		List<IDefinitionMember> result = new ArrayList<>();
+		for (TypeMember<CasterMemberRef> caster : casters) {
+			if (caster.member.member.isAbstract() && !implemented.contains(caster.member.member))
+				result.add(caster.member.member);
+		}
+		for (TypeMember<IteratorMemberRef> iterator : iterators) {
+			if (iterator.member.target.isAbstract() && !implemented.contains(iterator.member.target))
+				result.add(iterator.member.target);
+		}
+		for (Map.Entry<String, DefinitionMemberGroup> entry : members.entrySet()) {
+			DefinitionMemberGroup group = entry.getValue();
+			if (group.getGetter() != null && group.getGetter().member.isAbstract() && !implemented.contains(group.getGetter().member))
+				result.add(group.getGetter().member);
+			if (group.getSetter() != null && group.getSetter().member.isAbstract() && !implemented.contains(group.getSetter().member))
+				result.add(group.getSetter().member);
+			for (TypeMember<FunctionalMemberRef> member : group.getMethodMembers())
+				if (member.member.getTarget().isAbstract() && !implemented.contains(member.member.getTarget()))
+					result.add(member.member.getTarget());
+		}
+		for (Map.Entry<OperatorType, DefinitionMemberGroup> entry : operators.entrySet()) {
+			if (entry.getKey() == OperatorType.DESTRUCTOR)
+				continue; // destructor doesn't have to be implemented; the compiler can do so automatically
+			
+			DefinitionMemberGroup group = entry.getValue();
+			if (group.getGetter() != null && group.getGetter().member.isAbstract() && !implemented.contains(group.getGetter().member))
+				result.add(group.getGetter().member);
+			if (group.getSetter() != null && group.getSetter().member.isAbstract() && !implemented.contains(group.getSetter().member))
+				result.add(group.getSetter().member);
+			for (TypeMember<FunctionalMemberRef> member : group.getMethodMembers())
+				if (member.member.getTarget().isAbstract() && !implemented.contains(member.member.getTarget()))
+					result.add(member.member.getTarget());
+		}
+		return result;
+	}
+	
 	public void addConstructor(FunctionalMemberRef constructor, TypeMemberPriority priority) {
 		getOrCreateGroup(OperatorType.CONSTRUCTOR).addMethod(constructor, priority);
 	}

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

 	@Override
 	public Void visitClass(ClassDefinition definition) {
 		JavaSourceFileScope scope = createScope(definition);
+		JavaSourceClass cls = definition.getTag(JavaSourceClass.class);
 		
 		output.append(indent);
 		convertModifiers(definition.modifiers);
-		output.append("class ").append(definition.name);
+		output.append("class ").append(cls.getName());
 		JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, definition.genericParameters, false);
 		if (definition.getSuperType() != null) {
 			output.append(" extends ");
 			}
 		}
 		
-		if (mergedImplementations.size() > 0 || definition.isDestructible()) {
+		if (mergedImplementations.size() > 0 || cls.destructible) {
 			output.append(" implements ");
 			boolean first = true;
 			for (int i = 0; i < mergedImplementations.size(); i++) {
 				output.append(scope.type(implementation.type));
 			}
 			
-			if (definition.isDestructible()) {
+			if (cls.destructible) {
 				if (first)
 					first = false;
 				else
 	@Override
 	public Void visitInterface(InterfaceDefinition definition) {
 		JavaSourceFileScope scope = createScope(definition);
+		JavaSourceClass cls = definition.getTag(JavaSourceClass.class);
 		
 		output.append(indent);
 		convertModifiers(definition.modifiers | Modifiers.VIRTUAL); // to prevent 'final'
-		output.append("interface ").append(definition.name);
+		output.append("interface ").append(cls.getName());
 		JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, definition.genericParameters, false);
-			
+		
+		boolean firstExtends = true;
 		if (definition.isDestructible()) {
 			output.append(" extends ");
 			output.append(scope.importer.importType(new JavaSourceClass("java.lang", "AutoCloseable")));
+			firstExtends = false;
+		}
+		
+		for (ITypeID base : definition.baseInterfaces) {
+			if (firstExtends) {
+				firstExtends = false;
+				output.append(" extends ");
+			} else {
+				output.append(", ");
+			}
+			output.append(scope.type(base));
 		}
 		
 		output.append(" {\n");

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

 
 	@Override
 	public Void visitDestructor(DestructorMember member) {
-		throw new UnsupportedOperationException("Expansions cannot declare destructors");
+		return null; // ignore
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.ConstMember;
 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.statement.BlockStatement;
 import org.openzen.zenscript.codemodel.statement.EmptyStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 		
 		output.append(indent).append("@Override\n");
 		output.append(indent).append("public void close()");
-		compileBody(member.body, member.header);
+		
+		Statement body = member.body;
+		if ((body == null || body instanceof EmptyStatement) && !(definition instanceof InterfaceDefinition))
+			body = new BlockStatement(member.position, Collections.emptyList());
+		
+		compileBody(body, member.header);
 		return null;
 	}
 
 	}
 	
 	public void finish() {
-		// TODO: needs to be moved elsewhere (normalization stage?)
-		for (FieldMember field : fields) {
-			if (field.autoGetter != null)
-				visitGetter(field.autoGetter);
-			if (field.autoSetter != null)
-				visitSetter(field.autoSetter);
-		}
+		
 	}
 }

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

 					throw new UnsupportedOperationException("Not yet supported!");
 				}
 			}
-			case ARRAY_CONSTRUCTOR_PROJECTED_INDEXED:
+			case ARRAY_CONSTRUCTOR_PROJECTED_INDEXED: {
 				ArrayTypeID type = (ArrayTypeID) expression.type;
 				
 				if (type.dimension == 1) {
 					// TODO: implement
 					throw new UnsupportedOperationException("Not yet supported!");
 				}
+			}
+			case CLASS_DEFAULT_CONSTRUCTOR:
+				return new ExpressionString("new " + scope.type(expression.type) + "()", JavaOperator.NEW);
 		}
 		
 		throw new UnsupportedOperationException("Unknown builtin constructor: " + expression.constructor.getBuiltin());

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaNativeClass.java

 public class JavaNativeClass {
 	public final JavaSourceClass cls;
 	private final Map<String, JavaSourceMethod> methods = new HashMap<>();
+	public final boolean nonDestructible;
 	
 	public JavaNativeClass(JavaSourceClass cls) {
+		this(cls, false);
+	}
+	
+	public JavaNativeClass(JavaSourceClass cls, boolean nonDestructible) {
 		this.cls = cls;
+		this.nonDestructible = nonDestructible;
 	}
 	
 	public void addMethod(String key, JavaSourceMethod method) {

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareClassMethodVisitor.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.javasource.JavaSourceTypeNameVisitor;
 import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 import org.openzen.zenscript.javasource.tags.JavaSourceField;
  * @author Hoofdgebruiker
  */
 public class JavaSourcePrepareClassMethodVisitor implements MemberVisitor<Void> {
+	private static final boolean DEBUG_EMPTY = true;
+	
+	private final JavaSourcePrepareDefinitionVisitor definitionPreparer;
 	private final String filename;
 	private final JavaSourceClass cls;
 	private final JavaNativeClass nativeClass;
 	
-	public JavaSourcePrepareClassMethodVisitor(String filename, JavaSourceClass cls, JavaNativeClass nativeClass, boolean startsEmpty) {
+	public JavaSourcePrepareClassMethodVisitor(
+			JavaSourcePrepareDefinitionVisitor definitionPreparer,
+			String filename,
+			JavaSourceClass cls,
+			JavaNativeClass nativeClass,
+			boolean startsEmpty) {
+		this.definitionPreparer = definitionPreparer;
 		this.filename = filename;
 		this.cls = cls;
 		this.nativeClass = nativeClass;
+		
 		cls.empty = startsEmpty;
 	}
 	
 	@Override
 	public Void visitConst(ConstMember member) {
+		if (DEBUG_EMPTY && cls.empty)
+			System.out.println("Class " + cls.fullName + " not empty because of const " + member.name);
+		
 		cls.empty = false;
 		member.setTag(JavaSourceField.class, new JavaSourceField(cls, member.name));
 		return null;
 	
 	@Override
 	public Void visitField(FieldMember member) {
-		cls.empty = false;
 		member.setTag(JavaSourceField.class, new JavaSourceField(cls, member.name));
 		if (member.hasAutoGetter())
 			visitGetter(member.autoGetter);
 
 	@Override
 	public Void visitDestructor(DestructorMember member) {
+		if (DEBUG_EMPTY && cls.empty)
+			System.out.println("Class " + cls.fullName + " not empty because of destructor");
+		
 		cls.empty = false;
 		return null;
 	}
 
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
-		cls.empty = false;
+		definitionPreparer.prepare(member.type);
+		
 		if (canMergeImplementation(member)) {
 			member.setTag(JavaSourceImplementation.class, new JavaSourceImplementation(true, cls));
 			for (IDefinitionMember m : member.members)
 				m.accept(this);
 		} else {
+			if (DEBUG_EMPTY && cls.empty)
+				System.out.println("Class " + cls.fullName + " not empty because of unmergeable implementation");
+			
+			cls.empty = false;
+			
 			JavaSourceClass implementationClass = new JavaSourceClass(cls, member.type.accept(new JavaSourceTypeNameVisitor()) + "Implementation");
 			member.setTag(JavaSourceImplementation.class, new JavaSourceImplementation(false, implementationClass));
 			
-			JavaSourcePrepareClassMethodVisitor visitor = new JavaSourcePrepareClassMethodVisitor(filename, implementationClass, null, true);
+			JavaSourcePrepareClassMethodVisitor visitor = new JavaSourcePrepareClassMethodVisitor(definitionPreparer, filename, implementationClass, null, true);
 			for (IDefinitionMember m : member.members)
 				m.accept(visitor);
 		}
 		JavaSourcePrepareDefinitionVisitor innerDefinitionPrepare = new JavaSourcePrepareDefinitionVisitor(filename, cls);
 		member.innerDefinition.accept(innerDefinitionPrepare);
 		
+		if (DEBUG_EMPTY && cls.empty)
+			System.out.println("Class " + cls.fullName + " not empty because of inner definition " + member.innerDefinition.name);
 		cls.empty = false;
 		return null;
 	}
 
 	@Override
 	public Void visitStaticInitializer(StaticInitializerMember member) {
+		if (DEBUG_EMPTY && cls.empty)
+			System.out.println("Class " + cls.fullName + " not empty because of static initializer");
+		
 		cls.empty = false;
 		return null;
 	}
 		JavaSourceMethod method = null;
 		if (nativeTag != null && nativeClass != null)
 			method = nativeClass.getMethod(nativeTag.value);
-		if (method == null)
+		
+		if (member.getOverrides() != null) {
+			DefinitionMemberRef base = member.getOverrides();
+			JavaSourceMethod baseMethod = base.getTarget().getTag(JavaSourceMethod.class);
+			if (baseMethod == null)
+				throw new IllegalStateException("Base method not yet prepared!");
+			
+			method = new JavaSourceMethod(cls, baseMethod.kind, baseMethod.name, true);
+		} else if (method == null) {
 			method = new JavaSourceMethod(cls, getKind(member), name, true);
+		}
 		
-		if (method.compile)
+		if (method.compile) {
+			if (DEBUG_EMPTY && cls.empty)
+				System.out.println("Class " + cls.fullName + " not empty because of " + member.describe());
+			
 			cls.empty = false;
+		}
 		
 		member.setTag(JavaSourceMethod.class, method);
 	}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareDefinitionVisitor.java

 import org.openzen.zenscript.codemodel.expression.CastExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.formattershared.ExpressionString;
 import org.openzen.zenscript.javasource.JavaOperator;
 import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 			list.addInstanceMethod("insert", "add");
 			list.addInstanceMethod("remove", "remove");
 			list.addInstanceMethod("indexOf", "indexOf");
+			list.addInstanceMethod("lastIndexOf", "lastIndexOf");
 			list.addInstanceMethod("getAtIndex", "get");
 			list.addInstanceMethod("setAtIndex", "set");
 			list.addInstanceMethod("contains", "contains");
 			list.addMethod("toArray", new JavaSourceMethod((formatter, call) -> formatter.listToArray((CastExpression)call)));
-			list.addInstanceMethod("length", "length");
+			list.addInstanceMethod("length", "size");
 			list.addInstanceMethod("isEmpty", "isEmpty");
+			list.addInstanceMethod("iterate", "iterator");
 			nativeClasses.put("stdlib::List", list);
 		}
 		
+		{
+			JavaNativeClass iterable = new JavaNativeClass(new JavaSourceClass("java.lang", "Iterable"));
+			iterable.addInstanceMethod("iterate", "iterator");
+			nativeClasses.put("stdlib::Iterable", iterable);
+		}
+		
+		{
+			JavaNativeClass iterator = new JavaNativeClass(new JavaSourceClass("java.lang", "Iterator"));
+			iterator.addInstanceMethod("hasNext", "hasNext");
+			iterator.addInstanceMethod("next", "next");
+			nativeClasses.put("stdlib::Iterator", iterator);
+		}
+		
 		{
 			JavaNativeClass comparable = new JavaNativeClass(new JavaSourceClass("java.lang", "Comparable"));
 			comparable.addInstanceMethod("compareTo", "compareTo");
 		}
 		
 		{
-			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.io", "StringReader"));
+			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.io", "StringReader"), true);
 			cls.addInstanceMethod("constructor", "");
 			cls.addInstanceMethod("destructor", "close");
 			cls.addInstanceMethod("readCharacter", "read");
 		this.outerClass = outerClass;
 	}
 	
+	private boolean isPrepared(HighLevelDefinition definition) {
+		return definition.hasTag(JavaSourceClass.class);
+	}
+	
+	public void prepare(ITypeID type) {
+		if (!(type instanceof DefinitionTypeID))
+			return;
+			
+		HighLevelDefinition definition = ((DefinitionTypeID)type).definition;
+		definition.accept(this);
+	}
+	
 	@Override
 	public JavaSourceClass visitClass(ClassDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaSourceClass.class);
+		
 		return visitClassCompiled(definition, true);
 	}
 
 	@Override
 	public JavaSourceClass visitInterface(InterfaceDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaSourceClass.class);
+		
+		for (ITypeID baseType : definition.baseInterfaces)
+			prepare(baseType);
+		
 		return visitClassCompiled(definition, true);
 	}
 
 	@Override
 	public JavaSourceClass visitEnum(EnumDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaSourceClass.class);
+		
 		return visitClassCompiled(definition, false);
 	}
 
 	@Override
 	public JavaSourceClass visitStruct(StructDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaSourceClass.class);
+		
 		return visitClassCompiled(definition, true);
 	}
 
 	@Override
 	public JavaSourceClass visitFunction(FunctionDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaSourceClass.class);
+		
 		JavaSourceClass cls = new JavaSourceClass(definition.pkg.fullName, filename);
 		definition.setTag(JavaSourceClass.class, cls);
 		JavaSourceMethod method = new JavaSourceMethod(cls, JavaSourceMethod.Kind.STATIC, definition.name, true);
 
 	@Override
 	public JavaSourceClass visitExpansion(ExpansionDefinition definition) {
+		if (isPrepared(definition))
+			return definition.getTag(JavaSourceClass.class);
+		
 		NativeTag nativeTag = definition.getTag(NativeTag.class);
 		JavaNativeClass nativeClass = null;
 		if (nativeTag != null) {
 
 	@Override
 	public JavaSourceClass visitVariant(VariantDefinition variant) {
+		if (isPrepared(variant))
+			return variant.getTag(JavaSourceClass.class);
+		
 		JavaSourceClass cls = new JavaSourceClass(variant.pkg.fullName, variant.name);
 		variant.setTag(JavaSourceClass.class, cls);
 		
 	}
 	
 	private JavaSourceClass visitClassCompiled(HighLevelDefinition definition, boolean startsEmpty) {
+		if (definition.getSuperType() != null)
+			prepare(definition.getSuperType());
+		
 		NativeTag nativeTag = definition.getTag(NativeTag.class);
 		JavaNativeClass nativeClass = nativeTag == null ? null : nativeClasses.get(nativeTag.value);
 		if (nativeClass == null) {
 			JavaSourceClass cls = outerClass == null ? new JavaSourceClass(definition.pkg.fullName, definition.name) : new JavaSourceClass(outerClass, definition.name);
+			cls.destructible = definition.isDestructible();
 			definition.setTag(JavaSourceClass.class, cls);
 			visitClassMembers(definition, cls, null, startsEmpty);
 			return cls;
 			definition.setTag(JavaSourceClass.class, nativeClass.cls);
 			definition.setTag(JavaNativeClass.class, nativeClass);
 			visitExpansionMembers(definition, cls, nativeClass);
+			
+			if (nativeClass.nonDestructible)
+				cls.destructible = false;
+			
 			return cls;
 		}
 	}
 	
 	private void visitClassMembers(HighLevelDefinition definition, JavaSourceClass cls, JavaNativeClass nativeClass, boolean startsEmpty) {
-		JavaSourcePrepareClassMethodVisitor methodVisitor = new JavaSourcePrepareClassMethodVisitor(filename, cls, nativeClass, startsEmpty);
+		JavaSourcePrepareClassMethodVisitor methodVisitor = new JavaSourcePrepareClassMethodVisitor(this, filename, cls, nativeClass, startsEmpty);
 		for (IDefinitionMember member : definition.members) {
 			member.accept(methodVisitor);
 		}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareExpansionMethodVisitor.java

  * @author Hoofdgebruiker
  */
 public class JavaSourcePrepareExpansionMethodVisitor implements MemberVisitor<Void> {
+	private static final boolean DEBUG_EMPTY = true;
+	
 	private final JavaSourceClass cls;
 	private final JavaNativeClass nativeClass;
 	
 	@Override
 	public Void visitConst(ConstMember member) {
 		member.setTag(JavaSourceField.class, new JavaSourceField(cls, member.name));
+		
+		if (DEBUG_EMPTY && cls.empty)
+			System.out.println("Class " + cls.fullName + " not empty because of const");
+		
 		cls.empty = false;
 		return null;
 	}
 
 	@Override
 	public Void visitDestructor(DestructorMember member) {
+		if (nativeClass != null && nativeClass.nonDestructible)
+			return null;
+		
 		visitFunctional(member, "");
 		return null;
 	}
 		if (method == null)
 			method = new JavaSourceMethod(cls, getKind(member), name, true); 
 		
-		if (method.compile)
+		if (method.compile) {
+			if (DEBUG_EMPTY && cls.empty)
+				System.out.println("Class " + cls.fullName + " not empty because of " + member.describe());
+			
 			cls.empty = false;
+		}
 		
 		member.setTag(JavaSourceMethod.class, method);
 	}

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedClass.java

 		return result;
 	}
 	
-	private final List<ParsedTypeParameter> genericParameters;
+	private final List<ParsedTypeParameter> parameters;
 	private final IParsedType superclass;
 	
 	private final ClassDefinition compiled;
 	
-	public ParsedClass(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> genericParameters, IParsedType superclass, HighLevelDefinition outerDefinition) {
+	public ParsedClass(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> parameters, IParsedType superclass, HighLevelDefinition outerDefinition) {
 		super(position, modifiers, annotations);
 		
-		this.genericParameters = genericParameters;
+		this.parameters = parameters;
 		this.superclass = superclass;
 		
 		compiled = new ClassDefinition(position, pkg, name, modifiers, outerDefinition);
-		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(genericParameters));
+		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(parameters));
 	}
 
 	@Override
 
 	@Override
 	protected void linkTypesLocal(TypeResolutionContext context) {
+		ParsedTypeParameter.compile(context, compiled.genericParameters, this.parameters);
+		
 		if (superclass != null)
 			compiled.setSuperType(superclass.compile(context));
 		

Validator/src/main/java/org/openzen/zenscript/validator/ValidationLogEntry.java

 		OVERRIDE_MISSING_BASE,
 		INVALID_OVERRIDE,
 		SUPERTYPE_NOT_DESTRUCTIBLE,
-		INVALID_IMPLEMENTATION_TYPE
+		INVALID_IMPLEMENTATION_TYPE,
+		INCOMPLETE_IMPLEMENTATION
 	}
 }

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

 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.validator.ValidationLogEntry;
 import org.openzen.zenscript.validator.Validator;
 import org.openzen.zenscript.validator.analysis.ExpressionScope;
 	public Void visitGetter(GetterMember member) {
 		ValidationUtils.validateIdentifier(validator, member.position, member.name);
 		member.type.accept(new TypeValidator(validator, member.position));
-		validateFunctional(member, new MethodStatementScope(member.header));
+		validateProperty(member, new MethodStatementScope(member.header));
 		return null;
 	}
 
 	public Void visitSetter(SetterMember member) {
 		ValidationUtils.validateIdentifier(validator, member.position, member.name);
 		member.type.accept(new TypeValidator(validator, member.position));
-		validateFunctional(member, new MethodStatementScope(member.header));
+		validateProperty(member, new MethodStatementScope(member.header));
 		return null;
 	}
 	
 
 	@Override
 	public Void visitCustomIterator(CustomIteratorMember member) {
-		// TODO: validate iterators
+		for (ITypeID type : member.getLoopVariableTypes())
+			type.accept(new TypeValidator(validator, member.position));
+		validateFunctional(member, new MethodStatementScope(new FunctionHeader(scope.getTypeRegistry().getIterator(member.getLoopVariableTypes()))));
 		return null;
 	}
 
 			member.accept(memberValidator);
 		}
 		
+		checkImplementationComplete(implementation);
 		return null;
 	}
+	
+	private void checkImplementationComplete(ImplementationMember implementation) {
+		Set<IDefinitionMember> implemented = new HashSet<>();
+		for (IDefinitionMember member : implementation.members)
+			if (member.getOverrides() != null)
+				implemented.add(member.getOverrides().getTarget());
+		
+		TypeMembers members = scope.getTypeMembers(implementation.type);
+		List<IDefinitionMember> unimplemented = members.getUnimplementedMembers(implemented);
+		if (unimplemented.size() == 1) {
+			validator.logError(ValidationLogEntry.Code.INCOMPLETE_IMPLEMENTATION, implementation.position, unimplemented.get(0).describe() + " not implemented");
+		} else if (unimplemented.size() > 1) {
+			StringBuilder message = new StringBuilder();
+			message.append("Implementation incomplete: ").append(unimplemented.size()).append(" members not yet implemented:");
+			for (IDefinitionMember member : unimplemented) {
+				message.append("\n").append("  - ").append(member.describe());
+			}
+			validator.logError(ValidationLogEntry.Code.INCOMPLETE_IMPLEMENTATION, implementation.position, message.toString());
+		}
+	}
 
 	@Override
 	public Void visitInnerDefinition(InnerDefinitionMember innerDefinition) {
 		}
 	}
 	
+	private void validateProperty(FunctionalMember member, StatementScope scope) {
+		if (Modifiers.isOverride(member.modifiers) || (context == DefinitionMemberContext.IMPLEMENTATION && !member.isPrivate())) {
+			if (member.getOverrides() == null) {
+				validator.logError(ValidationLogEntry.Code.OVERRIDE_MISSING_BASE, member.position, "Overridden method not identified");
+			}
+		}
+		
+		if (member.body != null) {
+			StatementValidator statementValidator = new StatementValidator(validator, scope);
+			member.body.accept(statementValidator);
+			validateThrow(member);
+		}
+	}
+	
 	private class FieldInitializerScope implements ExpressionScope {
 		private final FieldMember field;