Fixed a large number of java source compilation bugs. (ZenCode.shared module now compiles, and so does StdLib.stdlib)

CodeFormatterShared/src/main/java/org/openzen/zenscript/formattershared/StatementFormatter.java

 		if (!lineAfter.isEmpty())
 			output.append('\n').append(indent).append(lineAfter);
 	}
+	
+	@Override
+	public void writeInner(String lineBefore, String[] inlineContents, Statement contents, LoopStatement loop, String lineAfter) {
+		output.append('\n').append(indent).append(lineBefore);
+		StatementFormatter innerFormatter = new StatementFormatter(output, settings, formatter.forLoop(loop), indent + settings.indent, loop == null ? innerLoop : loop);
+		for (String inline : inlineContents)
+			output.append('\n').append(indent).append(settings.indent).append(inline);
+		if (contents instanceof BlockStatement) {
+			for (Statement statement : ((BlockStatement) contents).statements)
+				statement.accept(innerFormatter);
+		} else {
+			contents.accept(innerFormatter);
+		}
+		
+		if (!lineAfter.isEmpty())
+			output.append('\n').append(indent).append(lineAfter);
+	}
 
 	@Override
 	public void writeInnerMulti(String lineBefore, List<StatementFormattingSubBlock> contents, LoopStatement loop, String lineAfter) {
 		output.append('\n').append(indent).append(lineBefore);
 		
 		String newIndent = indent + settings.indent + settings.indent;
-		StatementFormatter inner = new StatementFormatter(output, settings, formatter, newIndent, innerLoop);
+		StatementFormatter inner = new StatementFormatter(output, settings, formatter.forLoop(loop), newIndent, innerLoop);
 		
 		for (StatementFormattingSubBlock subBlock : contents) {
 			output.append('\n').append(indent).append(settings.indent).append(subBlock.header);
 	}
 	
 	public interface Formatter {
+		public Formatter forLoop(LoopStatement statement);
+		
 		public void formatBlock(StatementFormattingTarget target, BlockStatement statement);
 	
 		public void formatBreak(StatementFormattingTarget target, BreakStatement statement);

CodeFormatterShared/src/main/java/org/openzen/zenscript/formattershared/StatementFormattingTarget.java

 	
 	void writeInner(String lineBefore, Statement contents, LoopStatement loop, String lineAfter);
 	
+	void writeInner(String lineBefore, String[] inlineContents, Statement contents, LoopStatement loop, String lineAfter);
+	
 	void writeInnerMulti(String lineBefore, List<StatementFormattingSubBlock> contents, LoopStatement loop, String lineAfter);
 	
 	void writeBlock(String lineBefore, BlockStatement contents, String lineAfter);

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

 	public final FunctionParameter[] parameters;
 	public final ITypeID thrownType;
 	
+	public final int minParameters;
+	public final int maxParameters;
+	
 	public FunctionHeader(ITypeID returnType) {
 		if (returnType == null)
 			throw new NullPointerException();
 		this.returnType = returnType;
 		this.parameters = NO_PARAMETERS;
 		this.thrownType = null;
+		
+		minParameters = 0;
+		maxParameters = 0;
 	}
 	
 	public FunctionHeader(ITypeID returnType, ITypeID... parameterTypes) {
 		
 		for (int i = 0; i < parameterTypes.length; i++)
 			parameters[i] = new FunctionParameter(parameterTypes[i], null);
+		
+		minParameters = parameterTypes.length;
+		maxParameters = parameterTypes.length;
 	}
 	
 	public FunctionHeader(ITypeID returnType, FunctionParameter... parameters) {
 		this.returnType = returnType;
 		this.parameters = parameters;
 		this.thrownType = null;
+		
+		minParameters = getMinParameters(parameters);
+		maxParameters = getMaxParameters(parameters);
 	}
 	
 	public FunctionHeader(TypeParameter[] genericParameters, ITypeID returnType, ITypeID thrownType, FunctionParameter... parameters) {
 		this.returnType = returnType;
 		this.parameters = parameters;
 		this.thrownType = thrownType;
+		
+		minParameters = getMinParameters(parameters);
+		maxParameters = getMaxParameters(parameters);
 	}
 	
 	public int getNumberOfTypeParameters() {
 		return typeParameters == null ? 0 : typeParameters.length;
 	}
 	
+	public boolean matchesExactly(CallArguments arguments, TypeScope scope) {
+		if (arguments.arguments.length < minParameters || arguments.arguments.length > maxParameters)
+			return false;
+		
+		FunctionHeader header = fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+		for (int i = 0; i < header.parameters.length; i++) {
+			if (arguments.arguments[i].type != header.parameters[i].type)
+				return false;
+		}
+		
+		return true;
+	}
+	
+	public boolean matchesImplicitly(CallArguments arguments, TypeScope scope) {
+		if (arguments.arguments.length < minParameters || arguments.arguments.length > maxParameters)
+			return false;
+		
+		FunctionHeader header = fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+		for (int i = 0; i < header.parameters.length; i++) {
+			if (!scope.getTypeMembers(arguments.arguments[i].type).canCastImplicit(header.parameters[i].type))
+				return false;
+		}
+		
+		return true;
+	}
+	
 	public String getCanonical() {
 		StringBuilder result = new StringBuilder();
 		if (getNumberOfTypeParameters() > 0) {
 		result.append(")");
 		return result.toString();
 	}
+
+	private static int getMinParameters(FunctionParameter[] parameters) {
+		for (int i = 0; i < parameters.length; i++)
+			if (parameters[i].defaultValue != null || parameters[i].variadic)
+				return i;
+		
+		return parameters.length;
+	}
+	
+	private static int getMaxParameters(FunctionParameter[] parameters) {
+		if (parameters.length == 0)
+			return 0;
+		
+		return parameters[parameters.length - 1].variadic ? Integer.MAX_VALUE : parameters.length;
+	}
 }

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

 
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionBuilder;
+import org.openzen.zenscript.codemodel.expression.PanicExpression;
 import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.statement.BlockStatement;
+import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 import org.openzen.zenscript.codemodel.statement.IfStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
-import org.openzen.zenscript.codemodel.statement.ThrowStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.shared.CodePosition;
 
 		List<Statement> statements = new ArrayList<>();
 		ExpressionBuilder expressionBuilder = new ExpressionBuilder(position, expressionScope);
 		Expression inverseCondition = expressionBuilder.not(condition);
-		Statement throwStatement = new ThrowStatement(CodePosition.BUILTIN, expressionBuilder.constructNew("stdlib.IllegalArgumentException", message));
-		statements.add(new IfStatement(CodePosition.BUILTIN, inverseCondition, throwStatement, null));
+		Statement throwStatement = new ExpressionStatement(position, new PanicExpression(position, BasicTypeID.VOID, message));
+		statements.add(new IfStatement(position, inverseCondition, throwStatement, null));
 		if (member.body instanceof BlockStatement) {
 			statements.addAll(((BlockStatement)member.body).statements);
 		} else {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/iterator/ForeachIteratorVisitor.java

 	
 	T visitArrayKeyValueIterator();
 	
+	T visitAssocKeyIterator();
+	
+	T visitAssocKeyValueIterator();
+	
 	T visitStringCharacterIterator();
 	
 	T visitCustomIterator();

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

  */
 public class CustomIteratorMember extends DefinitionMember implements IIteratorMember {
 	private final ITypeID[] iteratorTypes;
-	private Statement content;
+	public Statement body;
 	
 	public CustomIteratorMember(CodePosition position, HighLevelDefinition definition, int modifiers, ITypeID[] iteratorTypes) {
 		super(position, definition, modifiers);
 		this.iteratorTypes = iteratorTypes;
 	}
 	
-	public void setContent(Statement content) {
-		this.content = content;
+	public void setContent(Statement body) {
+		this.body = body;
 	}
 
 	@Override

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

  * @author Hoofdgebruiker
  */
 public class StaticInitializerMember extends Taggable implements IDefinitionMember {
-	private final CodePosition position;
+	public final CodePosition position;
 	public Statement body;
 	public MemberAnnotation[] annotations = MemberAnnotation.NONE;
 	

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

 
 	@Override
 	public <T> T acceptForIterator(ForeachIteratorVisitor<T> visitor) {
-		return visitor.visitArrayKeyValueIterator();
+		return visitor.visitAssocKeyValueIterator();
 	}
 }

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

 		return target.getKind() == FunctionalKind.OPERATOR;
 	}
 	
+	// TODO: shouldn't this be a call operator?
 	public boolean isCaller() {
 		return target.getKind() == FunctionalKind.CALLER;
 	}

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

  */
 package org.openzen.zenscript.codemodel.type;
 
+import java.util.List;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 		return false;
 	}
 
+	@Override
+	public void extractTypeParameters(List<TypeParameter> typeParameters) {
+		elementType.extractTypeParameters(typeParameters);
+	}
+
 	@Override
 	public int hashCode() {
 		int hash = 7;

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

  */
 package org.openzen.zenscript.codemodel.type;
 
+import java.util.List;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 		return true;
 	}
 
+	@Override
+	public void extractTypeParameters(List<TypeParameter> typeParameters) {
+		keyType.extractTypeParameters(typeParameters);
+		valueType.extractTypeParameters(typeParameters);
+	}
+
 	@Override
 	public int hashCode() {
 		int hash = 7;

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

 	public boolean hasDefaultValue() {
 		return true;
 	}
+
+	@Override
+	public void extractTypeParameters(List<TypeParameter> typeParameters) {
+		
+	}
 }

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

  */
 package org.openzen.zenscript.codemodel.type;
 
+import java.util.List;
 import java.util.Objects;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 		return baseType.isObjectType();
 	}
 
+	@Override
+	public boolean hasDefaultValue() {
+		return baseType.hasDefaultValue();
+	}
+
+	@Override
+	public void extractTypeParameters(List<TypeParameter> typeParameters) {
+		baseType.extractTypeParameters(typeParameters);
+	}
+
 	@Override
 	public int hashCode() {
 		int hash = 3;
 	public String toString() {
 		return "const " + baseType.toString();
 	}
-
-	@Override
-	public boolean hasDefaultValue() {
-		return baseType.hasDefaultValue();
-	}
 }

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

 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import org.openzen.zenscript.codemodel.GenericMapper;
 	public boolean hasDefaultValue() {
 		return definition.hasEmptyConstructor();
 	}
+
+	@Override
+	public void extractTypeParameters(List<TypeParameter> typeParameters) {
+		for (ITypeID type : this.typeParameters)
+			type.extractTypeParameters(typeParameters);
+	}
 	
 	private class OuterTypeEntry {
 		private final TypeParameter parameter;

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

 package org.openzen.zenscript.codemodel.type;
 
 import java.util.Arrays;
+import java.util.List;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.GenericMapper;
 		return false;
 	}
 
+	@Override
+	public void extractTypeParameters(List<TypeParameter> typeParameters) {
+		header.returnType.extractTypeParameters(typeParameters);
+		for (FunctionParameter parameter : header.parameters)
+			parameter.type.extractTypeParameters(typeParameters);
+	}
+
 	@Override
 	public int hashCode() {
 		int hash = 5;

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

  */
 package org.openzen.zenscript.codemodel.type;
 
+import java.util.List;
 import java.util.Objects;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 	public boolean isObjectType() {
 		return true;
 	}
+
+	@Override
+	public void extractTypeParameters(List<TypeParameter> typeParameters) {
+		value.extractTypeParameters(typeParameters);
+		typeParameters.remove(key);
+	}
 	
 	@Override
 	public String toString() {

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

  */
 package org.openzen.zenscript.codemodel.type;
 
+import java.util.List;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 		return false;
 	}
 
+	@Override
+	public void extractTypeParameters(List<TypeParameter> typeParameters) {
+		if (!typeParameters.contains(parameter))
+			typeParameters.add(parameter);
+	}
+
 	@Override
 	public int hashCode() {
 		int hash = 7;

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

  */
 package org.openzen.zenscript.codemodel.type;
 
+import java.util.List;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 		return accept(new MatchingTypeVisitor(cache, targetType, mapping));
 	}
 	
+	public void extractTypeParameters(List<TypeParameter> typeParameters);
+	
 	public static class MatchingTypeVisitor implements ITypeVisitor<Boolean> {
 		private final ITypeID type;
 		private final Map<TypeParameter, ITypeID> mapping;

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

 package org.openzen.zenscript.codemodel.type;
 
 import java.util.Arrays;
+import java.util.List;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 		return false;
 	}
 
+	@Override
+	public void extractTypeParameters(List<TypeParameter> typeParameters) {
+		for (ITypeID type : iteratorTypes)
+			type.extractTypeParameters(typeParameters);
+	}
+
 	@Override
 	public int hashCode() {
 		int hash = 5;

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

  */
 package org.openzen.zenscript.codemodel.type;
 
+import java.util.List;
 import java.util.Objects;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 		return true;
 	}
 
+	@Override
+	public void extractTypeParameters(List<TypeParameter> typeParameters) {
+		baseType.extractTypeParameters(typeParameters);
+	}
+
 	@Override
 	public int hashCode() {
 		int hash = 7;

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

  */
 package org.openzen.zenscript.codemodel.type;
 
+import java.util.List;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 		return false;
 	}
 
+	@Override
+	public void extractTypeParameters(List<TypeParameter> typeParameters) {
+		from.extractTypeParameters(typeParameters);
+		to.extractTypeParameters(typeParameters);
+	}
+
 	@Override
 	public int hashCode() {
 		int hash = 5;

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

 	GENERICMAP_GETOPTIONAL,
 	GENERICMAP_PUT,
 	GENERICMAP_CONTAINS,
+	GENERICMAP_ADDALL,
 	GENERICMAP_SIZE,
 	GENERICMAP_ISEMPTY,
 	GENERICMAP_HASHCODE,
 	RANGE_FROM,
 	RANGE_TO,
 	
+	OPTIONAL_IS_NULL,
+	OPTIONAL_IS_NOT_NULL,
 	AUTOOP_NOTEQUALS
 }

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

 	
 	public FunctionalMemberRef selectMethod(CodePosition position, TypeScope scope, CallArguments arguments, boolean allowNonStatic, boolean allowStatic) {
 		// try to match with exact types
-		outer: for (TypeMember<FunctionalMemberRef> method : methods) {
+		for (TypeMember<FunctionalMemberRef> method : methods) {
 			if (!(method.member.isStatic() ? allowStatic : allowNonStatic))
 				continue;
 			
 			FunctionHeader header = method.member.header;
-			if (header.parameters.length != arguments.arguments.length)
-				continue;
-			if (header.getNumberOfTypeParameters() != arguments.getNumberOfTypeArguments())
-				continue;
-			
-			if (arguments.typeArguments.length > 0) {
-				header = header.fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
-			}
-			
-			for (int i = 0; i < header.parameters.length; i++) {
-				if (arguments.arguments[i].type != header.parameters[i].type)
-					continue outer;
-			}
-			
-			return method.member;
+			if (header.matchesExactly(arguments, scope))
+				return method.member;
 		}
 		
 		// try to match with approximate types
 		FunctionalMemberRef selected = null;
-		outer: for (TypeMember<FunctionalMemberRef> method : methods) {
+		for (TypeMember<FunctionalMemberRef> method : methods) {
 			if (!(method.member.isStatic() ? allowStatic : allowNonStatic))
 				continue;
 			
 			FunctionHeader header = method.member.header;
-			if (header.parameters.length != arguments.arguments.length)
+			if (!header.matchesImplicitly(arguments, scope))
 				continue;
-			if (header.getNumberOfTypeParameters() != arguments.getNumberOfTypeArguments())
-				continue;
-			
-			if (arguments.typeArguments.length > 0) {
-				header = header.fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
-			}
-			
-			for (int i = 0; i < header.parameters.length; i++) {
-				if (!scope.getTypeMembers(arguments.arguments[i].type).canCastImplicit(header.parameters[i].type))
-					continue outer;
-			}
 			
 			if (selected != null) {
 				StringBuilder explanation = new StringBuilder();

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

 		method(builtin, "getOptional", getOptionalHeader, GENERICMAP_GETOPTIONAL);
 		method(builtin, "put", putHeader, GENERICMAP_PUT);
 		method(builtin, "contains", containsHeader, GENERICMAP_CONTAINS);
+		method(builtin, "addAll", new FunctionHeader(VOID, map), GENERICMAP_ADDALL);
 		
 		getter(builtin, GENERICMAP_SIZE, "size", INT);
 		getter(builtin, GENERICMAP_ISEMPTY, "isEmpty", BOOL);
 	public Void visitOptional(OptionalTypeID optional) {
 		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "optional", Modifiers.EXPORT, null);
 		optional.baseType.accept(this);
+		operator(builtin, OperatorType.EQUALS, new FunctionHeader(BOOL, NULL), BuiltinID.OPTIONAL_IS_NULL);
+		operator(builtin, OperatorType.NOTEQUALS, new FunctionHeader(BOOL, NULL), BuiltinID.OPTIONAL_IS_NOT_NULL);
 		processType(builtin, optional);
 		return null;
 	}

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

     public Void visitCustomIterator() {
         return null;
     }
+
+	@Override
+	public Void visitAssocKeyIterator() {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Void visitAssocKeyValueIterator() {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
 }

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javasource;
+
+import java.util.Collections;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.member.MemberVisitor;
+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.ITypeID;
+import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
+import org.openzen.zenscript.javasource.scope.JavaSourceStatementScope;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public abstract class BaseMemberCompiler implements MemberVisitor<Void> {
+	protected final String indent;
+	protected final StringBuilder output;
+	protected final JavaSourceFileScope scope;
+	protected final JavaSourceStatementScope fieldInitializerScope;
+	protected final JavaSourceFormattingSettings settings;
+	protected final ITypeID expansionTarget;
+	protected final HighLevelDefinition definition;
+	
+	private ElementType currentElementType = null;
+	
+	public BaseMemberCompiler(
+			JavaSourceFormattingSettings settings,
+			String indent,
+			StringBuilder output,
+			JavaSourceFileScope scope,
+			ITypeID expansionTarget,
+			HighLevelDefinition definition)
+	{
+		this.indent = indent;
+		this.output = output;
+		this.scope = scope;
+		this.settings = settings;
+		this.expansionTarget = expansionTarget;
+		this.definition = definition;
+		
+		fieldInitializerScope = new JavaSourceStatementScope(
+				scope,
+				settings,
+				null,
+				indent + settings.indent,
+				null,
+				null,
+				true);
+	}
+	
+	protected void begin(ElementType type) {
+		if (currentElementType != null) {
+			if (currentElementType != ElementType.FIELD || type != ElementType.FIELD)
+				output.append(indent).append('\n');
+		}
+		
+		this.currentElementType = type;
+	}
+	
+	protected void modifiers(int modifiers) {
+		if (Modifiers.isPublic(modifiers))
+			output.append("public ");
+		if (Modifiers.isProtected(modifiers))
+			output.append("protected ");
+		if (Modifiers.isPrivate(modifiers))
+			output.append("private ");
+		if (Modifiers.isStatic(modifiers))
+			output.append("static ");
+		if (Modifiers.isFinal(modifiers))
+			output.append("final ");
+	}
+	
+	protected void compileBody(Statement body, FunctionHeader header) {
+		if (body == null || body instanceof EmptyStatement) {
+			output.append(";\n");
+		} else {
+			if (!(body instanceof BlockStatement))
+				body = new BlockStatement(body.position, Collections.singletonList(body));
+			
+			JavaSourceStatementScope scope = new JavaSourceStatementScope(this.scope, settings, header, indent + settings.indent, null, null, expansionTarget != null);
+			body.accept(new JavaSourceStatementCompiler(scope, output, true, false));
+			output.append('\n');
+		}
+	}
+	
+	protected void formatParameters(boolean isStatic, FunctionHeader header) {
+		formatParameters(isStatic, null, header);
+	}
+	
+	protected void formatParameters(boolean isStatic, TypeParameter[] targetTypeParameters, FunctionHeader header) {
+		output.append("(");
+		boolean first = true;
+		if (expansionTarget != null && !isStatic) {
+			if (targetTypeParameters != null) {
+				for (TypeParameter parameter : targetTypeParameters) {
+					if (first)
+						first = false;
+					else
+						output.append(", ");
+
+					output.append("Class<").append(parameter.name).append("> typeOf").append(parameter.name);
+				}
+			}
+			if (first)
+				first = false;
+			else
+				output.append(", ");
+			
+			output.append(scope.type(expansionTarget));
+			output.append(" self");
+		}
+		if (header.typeParameters != null) {
+			for (TypeParameter typeParameter : header.typeParameters) {
+				if (first)
+					first = false;
+				else
+					output.append(", ");
+
+				output.append("Class<")
+						.append(typeParameter.name)
+						.append(">")
+						.append(" ")
+						.append("typeOf")
+						.append(typeParameter.name);
+			}
+		}
+		
+		for (int i = 0; i < header.parameters.length; i++) {
+			if (first)
+				first = false;
+			else
+				output.append(", ");
+			
+			FunctionParameter parameter = header.parameters[i];
+			output.append(scope.type(parameter.type));
+			output.append(" ").append(parameter.name);
+			if (parameter.variadic)
+				output.append("...");
+		}
+		output.append(")");
+		
+		if (header.thrownType != null) {
+			output.append(" throws ");
+			output.append(scope.type(header.thrownType));
+		}
+	}
+	
+	public enum ElementType {
+		STATICINIT,
+		FIELD,
+		CONSTRUCTOR,
+		METHOD,
+		INNERCLASS
+	}
+}

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

 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.compiler.CompileScope;
+import org.openzen.zenscript.compiler.SemanticModule;
+import org.openzen.zenscript.javasource.prepare.JavaNativeClass;
 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
+import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class JavaDefinitionVisitor implements DefinitionVisitor<Void> {
-	private final JavaSourceFileScope scope;
+	private final JavaSourceCompiler compiler;
+	private final JavaSourceClass cls;
+	private final JavaSourceFile file;
 	private final JavaSourceFormattingSettings settings;
+	private final List<ExpansionDefinition> expansions;
 	private final StringBuilder output;
+	private final Map<HighLevelDefinition, SemanticModule> modules;
 	
-	public JavaDefinitionVisitor(JavaSourceFormattingSettings settings, JavaSourceFileScope scope, StringBuilder output) {
-		this.settings = settings;
-		this.scope = scope;
+	public JavaDefinitionVisitor(
+			JavaSourceCompiler compiler,
+			JavaSourceClass cls,
+			JavaSourceFile file,
+			StringBuilder output,
+			List<ExpansionDefinition> expansions,
+			Map<HighLevelDefinition, SemanticModule> modules)
+	{
+		this.compiler = compiler;
+		this.cls = cls;
+		this.file = file;
+		this.settings = compiler.settings;
 		this.output = output;
+		this.expansions = expansions;
+		this.modules = modules;
+	}
+	
+	private JavaSourceFileScope createScope(HighLevelDefinition definition) {
+		SemanticModule module = modules.get(definition);
+		CompileScope scope = new CompileScope(definition.access, module.compilationUnit.globalTypeRegistry, module.expansions, module.annotations);
+		return new JavaSourceFileScope(file.importer, compiler.typeGenerator, compiler.helperGenerator, cls, scope, definition instanceof InterfaceDefinition);
 	}
 
 	@Override
 	public Void visitClass(ClassDefinition definition) {
+		JavaSourceFileScope scope = createScope(definition);
+		
 		convertModifiers(definition.modifiers);
 		output.append("class ").append(definition.name);
-		JavaSourceUtils.formatTypeParameters(scope, output, definition.genericParameters);
+		JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, definition.genericParameters);
 		if (definition.superType != null) {
 			output.append(" extends ");
 			output.append(scope.type(definition.superType));
 		}
 		
 		output.append(" {\n");
-		compileMembers(definition);
+		compileMembers(scope, definition);
+		compileExpansions();
 		output.append("}\n");
 		return null;
 	}
 
 	@Override
 	public Void visitInterface(InterfaceDefinition definition) {
+		JavaSourceFileScope scope = createScope(definition);
+		
 		convertModifiers(definition.modifiers | Modifiers.VIRTUAL); // to prevent 'final'
 		output.append("interface ").append(definition.name);
-		JavaSourceUtils.formatTypeParameters(scope, output, definition.genericParameters);
+		JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, definition.genericParameters);
 		output.append(" {\n");
-		compileMembers(definition);
+		compileMembers(scope, definition);
+		compileExpansions();
 		output.append("}\n");
 		return null;
 	}
 
 	@Override
 	public Void visitEnum(EnumDefinition definition) {
+		JavaSourceFileScope scope = createScope(definition);
+		
 		convertModifiers(definition.modifiers | Modifiers.VIRTUAL); // to prevent 'final'
 		output.append("enum ").append(definition.name);
 		
 		
 		if (definition.members.size() > 0) {
 			output.append(";\n");
-			compileMembers(definition);
+			compileMembers(scope, definition);
 		} else {
 			output.append("\n");
 		}
 		
+		compileExpansions();
 		output.append("}\n");
 		return null;
 	}
 
 	@Override
 	public Void visitStruct(StructDefinition definition) {
+		JavaSourceFileScope scope = createScope(definition);
+		
 		convertModifiers(definition.modifiers | Modifiers.FINAL);
 		output.append("class ").append(definition.name);
-		JavaSourceUtils.formatTypeParameters(scope, output, definition.genericParameters);
+		JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, definition.genericParameters);
 		output.append(" {\n");
-		compileMembers(definition);
+		compileMembers(scope, definition);
+		compileExpansions();
 		output.append("}\n");
 		return null;
 	}
 
 	@Override
 	public Void visitFunction(FunctionDefinition definition) {
+		JavaSourceFileScope scope = createScope(definition);
+		
 		convertModifiers(definition.modifiers | Modifiers.STATIC);
 		
 		return null;
 
 	@Override
 	public Void visitExpansion(ExpansionDefinition definition) {
+		JavaSourceFileScope scope = createScope(definition);
+		
 		convertModifiers(definition.modifiers);
 		output.append("class ");
-		output.append(scope.className);
+		output.append(cls.name);
 		output.append(" {\n");
-		output.append(settings.indent).append("private ").append(scope.className).append("() {}\n");
+		output.append(settings.indent).append("private ").append(cls.name).append("() {}\n");
 		
-		JavaExpansionMemberCompiler memberCompiler = new JavaExpansionMemberCompiler(settings, definition.target, "\t", output, scope);
+		JavaExpansionMemberCompiler memberCompiler = new JavaExpansionMemberCompiler(settings, definition.target, definition.genericParameters, "\t", output, scope, definition);
 		for (IDefinitionMember member : definition.members)
 			member.accept(memberCompiler);
 		memberCompiler.finish();
 		
+		compileExpansions();
 		output.append("}");
 		return null;
 	}
 
 	@Override
 	public Void visitVariant(VariantDefinition variant) {
+		JavaSourceFileScope scope = createScope(variant);
+		
 		convertModifiers(variant.modifiers | Modifiers.VIRTUAL | Modifiers.ABSTRACT);
 		output.append("class ").append(variant.name);
-		JavaSourceUtils.formatTypeParameters(scope, output, variant.genericParameters);
+		JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, variant.genericParameters);
 		output.append("{\n");
-		compileMembers(variant);
+		compileMembers(scope, variant);
 		output.append(settings.indent).append("public abstract Discriminant getDiscriminant();\n");
 		
 		output.append(settings.indent).append("\n");
 		for (VariantDefinition.Option option : variant.options) {
 			output.append(settings.indent).append("\n");
 			output.append(settings.indent).append("public static class ").append(option.name);
-			JavaSourceUtils.formatTypeParameters(scope, output, variant.genericParameters);
+			JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, variant.genericParameters);
 			output.append(" extends ");
 			output.append(variant.name);
 			if (variant.genericParameters != null && variant.genericParameters.length > 0) {
 			output.append(settings.indent).append("}\n");
 		}
 		
+		compileExpansions();
 		output.append("}\n");
 		return null;
 	}
 	
+	private void compileExpansions() {
+		for (ExpansionDefinition definition : expansions) {
+			JavaSourceFileScope scope = createScope(definition);
+			JavaExpansionMemberCompiler memberCompiler = new JavaExpansionMemberCompiler(settings, definition.target, definition.genericParameters, "\t", output, scope, definition);
+			for (IDefinitionMember member : definition.members)
+				member.accept(memberCompiler);
+			memberCompiler.finish();
+		}
+	}
+	
 	private void convertModifiers(int modifiers) {
 		if (Modifiers.isExport(modifiers) || Modifiers.isPublic(modifiers))
 			output.append("public ");
 		return true; // TODO: check merging conflicts
 	}
 	
-	private void compileMembers(HighLevelDefinition definition) {
-		JavaMemberCompiler memberCompiler = new JavaMemberCompiler(settings, "\t", output, scope, false, scope.isInterface);
-		for (IDefinitionMember member : definition.members)
-			member.accept(memberCompiler);
-		memberCompiler.finish();
+	private void compileMembers(JavaSourceFileScope scope, HighLevelDefinition definition) {
+		if (definition.hasTag(JavaNativeClass.class)) {
+			ITypeID[] typeParameters = new ITypeID[definition.getNumberOfGenericParameters()];
+			for (int i = 0; i < typeParameters.length; i++)
+				typeParameters[i] = scope.semanticScope.getTypeRegistry().getGeneric(definition.genericParameters[i]);
+			ITypeID targetType = new DefinitionTypeID(definition, typeParameters);
+			
+			JavaExpansionMemberCompiler memberCompiler = new JavaExpansionMemberCompiler(settings, targetType, definition.genericParameters, "\t", output, scope, definition);
+			for (IDefinitionMember member : definition.members)
+				member.accept(memberCompiler);
+			memberCompiler.finish();
+		} else {
+			JavaMemberCompiler memberCompiler = new JavaMemberCompiler(settings, "\t", output, scope, scope.isInterface, definition);
+			for (IDefinitionMember member : definition.members)
+				member.accept(memberCompiler);
+			memberCompiler.finish();
+		}
 	}
 }

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

 package org.openzen.zenscript.javasource;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
-import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 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.ConstructorMember;
 import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
+import org.openzen.zenscript.codemodel.member.DefinitionMember;
 import org.openzen.zenscript.codemodel.member.DestructorMember;
 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.InnerDefinitionMember;
-import org.openzen.zenscript.codemodel.member.MemberVisitor;
 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.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;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
-import org.openzen.zenscript.javasource.scope.JavaSourceStatementScope;
-import org.openzen.zenscript.shared.StringUtils;
+import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class JavaExpansionMemberCompiler implements MemberVisitor<Void> {
-	private final String indent;
-	private final StringBuilder output;
-	private final JavaSourceFileScope scope;
-	private final JavaSourceStatementScope fieldInitializerScope;
-	private final JavaSourceFormattingSettings settings;
+public class JavaExpansionMemberCompiler extends BaseMemberCompiler {
 	private final List<FieldMember> fields = new ArrayList<>();
-	private final ITypeID targetType;
-	private boolean first = true;
+	private final TypeParameter[] expansionTypeParameters;
 	
-	public JavaExpansionMemberCompiler(JavaSourceFormattingSettings settings, ITypeID targetType, String indent, StringBuilder output, JavaSourceFileScope scope) {
-		this.indent = indent;
-		this.output = output;
-		this.scope = scope;
-		this.settings = settings;
-		this.targetType = targetType;
+	public JavaExpansionMemberCompiler(
+			JavaSourceFormattingSettings settings,
+			ITypeID targetType,
+			TypeParameter[] expansionTypeParameters,
+			String indent,
+			StringBuilder output,
+			JavaSourceFileScope scope,
+			HighLevelDefinition definition)
+	{
+		super(settings, indent, output, scope, targetType, definition);
 		
-		fieldInitializerScope = new JavaSourceStatementScope(
-				scope,
-				settings,
-				null,
-				indent + settings.indent,
-				null,
-				null,
-				true);
+		this.expansionTypeParameters = expansionTypeParameters;
 	}
 	
-	private void addSpacing() {
-		if (first)
-			first = false;
+	private void compileMethod(DefinitionMember member, FunctionHeader header, Statement body) {
+		JavaSourceMethod method = member.getTag(JavaSourceMethod.class);
+		if (method == null)
+			throw new AssertionError();
+		if (!method.compile)
+			return;
+		
+		begin(ElementType.METHOD);
+		output.append(indent);
+		
+		modifiers(member.modifiers | Modifiers.STATIC);
+		if (member.isStatic())
+			JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, header.typeParameters);
 		else
-			output.append(indent).append("\n");
+			JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, expansionTypeParameters, header.typeParameters);
+		
+		output.append(header.returnType.accept(scope.typeVisitor));
+		output.append(" ");
+		output.append(method.name);
+		formatParameters(member.isStatic(), expansionTypeParameters, header);
+		compileBody(body, header);
 	}
 	
 	@Override
 	public Void visitConst(ConstMember member) {
+		begin(ElementType.FIELD);
 		modifiers(member.modifiers | Modifiers.STATIC | Modifiers.FINAL);
 		output.append(scope.type(member.type));
 		output.append(" ");
 
 	@Override
 	public Void visitField(FieldMember member) {
-		// TODO: nonstatic fields!
-		first = false;
+		begin(ElementType.FIELD);
 		
 		output.append(indent);
 		int modifiers = 0;
 
 	@Override
 	public Void visitConstructor(ConstructorMember member) {
-		// TODO: constructors
-		/*addSpacing();
-		
-		output.append(indent);
-		modifiers(member.modifiers);
-		JavaSourceUtils.formatTypeParameters(importer, output, member.header.typeParameters);
-		output.append(importer.getName());
-		formatParameters(true, member.header);
-		compileBody(member.body, member.header);*/
-		throw new UnsupportedOperationException("Expansions cannot declare constructors yet");
+		compileMethod(member, member.header, member.body);
+		return null;
 	}
 
 	@Override
 
 	@Override
 	public Void visitMethod(MethodMember member) {
-		addSpacing();
-		
-		output.append(indent);
-		
-		modifiers(member.modifiers | Modifiers.STATIC);
-		JavaSourceUtils.formatTypeParameters(scope, output, member.header.typeParameters);
-		output.append(scope.type(member.header.returnType));
-		output.append(" ");
-		output.append(member.name);
-		formatParameters(member.isStatic(), member.header);
-		compileBody(member.body, member.header);
+		compileMethod(member, member.header, member.body);
 		return null;
 	}
 
 	@Override
 	public Void visitGetter(GetterMember member) {
-		addSpacing();
-		
-		output.append(indent);
-		modifiers(member.modifiers | Modifiers.STATIC);
-		output.append(scope.type(member.type));
-		output.append(" ");
-		output.append("get").append(StringUtils.capitalize(member.name));
-		output.append("()");
-		compileBody(member.body, member.header);
+		compileMethod(member, member.header, member.body);
 		return null;
 	}
 
 	@Override
 	public Void visitSetter(SetterMember member) {
-		addSpacing();
-		
-		output.append(indent);
-		modifiers(member.modifiers | Modifiers.STATIC);
-		output.append("void set").append(StringUtils.capitalize(member.name));
-		output.append("(");
-		output.append(scope.type(member.type));
-		output.append(" ");
-		output.append("value");
-		output.append(")");
-		compileBody(member.body, member.header);
+		compileMethod(member, new FunctionHeader(BasicTypeID.VOID, new FunctionParameter(member.type, "value")), member.body);
 		return null;
 	}
 
 	@Override
 	public Void visitOperator(OperatorMember member) {
-		addSpacing();
-		
-		output.append(indent);
-		modifiers(member.modifiers | Modifiers.STATIC);
-		output.append(scope.type(member.header.returnType));
-		output.append(' ');
-		output.append(getOperatorName(member.operator));
-		formatParameters(member.isStatic(), member.header);
-		compileBody(member.body, member.header);
+		compileMethod(member, member.header, member.body);
 		return null;
 	}
 
 	@Override
 	public Void visitCaster(CasterMember member) {
-		addSpacing();
-		
-		output.append(indent);
-		modifiers(member.modifiers | Modifiers.STATIC);
-		output.append(scope.type(member.toType));
-		output.append(" ");
-		output.append("to").append(member.toType.accept(new JavaSourceTypeNameVisitor()));
-		output.append("(").append(scope.type(targetType)).append(" self)");
-		compileBody(member.body, member.header);
+		compileMethod(member, member.header, member.body);
 		return null;
 	}
 
 	@Override
 	public Void visitCustomIterator(CustomIteratorMember member) {
-		addSpacing();
-		
+		compileMethod(member, new FunctionHeader(scope.semanticScope.getTypeRegistry().getIterator(member.getLoopVariableTypes())), member.body);
 		return null;
 	}
 
 	@Override
 	public Void visitCaller(CallerMember member) {
-		addSpacing();
-		
+		compileMethod(member, member.header, member.body);
 		return null;
 	}
 
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
+		// TODO
 		return null;
 	}
 
 	@Override
 	public Void visitInnerDefinition(InnerDefinitionMember member) {
+		// TODO
 		return null;
 	}
 
 	@Override
 	public Void visitStaticInitializer(StaticInitializerMember member) {
-		addSpacing();
+		begin(ElementType.STATICINIT);
 		output.append(indent).append("static ");
 		compileBody(member.body, new FunctionHeader(BasicTypeID.VOID));
 		return null;
 				visitSetter(field.autoSetter);
 		}
 	}
-	
-	private void modifiers(int modifiers) {
-		if (Modifiers.isPublic(modifiers))
-			output.append("public ");
-		if (Modifiers.isProtected(modifiers))
-			output.append("protected ");
-		if (Modifiers.isPrivate(modifiers))
-			output.append("private ");
-		if (Modifiers.isStatic(modifiers))
-			output.append("static ");
-		if (Modifiers.isFinal(modifiers))
-			output.append("final ");
-	}
-	
-	private void compileBody(Statement body, FunctionHeader header) {
-		if (body == null) {
-			output.append(";\n");
-		} else {
-			if (!(body instanceof BlockStatement))
-				body = new BlockStatement(body.position, Collections.singletonList(body));
-			
-			JavaSourceStatementScope scope = new JavaSourceStatementScope(this.scope, settings, header, indent + settings.indent, null, null, true);
-			body.accept(new JavaSourceStatementCompiler(scope, output, true, false));
-			output.append('\n');
-		}
-	}
-	
-	private void formatParameters(boolean isStatic, FunctionHeader header) {
-		output.append("(");
-		boolean first = true;
-		if (!isStatic) {
-			first = false;
-			output.append(scope.type(targetType));
-			output.append(" self");
-		}
-		if (header.typeParameters != null) {
-			for (TypeParameter typeParameter : header.typeParameters) {
-				if (first)
-					first = false;
-				else
-					output.append(", ");
-
-				output.append("Class<")
-						.append(typeParameter.name)
-						.append(">")
-						.append(" ")
-						.append("typeOf")
-						.append(typeParameter.name);
-			}
-		}
-		
-		for (int i = 0; i < header.parameters.length; i++) {
-			if (first)
-				first = false;
-			else
-				output.append(", ");
-			
-			FunctionParameter parameter = header.parameters[i];
-			output.append(scope.type(parameter.type));
-			output.append(" ").append(parameter.name);
-			if (parameter.variadic)
-				output.append("...");
-		}
-		output.append(")");
-	}
-	
-	private String getOperatorName(OperatorType operator) {
-		switch (operator) {
-			case NEG:
-				return "negate";
-			case NOT:
-				return "invert";
-			case ADD:
-				return "add";
-			case ADDASSIGN:
-				return "addAssign";
-			case SUB:
-				return "subtract";
-			case SUBASSIGN:
-				return "subAssign";
-			case CAT:
-				return "concat";
-			case CATASSIGN:
-				return "append";
-			case MUL:
-				return "mul";
-			case MULASSIGN:
-				return "mulAssign";
-			case DIV:
-				return "div";
-			case DIVASSIGN:
-				return "divAssign";
-			case MOD:
-				return "mod";
-			case MODASSIGN:
-				return "modAssign";
-			case AND:
-				return "and";
-			case ANDASSIGN:
-				return "andAssign";
-			case OR:
-				return "or";
-			case ORASSIGN:
-				return "orAssign";
-			case XOR:
-				return "xor";
-			case XORASSIGN:
-				return "xorAssign";
-			case SHL:
-				return "shl";
-			case SHLASSIGN:
-				return "shlAssign";
-			case SHR:
-				return "shr";
-			case SHRASSIGN:
-				return "shrAssign";
-			case USHR:
-				return "ushr";
-			case USHRASSIGN:
-				return "ushrAssign";
-			case INDEXGET:
-				return "getAt";
-			case INDEXSET:
-				return "setAt";
-			case INCREMENT:
-				return "increment";
-			case DECREMENT:
-				return "decrement";
-			case CONTAINS:
-				return "contains";
-			case EQUALS:
-				return "equals";
-			case COMPARE:
-				return "compareTo";
-			case RANGE:
-				return "until";
-			case CAST:
-				return "cast";
-			case CALL:
-				return "call";
-			case MEMBERGETTER:
-				return "getMember";
-			case MEMBERSETTER:
-				return "setMember";
-			default:
-				throw new IllegalArgumentException("Invalid operator: " + operator);
-		}
-	}
 }

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

 package org.openzen.zenscript.javasource;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
 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.ConstructorMember;
 import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
+import org.openzen.zenscript.codemodel.member.DefinitionMember;
 import org.openzen.zenscript.codemodel.member.DestructorMember;
 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.InnerDefinitionMember;
-import org.openzen.zenscript.codemodel.member.MemberVisitor;
 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.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;
 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
-import org.openzen.zenscript.javasource.scope.JavaSourceStatementScope;
 import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
-import org.openzen.zenscript.shared.StringUtils;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class JavaMemberCompiler implements MemberVisitor<Void> {
-	private final String indent;
-	private final StringBuilder output;
-	private final JavaSourceFileScope scope;
-	private final JavaSourceStatementScope fieldInitializerScope;
-	private final JavaSourceFormattingSettings settings;
+public class JavaMemberCompiler extends BaseMemberCompiler {
 	private final List<FieldMember> fields = new ArrayList<>();
-	private final boolean isExpansion;
 	private final boolean isInterface;
-	private boolean first = true;
 	
-	public JavaMemberCompiler(JavaSourceFormattingSettings settings, String indent, StringBuilder output, JavaSourceFileScope scope, boolean isExpansion, boolean isInterface) {
-		this.indent = indent;
-		this.output = output;
-		this.scope = scope;
-		this.settings = settings;
-		this.isExpansion = isExpansion;
-		this.isInterface = isInterface;
+	public JavaMemberCompiler(
+			JavaSourceFormattingSettings settings,
+			String indent,
+			StringBuilder output,
+			JavaSourceFileScope scope,
+			boolean isInterface,
+			HighLevelDefinition definition)
+	{
+		super(settings, indent, output, scope, null, definition);
 		
-		fieldInitializerScope = new JavaSourceStatementScope(
-				scope,
-				settings,
-				null,
-				indent + settings.indent,
-				null,
-				null,
-				isExpansion);
+		this.isInterface = isInterface;
 	}
 	
-	private void addSpacing() {
-		if (first)
-			first = false;
+	private void compileMethod(DefinitionMember member, FunctionHeader header, Statement body) {
+		JavaSourceMethod method = member.getTag(JavaSourceMethod.class);
+		if (method == null)
+			throw new AssertionError();
+		if (!method.compile)
+			return;
+		
+		boolean hasBody = body != null && !(body instanceof EmptyStatement);
+		if (isInterface && method.name.equals("toString") && header.parameters.length == 0) {
+			hasBody = false;
+		}
+			
+		
+		begin(ElementType.METHOD);
+		output.append(indent);
+		if (isInterface && hasBody)
+			output.append("default ");
+		
+		modifiers(member.modifiers);
+		JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, header.typeParameters);
+		output.append(header.returnType.accept(scope.typeVisitor));
+		output.append(" ");
+		output.append(method.name);
+		formatParameters(member.isStatic(), header);
+		
+		if (hasBody)
+			compileBody(body, header);
 		else
-			output.append(indent).append("\n");
+			output.append(";\n");
 	}
 	
 	@Override
 	public Void visitConst(ConstMember member) {
+		begin(ElementType.FIELD);
+		
 		output.append(indent);
 		modifiers(member.modifiers | Modifiers.STATIC | Modifiers.FINAL);
 		output.append(scope.type(member.type));
 
 	@Override
 	public Void visitField(FieldMember member) {
-		first = false;
+		begin(ElementType.FIELD);
 		
 		output.append(indent);
 		int modifiers = 0;
 
 	@Override
 	public Void visitConstructor(ConstructorMember member) {
-		addSpacing();
+		begin(ElementType.CONSTRUCTOR);
 		
 		output.append(indent);
 		modifiers(member.modifiers);
-		JavaSourceUtils.formatTypeParameters(scope, output, member.header.typeParameters);
-		output.append(scope.className);
-		formatParameters(member.header);
+		JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, member.header.typeParameters);
+		output.append(scope.cls.name);
+		formatParameters(member.isStatic(), member.header);
 		compileBody(member.body, member.header);
 		return null;
 	}
 
 	@Override
 	public Void visitDestructor(DestructorMember member) {
-		addSpacing();
+		begin(ElementType.METHOD);
 		
 		output.append(indent).append("@Override\n");
 		output.append(indent).append("public void close()");
 
 	@Override
 	public Void visitMethod(MethodMember member) {
-		addSpacing();
-		
-		
-		output.append(indent);
-		if (isInterface && member.body != null && !(member.body instanceof EmptyStatement))
-			output.append("default ");
-		
-		modifiers(member.modifiers);
-		JavaSourceUtils.formatTypeParameters(scope, output, member.header.typeParameters);
-		output.append(member.header.returnType.accept(scope.typeVisitor));
-		output.append(" ");
-		output.append(member.name);
-		formatParameters(member.header);
-		compileBody(member.body, member.header);
+		compileMethod(member, member.header, member.body);
 		return null;
 	}
 
 	@Override
 	public Void visitGetter(GetterMember member) {
-		addSpacing();
-		
-		output.append(indent);
-		if (isInterface && member.body != null && !(member.body instanceof EmptyStatement))
-			output.append("default ");
-		
-		modifiers(member.modifiers);
-		output.append(scope.type(member.type));
-		output.append(" ");
-		output.append("get").append(StringUtils.capitalize(member.name));
-		output.append("()");
-		compileBody(member.body, member.header);
+		compileMethod(member, member.header, member.body);
 		return null;
 	}
 
 	@Override
 	public Void visitSetter(SetterMember member) {
-		addSpacing();
-		
-		output.append(indent);
-		if (isInterface && member.body != null && !(member.body instanceof EmptyStatement))
-			output.append("default ");
-		
-		modifiers(member.modifiers);
-		output.append("void set").append(StringUtils.capitalize(member.name));
-		output.append("(");
-		output.append(scope.type(member.type));
-		output.append(" ");
-		output.append("value");
-		output.append(")");
-		compileBody(member.body, member.header);
+		compileMethod(member, new FunctionHeader(BasicTypeID.VOID, new FunctionParameter(member.type, "value")), member.body);
 		return null;
 	}
 
 	@Override
 	public Void visitOperator(OperatorMember member) {
-		addSpacing();
-		JavaSourceMethod method = member.getTag(JavaSourceMethod.class);
-		if (method == null)
-			throw new IllegalStateException("Missing method tag!");
-		
-		output.append(indent);
-		if (isInterface && member.body != null && !(member.body instanceof EmptyStatement))
-			output.append("default ");
-		
-		modifiers(member.modifiers);
-		output.append(scope.type(member.header.returnType));
-		output.append(' ');
-		output.append(method.name);
-		formatParameters(member.header);
-		compileBody(member.body, member.header);
+		compileMethod(member, member.header, member.body);
 		return null;
 	}
 
 	@Override
 	public Void visitCaster(CasterMember member) {
-		addSpacing();
-		
-		output.append(indent);
-		if (isInterface && member.body != null && !(member.body instanceof EmptyStatement))
-			output.append("default ");
-		
-		modifiers(member.modifiers);
-		output.append(scope.type(member.toType));
-		output.append(" ");
-		output.append("to").append(member.toType.accept(new JavaSourceTypeNameVisitor()));
-		output.append("()");
-		compileBody(member.body, member.header);
+		compileMethod(member, new FunctionHeader(member.toType), member.body);
 		return null;
 	}
 
 	@Override
 	public Void visitCustomIterator(CustomIteratorMember member) {
-		addSpacing();
-		
+		compileMethod(member, new FunctionHeader(scope.semanticScope.getTypeRegistry().getIterator(member.getLoopVariableTypes())), member.body);
 		return null;
 	}
 
 	@Override
 	public Void visitCaller(CallerMember member) {
-		addSpacing();
-		
+		compileMethod(member, member.header, member.body);
 		return null;
 	}
 
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
+		// TODO
 		return null;
 	}
 
 	@Override
 	public Void visitInnerDefinition(InnerDefinitionMember member) {
+		// TODO
 		return null;
 	}
 
 	@Override
 	public Void visitStaticInitializer(StaticInitializerMember member) {
-		addSpacing();
+		begin(ElementType.STATICINIT);
 		output.append(indent).append("static");
 		compileBody(member.body, new FunctionHeader(BasicTypeID.VOID));
 		return null;
 				visitSetter(field.autoSetter);
 		}
 	}
-	
-	private void modifiers(int modifiers) {
-		if (Modifiers.isPublic(modifiers))
-			output.append("public ");
-		if (Modifiers.isProtected(modifiers))
-			output.append("protected ");
-		if (Modifiers.isPrivate(modifiers))
-			output.append("private ");
-		if (Modifiers.isStatic(modifiers))
-			output.append("static ");
-		if (Modifiers.isFinal(modifiers))
-			output.append("final ");
-	}
-	
-	private void compileBody(Statement body, FunctionHeader header) {
-		if (body == null || body instanceof EmptyStatement) {
-			output.append(";\n");
-		} else {
-			if (!(body instanceof BlockStatement))
-				body = new BlockStatement(body.position, Collections.singletonList(body));
-			
-			JavaSourceStatementScope scope = new JavaSourceStatementScope(this.scope, settings, header, indent + settings.indent, null, null, isExpansion);
-			body.accept(new JavaSourceStatementCompiler(scope, output, true, false));
-			output.append('\n');
-		}
-	}
-	
-	private void formatParameters(FunctionHeader header) {
-		output.append("(");
-		boolean first = true;
-		if (header.typeParameters != null) {
-			for (TypeParameter typeParameter : header.typeParameters) {
-				if (first)
-					first = false;
-				else
-					output.append(", ");
-
-				output.append("Class<")
-						.append(typeParameter.name)
-						.append(">")
-						.append(" ")
-						.append("typeOf")
-						.append(typeParameter.name);
-			}
-		}
-		
-		for (int i = 0; i < header.parameters.length; i++) {
-			if (first)
-				first = false;
-			else
-				output.append(", ");
-			
-			FunctionParameter parameter = header.parameters[i];
-			output.append(scope.type(parameter.type));
-			output.append(" ").append(parameter.name);
-			if (parameter.variadic)
-				output.append("...");
-		}
-		output.append(")");
-	}
 }

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

 import java.util.Map;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.ScriptBlock;
-import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.compiler.CompilationUnit;
 import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.compiler.ZenCodeCompiler;
+import org.openzen.zenscript.javasource.prepare.JavaSourcePrepareDefinitionVisitor;
+import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 import org.openzen.zenscript.shared.SourceFile;
 
 /**
 	private final File directory;
 	private final Map<File, JavaSourceFile> sourceFiles = new HashMap<>();
 	
+	private final Map<String, Integer> classNameCounters = new HashMap<>();
+	
 	public JavaSourceCompiler(File directory, CompilationUnit compilationUnit) {
 		if (!directory.exists())
 			directory.mkdirs();
 	
 	@Override
 	public void addDefinition(HighLevelDefinition definition, SemanticModule module) {
-		File file = new File(getDirectory(definition.pkg), definition.name + ".java");
-		if (definition.name == null || definition instanceof FunctionDefinition) {
-			SourceFile source = definition.getTag(SourceFile.class);
-			if (source != null) {
-				int slash = Math.max(source.filename.lastIndexOf('/'), source.filename.lastIndexOf('\\'));
-				String filename = source.filename.substring(slash < 0 ? 0 : slash);
-				filename = filename.substring(0, filename.lastIndexOf('.'));
-				file = new File(getDirectory(definition.pkg), filename + ".java");
-			}
-		}
+		String filename = getFilename(definition);
+		JavaSourcePrepareDefinitionVisitor prepare = new JavaSourcePrepareDefinitionVisitor(filename);
+		JavaSourceClass cls = definition.accept(prepare);
+		if (cls.empty)
+			return;
 		
+		File file = new File(getDirectory(definition.pkg), cls.name + ".java");
+		System.out.println("Compiling " + definition.name + " as " + cls.fullName);
 		JavaSourceFile sourceFile = sourceFiles.get(file);
 		if (sourceFile == null)
-			sourceFiles.put(file, sourceFile = new JavaSourceFile(this, file, definition.pkg));
+			sourceFiles.put(file, sourceFile = new JavaSourceFile(this, file, cls, definition.pkg));
 		
 		sourceFile.add(definition, module);
 	}
 		File base = getDirectory(pkg.parent);
 		return new File(base, pkg.name.replace('.', '/'));
 	}
+	
+	private String getFilename(HighLevelDefinition definition) {
+		SourceFile source = definition.getTag(SourceFile.class);
+		if (source != null) {
+			int slash = Math.max(source.filename.lastIndexOf('/'), source.filename.lastIndexOf('\\'));
+			String filename = source.filename.substring(slash < 0 ? 0 : slash + 1);
+			filename = filename.substring(0, filename.lastIndexOf('.'));
+			return filename;
+		} else {
+			return definition.name == null ? "Expansion" : definition.name;
+		}
+	}
 }

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

 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
  * @author Hoofdgebruiker
  */
 public class JavaSourceExpressionFormatter implements ExpressionVisitor<ExpressionString> {
-	private final JavaSourceStatementScope scope;
-	private final StatementFormattingTarget target;
+	private static final JavaSourceClass RESULT = new JavaSourceClass("stdlib", "Result");
+	private static final JavaSourceClass RESULT_OK = new JavaSourceClass("stdlib", "Result.Ok");
+	private static final JavaSourceClass RESULT_ERROR = new JavaSourceClass("stdlib", "Result.Error");
+	
+	public final JavaSourceStatementScope scope;
+	public final StatementFormattingTarget target;
 	
 	public JavaSourceExpressionFormatter(StatementFormattingTarget target, JavaSourceStatementScope scope) {
 		this.target = target;
 		switch (method.kind) {
 			case EXPANSION: {
 				StringBuilder output = new StringBuilder();
-				output.append(scope.sourceClass(method.cls));
+				output.append(scope.type(method.cls));
 				output.append('.');
 				output.append(method.name);
 				FormattingUtils.formatExpansionCall(output, this.target, scope, target.accept(this), arguments);
 			throw new IllegalStateException("No source method tag for " + expression.member.getCanonicalName() + "!");
 		
 		StringBuilder result = new StringBuilder();
-		result.append(scope.sourceClass(method.cls));
+		result.append(scope.type(method.cls));
 		result.append('.');
 		result.append(method.name);
 		FormattingUtils.formatCall(result, target, scope, expression.arguments);
 		if (expression.constructor.getBuiltin() != null)
 			return visitBuiltinConstructor(expression);
 		
-		StringBuilder result = new StringBuilder();
-		result.append("new ");
-		result.append(scope.type(expression.type));
-		FormattingUtils.formatCall(result, target, scope, expression.arguments);
-		return new ExpressionString(result.toString(), JavaOperator.PRIMARY);
+		JavaSourceMethod method = expression.constructor.getTag(JavaSourceMethod.class);
+		switch (method.kind) {
+			case EXPANSION: {
+				StringBuilder output = new StringBuilder();
+				output.append(scope.type(method.cls));
+				output.append('.');
+				output.append(method.name);
+				FormattingUtils.formatCall(output, this.target, scope, expression.arguments);
+				return new ExpressionString(output.toString(), JavaOperator.CALL);
+			}
+			case CONSTRUCTOR: {
+				StringBuilder output = new StringBuilder();
+				output.append("new ");
+				output.append(scope.type(expression.type, method.cls));
+				FormattingUtils.formatCall(output, this.target, scope, expression.arguments);
+				return new ExpressionString(output.toString(), JavaOperator.PRIMARY);
+			}
+			default:
+				throw new IllegalStateException("Invalid method call kind: " + method.kind);
+		}
 	}
 
 	@Override
 		JavaSourceField field = expression.field.getTag(JavaSourceField.class);
 		if (field == null)
 			throw new CompileException(expression.position, CompileExceptionCode.INTERNAL_ERROR, "Missing field tag");
-		
-		return new ExpressionString(
-				scope.type(field.cls) + "." + field.name + " = " + expression.value.accept(this).value,
-				JavaOperator.ASSIGN);
+		if (field.cls.fullName.equals(scope.fileScope.cls.fullName) && !scope.hasLocalVariable(field.name)) {
+			return new ExpressionString(
+					field.name + " = " + expression.value.accept(this).value,
+					JavaOperator.ASSIGN);
+		} else {
+			return new ExpressionString(
+					scope.type(field.cls) + "." + field.name + " = " + expression.value.accept(this).value,
+					JavaOperator.ASSIGN);
+		}
 	}
 
 	@Override
 
 	@Override
 	public ExpressionString visitTryRethrowAsException(TryRethrowAsExceptionExpression expression) {
+		DefinitionTypeID type = (DefinitionTypeID) expression.value.type;
+		
+		String errorType = scope.fileScope.importer.importType(RESULT_ERROR);
+		String okType = scope.fileScope.importer.importType(RESULT_OK);
+		
 		ExpressionString value = hoist(expression.value).accept(this);
-		target.writeLine("if (" + value.value + " instanceof " + scope.fileScope.importer.importType("stdlib.Result.Error") + ")");
-		target.writeLine(scope.settings.indent + "throw (" + scope.fileScope.importer.importType("stdlib.Result.Error") + ")" + value.value + ".value;");
+		target.writeLine("if (" + value.value + " instanceof " + errorType + ")");
+		target.writeLine(scope.settings.indent + "throw ((" + errorType + formatTypeArguments(type.typeParameters) + ")" + value.value + ").value;");
 		
 		return value
-				.unaryPrefix(JavaOperator.CAST, "(" + scope.fileScope.importer.importType("stdlib.Result.Ok") + ")")
+				.unaryPrefix(JavaOperator.CAST, "(" + okType + formatTypeArguments(type.typeParameters) + ")")
 				.unaryPostfix(JavaOperator.MEMBER, ".value");
 	}
 
 	@Override
 	public ExpressionString visitTryRethrowAsResult(TryRethrowAsResultExpression expression) {
+		DefinitionTypeID type = (DefinitionTypeID) expression.value.type;
+		
+		String errorType = scope.fileScope.importer.importType(RESULT_ERROR);
+		String okType = scope.fileScope.importer.importType(RESULT_OK);
+		
 		ExpressionString value = hoist(expression.value).accept(this);
-		target.writeLine("if (" + value.value + " instanceof " + scope.fileScope.importer.importType("stdlib.Result.Error") + ")");
-		target.writeLine(scope.settings.indent + "return new " + scope.fileScope.importer.importType("stdlib.Result.Error") + "<>((" + scope.fileScope.importer.importType("stdlib.Result.Error") + ")" + value.value + ".value);");
+		target.writeLine("if (" + value.value + " instanceof " + errorType + ")");
+		target.writeLine(scope.settings.indent + "return new " + errorType + "<>(((" + errorType + formatTypeArguments(type.typeParameters) + ")" + value.value + ").value);");
 		
 		return value
-				.unaryPrefix(JavaOperator.CAST, "(" + scope.fileScope.importer.importType("stdlib.Result.Ok") + ")")
+				.unaryPrefix(JavaOperator.CAST, "(" + okType + formatTypeArguments(type.typeParameters) + ")")
 				.unaryPostfix(JavaOperator.MEMBER, ".value");
 	}
 	
 		return expression.value.accept(this);
 	}
 	
+	private String formatTypeArguments(ITypeID[] types) {
+		if (types == null || types.length == 0)
+			return "";
+		
+		StringBuilder output = new StringBuilder();
+		output.append("<");
+		
+		for (int i = 0; i < types.length; i++) {
+			if (i > 0)
+				output.append(", ");
+			
+			output.append(types[i].accept(scope.fileScope.objectTypeVisitor));
+		}
+		output.append(">");
+		return output.toString();
+	}
+	
+	public ExpressionString newArray(ITypeID elementType, ExpressionString length) {
+		if (elementType instanceof GenericTypeID) {
+			// generic array creation
+			GenericTypeID generic = (GenericTypeID)elementType;
+			String array = scope.type(new JavaSourceClass("java.lang.reflect", "Array"));
+			return new ExpressionString("(" + generic.parameter.name + "[])(" + array + ".newInstance(typeOf" + generic.parameter.name + ", " + length.value + "))", JavaOperator.CAST);
+		} else {
+			return new ExpressionString("new " + scope.type(elementType) + "[" + length.value + "]", JavaOperator.NEW);
+		}
+	}
+	
 	public ExpressionString listToArray(CastExpression expression) {
 		Expression target = duplicable(expression.target);
 		ExpressionString targetString = target.accept(this);
 		ArrayTypeID resultType = (ArrayTypeID)expression.type;
 		return new ExpressionString(
-				targetString.value + ".toArray(new " + scope.type(resultType.elementType) + "[" + targetString.value + ".size()])",
+				targetString.value + ".toArray(" + newArray(resultType.elementType, targetString.unaryPostfix(JavaOperator.CALL, ".size()")).value + ")",
 				JavaOperator.CALL);
 	}
 	
 		return cast.isImplicit ? cast.target.accept(this) : cast(cast, type);
 	}
 	
-	private Expression duplicable(Expression expression) {
+	public Expression duplicable(Expression expression) {
 		boolean shouldHoist = expression.accept(ExpressionHoistingChecker.INSTANCE);
 		if (!shouldHoist)
 			return expression;
 		return new GetLocalVariableExpression(value.position, temp);
 	}
 	
-	private ExpressionString hoist(ExpressionString value, String type) {
+	public ExpressionString hoist(ExpressionString value, String type) {
 		String temp = scope.createTempVariable();
 		target.writeLine(type + " " + temp + " = " + value.value + ";");
 		return new ExpressionString(temp, JavaOperator.PRIMARY);
 			case GENERICMAP_GETOPTIONAL: return call("get", call).unaryPrefix(JavaOperator.CAST, "(" + scope.type(call.type) + ")");
 			case GENERICMAP_PUT: return call("put", call);
 			case GENERICMAP_CONTAINS: return call("containsKey", call);
+			case GENERICMAP_ADDALL: return call("putAll", call);
 			case GENERICMAP_EQUALS: throw new UnsupportedOperationException("Not yet supported!");
 			case GENERICMAP_NOTEQUALS: throw new UnsupportedOperationException("Not yet supported!");
 			case GENERICMAP_SAME: return binary(call, JavaOperator.EQUALS);
 			}
 			case ARRAY_CONTAINS: {
 				JavaSourceMethod method = scope.fileScope.helperGenerator.createArrayContains((ArrayTypeID)call.target.type);
-				return callAsStatic(scope.fileScope.importer.importType(method.cls.fullName) + '.' + method.name, call);
+				return callAsStatic(scope.fileScope.importer.importType(method.cls) + '.' + method.name, call);
 			}
 			case ARRAY_EQUALS: return callAsStatic("Arrays.equals", call);
 			case ARRAY_NOTEQUALS: return callAsStatic("!Arrays.equals", call);
 			case FUNCTION_NOTSAME: return binary(call, JavaOperator.NOTEQUALS);
 			case OBJECT_SAME: return binary(call, JavaOperator.EQUALS);
 			case OBJECT_NOTSAME: return binary(call, JavaOperator.NOTEQUALS);
+			case OPTIONAL_IS_NULL: return call.target.accept(this).unaryPostfix(JavaOperator.EQUALS, " == null");
+			case OPTIONAL_IS_NOT_NULL: return call.target.accept(this).unaryPostfix(JavaOperator.NOTEQUALS, " != null");
 			case AUTOOP_NOTEQUALS:
 				throw new UnsupportedOperationException("Not yet supported!");
 		}
 			case STRING_CONSTRUCTOR_CHARACTERS:
 				return callStatic("new String", expression.arguments.arguments[0]);
 			case ASSOC_CONSTRUCTOR: {
-				String typeName = scope.type(new JavaSourceClass("HashMap", "java.util.HashMap"));
+				String typeName = scope.type(new JavaSourceClass("java.util", "HashMap"));
 				AssocTypeID type = (AssocTypeID) expression.type;
 				
 				StringBuilder result = new StringBuilder();
 				result.append("new ").append(typeName).append("<");
-				result.append(scope.type(type.keyType));
-				result.append(", ");
-				result.append(scope.type(type.valueType));
+				//result.append(scope.type(type.keyType));
+				//result.append(", ");
+				//result.append(scope.type(type.valueType));
 				result.append(">()");
 				return new ExpressionString(result.toString(), JavaOperator.NEW);
 			}
 			case GENERICMAP_CONSTRUCTOR: {
-				String typeName = scope.type(new JavaSourceClass("HashMap", "java.util.HashMap"));
+				String typeName = scope.type(new JavaSourceClass("java.util", "HashMap"));
 				StringBuilder result = new StringBuilder();
 				result.append("new ").append(typeName).append("<Class<?>, Object>()");
 				return new ExpressionString(result.toString(), JavaOperator.NEW);
 				ArrayTypeID type = (ArrayTypeID) expression.type;
 				if (type.dimension == 1) {
 					ExpressionString size = expression.arguments.arguments[0].accept(this);
-					String typeName = scope.type(type.elementType);
-					return new ExpressionString("new " + typeName + "[" + size.value + "]", JavaOperator.NEW);
+					return newArray(type.elementType, size);
 				} else {
 					// TODO: implement
 					throw new UnsupportedOperationException("Not yet supported!");
 							.append(' ')
 							.append(temp)
 							.append(" = ")
-							.append(" new ")
-							.append(scope.type(type.elementType))
-							.append("[")
-							.append(size.value)
-							.append("];")
+							.append(newArray(type.elementType, size).value)
+							.append(";")
 							.toString());
 					target.writeLine(new StringBuilder()
 							.append("for (int ")
 								.append(scope.type(type))
 								.append(' ')
 								.append(temp)
-								.append(" = new ")
-								.append(scope.type(type.elementType))
-								.append("[")
-								.append(size.value)
-								.append("];")
+								.append(" = ")
+								.append(newArray(type.elementType, size))
+								.append(";")
 								.toString());
 					VarStatement tempI = new VarStatement(expression.position, scope.createTempVariable(), BasicTypeID.INT, null, true);
 					target.writeLine(new StringBuilder()
 							.append(scope.type(type))
 							.append(' ')
 							.append(temp)
-							.append(" = new ")
-							.append(scope.type(type.elementType))
-							.append("[")
-							.append(originalString.value)
-							.append(".length];")
+							.append(" = ")
+							.append(newArray(type.elementType, originalString.unaryPostfix(JavaOperator.MEMBER, ".length")))
+							.append(";")
 							.toString());
 					VarStatement tempI = new VarStatement(expression.position, scope.createTempVariable(), BasicTypeID.INT, null, true);
 					target.writeLine(new StringBuilder()
 							.append(scope.type(type))
 							.append(' ')
 							.append(temp)
-							.append(" = new ")
-							.append(scope.type(type.elementType))
-							.append("[")
-							.append(originalString.value)
-							.append(".length];")
+							.append(" = ")
+							.append(newArray(type.elementType, originalString.unaryPostfix(JavaOperator.MEMBER, ".length")))
+							.append(";")
 							.toString());
 					VarStatement tempI = new VarStatement(expression.position, scope.createTempVariable(), BasicTypeID.INT, null, true);
 					target.writeLine(new StringBuilder()
 								.append("] = ")
 								.append(lambdaString.value)
 								.append(".invoke(")
+								.append(tempI.name)
+								.append(", ")
 								.append(originalString.value)
 								.append("[")
 								.append(tempI.name)

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

 import java.io.OutputStreamWriter;
 import java.io.Writer;
 import java.nio.charset.StandardCharsets;
+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.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.compiler.CompileScope;
 import org.openzen.zenscript.compiler.SemanticModule;
-import org.openzen.zenscript.javasource.prepare.JavaSourcePrepareDefinitionVisitor;
-import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
+import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class JavaSourceFile {
-	private final JavaSourceImporter importer;
+	public final JavaSourceImporter importer;
 	private final JavaSourceCompiler compiler;
 	private final File file;
+	private final JavaSourceClass cls;
 	private final StringBuilder contents = new StringBuilder();
 	private final ZSPackage pkg;
 	
-	private final Map<HighLevelDefinition, SemanticModule> definitions = new HashMap<>();
+	private HighLevelDefinition mainDefinition;
+	private final List<ExpansionDefinition> expansions = new ArrayList<>();
+	
+	private final Map<HighLevelDefinition, SemanticModule> modules = new HashMap<>();
 	private final Set<String> existing = new HashSet<>();
 	
-	public JavaSourceFile(JavaSourceCompiler compiler, File file, ZSPackage pkg) {
+	public JavaSourceFile(JavaSourceCompiler compiler, File file, JavaSourceClass cls, ZSPackage pkg) {
 		this.compiler = compiler;
 		this.pkg = pkg;
+		this.cls = cls;
 		this.file = file;
 		
-		importer = new JavaSourceImporter(pkg);
+		importer = new JavaSourceImporter(cls);
 	}
 	
 	public String getName() {
-		return file.getName().substring(0, file.getName().lastIndexOf('.'));
+		return cls.name;
 	}
 	
 	public void add(HighLevelDefinition definition, SemanticModule module) {
-		if (existing.contains(definition.name))
-			throw new IllegalStateException("Duplicate " + definition.name);
-		
-		System.out.println("adding " + definition.name + " to " + file.getName());
+		if (definition instanceof ExpansionDefinition) {
+			expansions.add((ExpansionDefinition)definition);
+		} else if (mainDefinition != null) {
+			throw new IllegalStateException("Multiple main definitions!");
+		} else {
+			mainDefinition = definition;
+		}
 		
-		JavaSourcePrepareDefinitionVisitor prepare = new JavaSourcePrepareDefinitionVisitor(this);
-		definition.accept(prepare);
-		definitions.put(definition, module);
+		modules.put(definition, module);
 	}
 	
 	public void write() {
 		System.out.println("Calling write on " + file.getName());
 		
-		for (Map.Entry<HighLevelDefinition, SemanticModule> entry : definitions.entrySet()) {
-			HighLevelDefinition definition = entry.getKey();
-			SemanticModule module = entry.getValue();
-			CompileScope scope = new CompileScope(definition.access, module.compilationUnit.globalTypeRegistry, module.expansions, module.annotations);
-			JavaDefinitionVisitor visitor = new JavaDefinitionVisitor(
-					compiler.settings,
-					new JavaSourceFileScope(importer, compiler.typeGenerator, compiler.helperGenerator, getName(), scope, definition instanceof InterfaceDefinition),
-					contents);
-			definition.accept(visitor);
-		}
+		if (mainDefinition == null)
+			mainDefinition = expansions.remove(0);
+		
+		HighLevelDefinition definition = mainDefinition;
+		JavaDefinitionVisitor visitor = new JavaDefinitionVisitor(
+				compiler,
+				cls,
+				this,
+				contents,
+				expansions,
+				modules);
+		definition.accept(visitor);
 		
 		if (!file.getParentFile().exists())
 			file.getParentFile().mkdirs();
 			writer.write(pkg.fullName);
 			writer.write(";\n\n");
 			
-			JavaSourceImporter.Import[] imports = importer.getUsedImports();
+			JavaSourceClass[] imports = importer.getUsedImports();
 			if (imports.length > 0) {
-				for (JavaSourceImporter.Import import_ : imports) {
-					if (import_.actualName.startsWith("java.lang."))
+				for (JavaSourceClass import_ : imports) {
+					if (import_.pkg.equals("java.lang"))
 						continue;
 					
 					writer.write("import ");
-					writer.write(import_.actualName);
+					writer.write(import_.fullName);
 					writer.write(";\n");
 				}
 

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

 import java.util.Map;
 import java.util.Set;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class JavaSourceImporter {
-	private final ZSPackage pkg;
-	private final Map<String, Import> imports = new HashMap<>();
-	private final Set<Import> usedImports = new HashSet<>();
+	private final JavaSourceClass cls;
+	private final Map<String, JavaSourceClass> imports = new HashMap<>();
+	private final Set<JavaSourceClass> usedImports = new HashSet<>();
 	
-	public JavaSourceImporter(ZSPackage pkg) {
-		this.pkg = pkg;
-		
-		imports.put("IllegalArgumentException", new Import("IllegalArgumentException", "stdlib.IllegalArgumentException", "java.lang.IllegalArgumentException"));
-		imports.put("StringBuilder", new Import("StringBuilder", "stdlib.StringBuilder", "java.lang.StringBuilder"));
+	public JavaSourceImporter(JavaSourceClass cls) {
+		this.cls = cls;
 	}
 	
 	public String importType(HighLevelDefinition definition) {
-		if (definition.pkg == pkg)
-			return definition.name;
+		JavaSourceClass cls = definition.getTag(JavaSourceClass.class);
+		if (cls == null)
+			throw new IllegalStateException("Missing source class tag on " + definition.name);
+		if (cls.pkg.equals(this.cls.pkg))
+			return cls.name;
 		
-		return importType(definition.pkg.fullName + "." + definition.name);
+		return importType(cls);
 	}
 	
-	public String importType(String fullName) {
-		String name = fullName.substring(fullName.lastIndexOf('.') + 1);
-		if (imports.containsKey(name)) {
-			Import imported = imports.get(name);
+	public String importType(JavaSourceClass cls) {
+		if (imports.containsKey(cls.name)) {
+			JavaSourceClass imported = imports.get(cls.name);
 			usedImports.add(imported);
-			return imported.originalName.equals(fullName) ? name : fullName;
+			return imported.fullName.equals(cls.fullName) ? cls.name : cls.fullName;
 		}
 		
-		Import imported = new Import(name, fullName, fullName);
-		imports.put(name, imported);
-		return name;
+		imports.put(cls.name, cls);
+		usedImports.add(cls);
+		return cls.name;
 	}
 	
-	public Import[] getUsedImports() {
-		Import[] imports = usedImports.toArray(new Import[usedImports.size()]);
+	public JavaSourceClass[] getUsedImports() {
+		JavaSourceClass[] imports = usedImports.toArray(new JavaSourceClass[usedImports.size()]);
 		Arrays.sort(imports);
 		return imports;
 	}
-	
-	public static class Import implements Comparable<Import> {
-		public final String name;
-		public final String originalName;
-		public final String actualName;
-		
-		public Import(String name, String originalName, String actualName) {
-			this.name = name;
-			this.originalName = originalName;
-			this.actualName = actualName;
-		}
-
-		@Override
-		public int compareTo(Import o) {
-			return actualName.compareTo(o.actualName);
-		}
-	}
 }

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

 import java.util.Collections;
 import java.util.List;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.OperatorType;
-import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
 import org.openzen.zenscript.codemodel.expression.RangeExpression;
-import org.openzen.zenscript.codemodel.expression.SetLocalVariableExpression;
 import org.openzen.zenscript.codemodel.expression.switchvalue.CharSwitchValue;
 import org.openzen.zenscript.codemodel.expression.switchvalue.EnumConstantSwitchValue;
 import org.openzen.zenscript.codemodel.expression.switchvalue.IntSwitchValue;
 import org.openzen.zenscript.codemodel.statement.ForeachStatement;
 import org.openzen.zenscript.codemodel.statement.IfStatement;
 import org.openzen.zenscript.codemodel.statement.LockStatement;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.ReturnStatement;
-import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.SwitchCase;
 import org.openzen.zenscript.codemodel.statement.SwitchStatement;
 import org.openzen.zenscript.codemodel.statement.ThrowStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.statement.WhileStatement;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
-import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.formattershared.ExpressionString;
 import org.openzen.zenscript.formattershared.StatementFormatter;
 import org.openzen.zenscript.formattershared.StatementFormattingSubBlock;
 	public JavaSourceStatementFormatter(JavaSourceStatementScope scope) {
 		this.scope = scope;
 	}
+	
+	@Override
+	public JavaSourceStatementFormatter forLoop(LoopStatement statement) {
+		return new JavaSourceStatementFormatter(scope.createBlockScope(statement));
+	}
 
 	@Override
 	public void formatBlock(StatementFormattingTarget target, BlockStatement statement) {
 
 	@Override
 	public void formatBreak(StatementFormattingTarget target, BreakStatement statement) {
-		if (target.getInnerLoop() == statement.target)
+		if (scope.innerLoop == statement.target)
 			target.writeLine("break;");
 		else
 			target.writeLine("break " + statement.target.label + ";");
 
 	@Override
 	public void formatContinue(StatementFormattingTarget target, ContinueStatement statement) {
-		if (target.getInnerLoop() == statement.target)
+		if (scope.innerLoop == statement.target)
 			target.writeLine("continue;");
 		else
 			target.writeLine("continue " + statement.target.label + ";");
 			DefinitionTypeID variantType = (DefinitionTypeID)statement.value.type;
 			HighLevelDefinition variant = variantType.definition;
 			String variantTypeName = scope.type(variant.getTag(JavaSourceClass.class));
-			JavaSourceStatementScope innerScope = scope.createBlockScope(statement);
 			for (SwitchCase switchCase : statement.cases) {
 				VariantOptionSwitchValue switchValue = (VariantOptionSwitchValue)switchCase.value;
 				String header = switchValue == null ? "default:" : "case " + switchValue.option.getName() + ":";
 
 		@Override
 		public Void visitArrayKeyValueIterator() {
-			Statement content = statement.content;
-			
-			Expression list = scope.duplicable(target, statement.list);
-			
-			List<Statement> modifiedContent = new ArrayList<>();
-			TypeMembers arrayMembers = scope.fileScope.semanticScope.getTypeMembers(statement.list.type);
-			
-			Expression getElement = arrayMembers
-							.getOrCreateGroup(OperatorType.INDEXGET)
-							.call(statement.position,
-									scope.fileScope.semanticScope,
-									list,
-									new CallArguments(new GetLocalVariableExpression(statement.position, statement.loopVariables[0])), true);
-			Expression setLocal = new SetLocalVariableExpression(statement.position, statement.loopVariables[1], getElement);
-			
-			modifiedContent.add(new ExpressionStatement(
-					statement.position,
-					setLocal));
-			if (content instanceof BlockStatement) {
-				modifiedContent.addAll(((BlockStatement) content).statements);
-			} else {
-				modifiedContent.add(content);
-			}
+			ExpressionString list = scope.expression(target, scope.duplicable(target, statement.list));
 			
 			target.writeInner(
-					"for (" + scope.type(statement.loopVariables[0].type) + " " + statement.loopVariables[0].name + " : " + scope.expression(target, list) + ")",
-					new BlockStatement(statement.position, modifiedContent),
+					"for (int " + statement.loopVariables[0].name + " = 0; i < " + list.value + ".length; i++) {",
+					new String[] {
+						scope.type(statement.loopVariables[1].type) + " " + statement.loopVariables[1].name + " = " + list.value + "[" + statement.loopVariables[0].name + "];"
+					},
+					statement.content,
 					statement,
-					"");
+					"}");
 			
 			return null;
 		}
 		@Override
 		public Void visitStringCharacterIterator() {
 			target.writeInner(
-					"for (char " + statement.loopVariables[0].name + " : " + scope.expression(target, statement.list) + ".toCharArray())",
+					"for (char " + statement.loopVariables[0].name + " : " + scope.expression(target, statement.list).value + ".toCharArray())",
+					statement.content,
+					statement,
+					"");
+			return null;
+		}
+
+		@Override
+		public Void visitAssocKeyIterator() {
+			VarStatement key = statement.loopVariables[0];
+			target.writeInner(
+					"for (" + scope.type(key.type) + " " + key + " : " + scope.expression(target, statement.list).value + ".keySet())",
 					statement.content,
 					statement,
 					"");
 			return null;
 		}
+
+		@Override
+		public Void visitAssocKeyValueIterator() {
+			String temp = scope.createTempVariable();
+			VarStatement key = statement.loopVariables[0];
+			VarStatement value = statement.loopVariables[1];
+			target.writeInner(
+					"for (Map.Entry<" + scope.type(key.type) + ", " + scope.type(value.type) + "> " + temp + " : " + scope.expression(target, statement.list).value + ".entrySet()) {",
+					new String[] {
+						scope.type(key.type) + " " + key.name + " = " + temp + ".getKey();",
+						scope.type(value.type) + " " + value.name + " = " + temp + ".getValue();"
+					},
+					statement.content,
+					statement,
+					"}");
+			return null;
+		}
 	}
 }

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

 	private final File directory;
 	private final JavaSourceFormattingSettings settings;
 	private final Map<String, List<String>> members = new HashMap<>();
-	private final JavaSourceClass arrayHelpers = new JavaSourceClass("ArrayHelpers", "zsynthetic.ArrayHelpers");
+	private final JavaSourceClass arrayHelpers = new JavaSourceClass("zsynthetic", "ArrayHelpers");
 	private final Map<ArrayKind, JavaSourceMethod> existingContains = new HashMap<>();
 	private final Map<ArrayKind, JavaSourceMethod> existingIndexOf = new HashMap<>();
 	
 		String method = generateContains(kind);
 		addMember(arrayHelpers, method);
 		
-		JavaSourceMethod sourceMethod = new JavaSourceMethod(arrayHelpers, JavaSourceMethod.Kind.EXPANSION, kind.containsName);
+		JavaSourceMethod sourceMethod = new JavaSourceMethod(arrayHelpers, JavaSourceMethod.Kind.EXPANSION, kind.containsName, false);
 		existingContains.put(kind, sourceMethod);
 		return sourceMethod;
 	}
 		String method = generateContains(kind);
 		addMember(arrayHelpers, method);
 		
-		JavaSourceMethod sourceMethod = new JavaSourceMethod(arrayHelpers, JavaSourceMethod.Kind.EXPANSION, kind.containsName);
+		JavaSourceMethod sourceMethod = new JavaSourceMethod(arrayHelpers, JavaSourceMethod.Kind.EXPANSION, kind.containsName, false);
 		existingContains.put(kind, sourceMethod);
 		return sourceMethod;
 	}

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

 import java.io.OutputStreamWriter;
 import java.io.Writer;
 import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionParameter;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 
 /**
  * @author Hoofdgebruiker
  */
 public class JavaSourceSyntheticTypeGenerator {
-	private final Map<FunctionTypeID, JavaSourceClass> functions = new HashMap<>();
+	private final Map<FunctionTypeID, JavaSynthesizedClass> functions = new HashMap<>();
 	private final File directory;
 	private final JavaSourceFormattingSettings settings;
 	
 		this.settings = settings;
 	}
 	
-	public JavaSourceClass createFunction(FunctionTypeID function) {
+	public JavaSynthesizedClass createFunction(JavaSourceTypeVisitor typeFormatter, FunctionTypeID function) {
 		if (functions.containsKey(function))
 			return functions.get(function);
 		
 		String className = createFunctionClassName(function);
-		JavaSourceClass result = new JavaSourceClass(className, "zsynthetic." + className);
+		JavaSourceClass cls = new JavaSourceClass("zsynthetic", className);
+		JavaSynthesizedClass result = new JavaSynthesizedClass(cls, extractTypeParameters(function));
 		functions.put(function, result);
 		
-		JavaSourceImporter importer = new JavaSourceImporter(new ZSPackage(null, "zsynthetic"));
+		JavaSourceImporter importer = new JavaSourceImporter(cls);
 		JavaSourceTypeVisitor typeVisitor = new JavaSourceTypeVisitor(importer, this);
 		
 		StringBuilder contents = new StringBuilder();
 		contents.append("@FunctionalInterface\n");
 		contents.append("public interface ");
 		contents.append(className);
+		JavaSourceUtils.formatTypeParameters(typeFormatter, contents, result.typeParameters);
 		contents.append(" {\n");
 		contents.append(settings.indent);
 		if (function.header.getNumberOfTypeParameters() > 0) {
 		try (Writer writer = new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(file)), StandardCharsets.UTF_8)) {
 			writer.write("package zsynthetic;\n");
 			
-			JavaSourceImporter.Import[] imports = importer.getUsedImports();
+			JavaSourceClass[] imports = importer.getUsedImports();
 			if (imports.length > 0) {
-				for (JavaSourceImporter.Import import_ : imports) {
-					if (import_.actualName.startsWith("java.lang."))
+				for (JavaSourceClass import_ : imports) {
+					if (import_.pkg.equals("java.lang"))
 						continue;
 					
 					writer.write("import ");
-					writer.write(import_.actualName);
+					writer.write(import_.fullName);
 					writer.write(";\n");
 				}
 
 		className.append(functions.size() + 1); // TODO: create more meaningful names
 		return className.toString();
 	}
+	
+	private TypeParameter[] extractTypeParameters(ITypeID type) {
+		List<TypeParameter> result = new ArrayList<>();
+		type.extractTypeParameters(result);
+		return result.toArray(new TypeParameter[result.size()]);
+	}
 }

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

 import org.openzen.zenscript.codemodel.type.OptionalTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class JavaSourceTypeVisitor implements ITypeVisitor<String>, GenericParameterBoundVisitor<String> {
+	private static final JavaSourceClass MAP = new JavaSourceClass("java.util", "Map");
+	private static final JavaSourceClass HASHMAP = new JavaSourceClass("java.util", "HashMap");
+	private static final JavaSourceClass ITERATOR = new JavaSourceClass("java.util", "Iterator");
+	
 	public final JavaSourceImporter importer;
 	public final JavaSourceSyntheticTypeGenerator typeGenerator;
 	public final JavaSourceObjectTypeVisitor objectTypeVisitor;
+	public final JavaSourceClass cls;
 	
 	public JavaSourceTypeVisitor(JavaSourceImporter importer, JavaSourceSyntheticTypeGenerator typeGenerator) {
+		this(importer, typeGenerator, null);
+	}
+	
+	public JavaSourceTypeVisitor(JavaSourceImporter importer, JavaSourceSyntheticTypeGenerator typeGenerator, JavaSourceClass cls) {
 		this.importer = importer;
 		this.typeGenerator = typeGenerator;
+		this.cls = cls;
 		
 		if (this instanceof JavaSourceObjectTypeVisitor) {
 			objectTypeVisitor = (JavaSourceObjectTypeVisitor)this;
 
 	@Override
 	public String visitAssoc(AssocTypeID assoc) {
-		String map = importer.importType("java.util.Map");
+		String map = importer.importType(MAP);
 		return map + "<" + assoc.keyType.accept(new JavaSourceObjectTypeVisitor(importer, typeGenerator)) + ", " + assoc.valueType.accept(new JavaSourceObjectTypeVisitor(importer, typeGenerator)) + ">";
 	}
 
 	@Override
 	public String visitGenericMap(GenericMapTypeID map) {
-		String javaMap = importer.importType("java.util.Map");
-		return javaMap + "<Class<?>, Object>";
+		return importer.importType(MAP) + "<Class<?>, Object>";
 	}
 
 	@Override
 	public String visitIterator(IteratorTypeID iterator) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		if (iterator.iteratorTypes.length == 1) {
+			return importer.importType(ITERATOR) + "<" + iterator.iteratorTypes[0].accept(objectTypeVisitor) + '>';
+		} else {
+			throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		}
 	}
 
 	@Override
 	public String visitFunction(FunctionTypeID function) {
-		JavaSourceClass synthetic = typeGenerator.createFunction(function);
-		return importer.importType(synthetic.fullName);
+		JavaSynthesizedClass synthetic = typeGenerator.createFunction(this, function);
+		StringBuilder result = new StringBuilder();
+		result.append(importer.importType(synthetic.cls));
+		if (synthetic.typeParameters.length > 0) {
+			result.append('<');
+			for (int i = 0; i < synthetic.typeParameters.length; i++) {
+				if (i > 0)
+					result.append(", ");
+				
+				result.append(synthetic.typeParameters[i].name);
+			}
+			result.append('>');
+		}
+		return result.toString();
 	}
 
 	@Override
 	public String visitDefinition(DefinitionTypeID definition) {
-		String javaType = importer.importType(definition.definition);
+		String javaType = cls == null ? importer.importType(definition.definition) : importer.importType(cls);
 		StringBuilder result = new StringBuilder(javaType);
 		if (definition.typeParameters != null && definition.typeParameters.length > 0) {
 			result.append("<");

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

 import org.openzen.zenscript.codemodel.generic.ParameterSuperBound;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
  *
 public class JavaSourceUtils {
 	private JavaSourceUtils() {}
 	
-	public static void formatTypeParameters(JavaSourceFileScope scope, StringBuilder output, TypeParameter[] parameters) {
+	public static void formatTypeParameters(JavaSourceTypeVisitor typeFormatter, StringBuilder output, TypeParameter[] parameters) {
 		if (parameters == null || parameters.length == 0)
 			return;
 		
-		TypeParameterBoundVisitor boundVisitor = new TypeParameterBoundVisitor(scope, output);
+		TypeParameterBoundVisitor boundVisitor = new TypeParameterBoundVisitor(typeFormatter, output);
 		output.append("<");
 		for (int i = 0; i < parameters.length; i++) {
 			if (i > 0)
 		output.append("> ");
 	}
 	
+	public static void formatTypeParameters(JavaSourceTypeVisitor typeFormatter, StringBuilder output, TypeParameter[] expansion, TypeParameter[] parameters) {
+		if (((parameters == null ? 0 : parameters.length) + (expansion == null ? 0 : expansion.length)) == 0)
+			return;
+		
+		TypeParameterBoundVisitor boundVisitor = new TypeParameterBoundVisitor(typeFormatter, output);
+		output.append("<");
+		boolean first = true;
+		if (parameters != null) {
+			for (int i = 0; i < parameters.length; i++) {
+				if (first)
+					first = false;
+				else
+					output.append(", ");
+
+				TypeParameter typeParameter = parameters[i];
+				output.append(typeParameter.name);
+
+				if (typeParameter.bounds.size() > 0) {
+					for (GenericParameterBound bound : typeParameter.bounds)
+						bound.accept(boundVisitor);
+				}
+			}
+		}
+		if (expansion != null) {
+			for (int i = 0; i < expansion.length; i++) {
+				if (first)
+					first = false;
+				else
+					output.append(", ");
+
+				TypeParameter typeParameter = expansion[i];
+				output.append(typeParameter.name);
+
+				if (typeParameter.bounds.size() > 0) {
+					for (GenericParameterBound bound : typeParameter.bounds)
+						bound.accept(boundVisitor);
+				}
+			}
+		}
+		output.append("> ");
+	}
+	
 	private static class TypeParameterBoundVisitor implements GenericParameterBoundVisitor<Void> {
-		private final JavaSourceFileScope scope;
+		private final JavaSourceTypeVisitor typeFormatter;
 		private final StringBuilder output;
 		
-		public TypeParameterBoundVisitor(JavaSourceFileScope scope, StringBuilder output) {
-			this.scope = scope;
+		public TypeParameterBoundVisitor(JavaSourceTypeVisitor typeFormatter, StringBuilder output) {
+			this.typeFormatter = typeFormatter;
 			this.output = output;
 		}
 
 		@Override
 		public Void visitSuper(ParameterSuperBound bound) {
-			output.append(" super ").append(scope.type(bound.type));
+			output.append(" super ").append(bound.type.accept(typeFormatter));
 			return null;
 		}
 
 		@Override
 		public Void visitType(ParameterTypeBound bound) {
-			output.append(" extends ").append(scope.type(bound.type));
+			output.append(" extends ").append(bound.type.accept(typeFormatter));
 			return null;
 		}
 	}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javasource;
+
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSynthesizedClass {
+	public final JavaSourceClass cls;
+	public final TypeParameter[] typeParameters;
+	
+	public JavaSynthesizedClass(JavaSourceClass cls, TypeParameter[] typeParameters) {
+		this.cls = cls;
+		this.typeParameters = typeParameters;
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javasource.prepare;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.openzen.zenscript.javasource.tags.JavaSourceClass;
+import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaNativeClass {
+	public final JavaSourceClass cls;
+	private final Map<String, JavaSourceMethod> methods = new HashMap<>();
+	
+	public JavaNativeClass(JavaSourceClass cls) {
+		this.cls = cls;
+	}
+	
+	public void addMethod(String key, JavaSourceMethod method) {
+		methods.put(key, method);
+	}
+	
+	public void addConstructor(String key, String name) {
+		methods.put(key, new JavaSourceMethod(cls, JavaSourceMethod.Kind.CONSTRUCTOR, name, false));
+	}
+	
+	public void addInstanceMethod(String key, String name) {
+		methods.put(key, new JavaSourceMethod(cls, JavaSourceMethod.Kind.INSTANCE, name, false));
+	}
+	
+	public JavaSourceMethod getMethod(String name) {
+		return methods.get(name);
+	}
+}

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

 
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.annotations.NativeTag;
-import org.openzen.zenscript.codemodel.expression.CastExpression;
 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.formattershared.ExpressionString;
-import org.openzen.zenscript.javasource.JavaOperator;
 import org.openzen.zenscript.javasource.JavaSourceTypeNameVisitor;
 import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 import org.openzen.zenscript.javasource.tags.JavaSourceField;
  */
 public class JavaSourcePrepareClassMethodVisitor implements MemberVisitor<Void> {
 	private final JavaSourceClass cls;
+	private final JavaNativeClass nativeClass;
 	
-	public JavaSourcePrepareClassMethodVisitor(JavaSourceClass cls) {
+	public JavaSourcePrepareClassMethodVisitor(JavaSourceClass cls, JavaNativeClass nativeClass, boolean startsEmpty) {
 		this.cls = cls;
+		this.nativeClass = nativeClass;
+		cls.empty = startsEmpty;
 	}
 	
 	@Override
 	public Void visitConst(ConstMember member) {
+		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);
+		if (member.hasAutoSetter())
+			visitSetter(member.autoSetter);
+		
 		return null;
 	}
 
 
 	@Override
 	public Void visitDestructor(DestructorMember member) {
+		cls.empty = false;
 		return null;
 	}
 
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
 		// TODO: implementation merge check
+		cls.empty = false;
 		return null;
 	}
 
 	@Override
 	public Void visitInnerDefinition(InnerDefinitionMember member) {
 		// TODO
+		cls.empty = false;
 		return null;
 	}
 
 	@Override
 	public Void visitStaticInitializer(StaticInitializerMember member) {
+		cls.empty = false;
 		return null;
 	}
 	
 	private JavaSourceMethod.Kind getKind(DefinitionMember member) {
+		if (member instanceof ConstructorMember)
+			return JavaSourceMethod.Kind.CONSTRUCTOR;
+		
 		return member.isStatic() ? JavaSourceMethod.Kind.STATIC : JavaSourceMethod.Kind.INSTANCE;
 	}
 	
 			case CONTAINS:
 				return "contains";
 			case EQUALS:
-				return "equals";
+				return "equals_";
 			case COMPARE:
 				return "compareTo";
 			case RANGE:
 	
 	private void visitFunctional(DefinitionMember member, String name) {
 		NativeTag nativeTag = member.getTag(NativeTag.class);
-		if (nativeTag == null) {
-			member.setTag(
-					JavaSourceMethod.class,
-					new JavaSourceMethod(cls, getKind(member), name));
-		} else {
-			member.setTag(JavaSourceMethod.class, getNative(nativeTag.value));
-		}
-	}
-	
-	private JavaSourceMethod getNative(String name) {
-		if (cls.fullName.equals("java.lang.StringBuilder"))
-			return getStringBuilderNative(name);
-		else if (cls.fullName.equals("java.util.List"))
-			return getListNative(name);
+		JavaSourceMethod method = null;
+		if (nativeTag != null && nativeClass != null)
+			method = nativeClass.getMethod(nativeTag.value);
+		if (method == null)
+			method = new JavaSourceMethod(cls, getKind(member), name, true);
 		
-		throw new UnsupportedOperationException("Unknown native class: " + cls.fullName);
-	}
-	
-	private JavaSourceMethod getListNative(String name) {
-		switch (name) {
-			case "constructor":
-				return new JavaSourceMethod((formatter, call) -> new ExpressionString("new ArrayList<>()", JavaOperator.NEW));
-			case "add":
-				return new JavaSourceMethod(cls, JavaSourceMethod.Kind.INSTANCE, "add");
-			case "getIndex":
-				return new JavaSourceMethod(cls, JavaSourceMethod.Kind.INSTANCE, "get");
-			case "setIndex":
-				return new JavaSourceMethod(cls, JavaSourceMethod.Kind.INSTANCE, "set");
-			case "toArray":
-				return new JavaSourceMethod((formatter, calle)
-						-> formatter.listToArray((CastExpression)calle));
-			case "length":
-				return new JavaSourceMethod(cls, JavaSourceMethod.Kind.INSTANCE, "size");
-			case "isEmpty":
-				return new JavaSourceMethod(cls, JavaSourceMethod.Kind.INSTANCE, "isEmpty");
-			default:
-				throw new UnsupportedOperationException("Unknown native method: " + name);
-		}
-	}
-	
-	private JavaSourceMethod getStringBuilderNative(String name) {
-		switch (name) {
-			case "constructor":
-			case "constructorWithCapacity":
-			case "constructorWithValue":
-				return new JavaSourceMethod(cls, JavaSourceMethod.Kind.INSTANCE, "");
-			case "isEmpty":
-				return new JavaSourceMethod(cls, JavaSourceMethod.Kind.INSTANCE, "isEmpty");
-			case "length":
-				return new JavaSourceMethod(cls, JavaSourceMethod.Kind.INSTANCE, "length");
-			case "appendBool":
-			case "appendByte":
-			case "appendSByte":
-			case "appendShort":
-			case "appendUShort":
-			case "appendInt":
-			case "appendUInt":
-			case "appendLong":
-			case "appendULong":
-			case "appendFloat":
-			case "appendDouble":
-			case "appendChar":
-			case "appendString":
-				return new JavaSourceMethod(cls, JavaSourceMethod.Kind.INSTANCE, "append");
-			case "asString":
-				return new JavaSourceMethod(cls, JavaSourceMethod.Kind.INSTANCE, "toString");
-			default:
-				throw new UnsupportedOperationException("Unknown native method: " + name);
-		}
+		if (method.compile)
+			cls.empty = false;
+		
+		member.setTag(JavaSourceMethod.class, method);
 	}
 }

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

  */
 package org.openzen.zenscript.javasource.prepare;
 
+import java.util.HashMap;
+import java.util.Map;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.annotations.NativeTag;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.definition.StructDefinition;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+import org.openzen.zenscript.codemodel.expression.CallExpression;
+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.ArrayTypeID;
+import org.openzen.zenscript.formattershared.ExpressionString;
+import org.openzen.zenscript.javasource.JavaOperator;
 import org.openzen.zenscript.javasource.tags.JavaSourceClass;
-import org.openzen.zenscript.javasource.JavaSourceFile;
 import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 import org.openzen.zenscript.javasource.tags.JavaSourceVariantOption;
 
  *
  * @author Hoofdgebruiker
  */
-public class JavaSourcePrepareDefinitionVisitor implements DefinitionVisitor<Void> {
-	private final JavaSourceFile file;
+public class JavaSourcePrepareDefinitionVisitor implements DefinitionVisitor<JavaSourceClass> {
+	private static final Map<String, JavaNativeClass> nativeClasses = new HashMap<>();
 	
-	public JavaSourcePrepareDefinitionVisitor(JavaSourceFile file) {
-		this.file = file;
+	static {
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.lang", "StringBuilder"));
+			cls.addConstructor("constructor", "");
+			cls.addConstructor("constructorWithCapacity", "");
+			cls.addConstructor("constructorWithValue", "");
+			cls.addMethod("isEmpty", new JavaSourceMethod((formatter, call) -> ((CallExpression)call).accept(formatter).unaryPostfix(JavaOperator.EQUALS, "length() == 0")));
+			cls.addInstanceMethod("length", "length");
+			cls.addInstanceMethod("appendBool", "append");
+			cls.addInstanceMethod("appendByte", "append");
+			cls.addInstanceMethod("appendSByte", "append");
+			cls.addInstanceMethod("appendShort", "append");
+			cls.addInstanceMethod("appendUShort", "append");
+			cls.addInstanceMethod("appendInt", "append");
+			cls.addInstanceMethod("appendUInt", "append");
+			cls.addInstanceMethod("appendLong", "append");
+			cls.addInstanceMethod("appendULong", "append");
+			cls.addInstanceMethod("appendFloat", "append");
+			cls.addInstanceMethod("appendDouble", "append");
+			cls.addInstanceMethod("appendChar", "append");
+			cls.addInstanceMethod("appendString", "append");
+			cls.addInstanceMethod("asString", "toString");
+			nativeClasses.put("stdlib::StringBuilder", cls);
+		}
+		
+		{
+			JavaNativeClass list = new JavaNativeClass(new JavaSourceClass("java.util", "List"));
+			JavaSourceClass arrayList = new JavaSourceClass("java.util", "ArrayList");
+			list.addMethod("constructor", new JavaSourceMethod(arrayList, JavaSourceMethod.Kind.CONSTRUCTOR, "", false));
+			list.addInstanceMethod("add", "add");
+			list.addInstanceMethod("insert", "add");
+			list.addInstanceMethod("getAtIndex", "get");
+			list.addInstanceMethod("setAtIndex", "set");
+			list.addMethod("toArray", new JavaSourceMethod((formatter, call) -> formatter.listToArray((CastExpression)call)));
+			list.addInstanceMethod("length", "length");
+			list.addInstanceMethod("isEmpty", "isEmpty");
+			nativeClasses.put("stdlib::List", list);
+		}
+		
+		{
+			JavaNativeClass comparable = new JavaNativeClass(new JavaSourceClass("java.lang", "Comparable"));
+			comparable.addInstanceMethod("compareTo", "compareTo");
+			nativeClasses.put("stdlib::Comparable", comparable);
+		}
+		
+		{
+			JavaSourceClass integer = new JavaSourceClass("java.lang", "Integer");
+			JavaSourceClass math = new JavaSourceClass("java.lang", "Math");
+			
+			JavaNativeClass cls = new JavaNativeClass(integer);
+			cls.addMethod("min", new JavaSourceMethod(math, JavaSourceMethod.Kind.STATIC, "min", false));
+			cls.addMethod("max", new JavaSourceMethod(math, JavaSourceMethod.Kind.STATIC, "max", false));
+			cls.addMethod("toHexString", new JavaSourceMethod(integer, JavaSourceMethod.Kind.EXPANSION, "toHexString", false));
+			nativeClasses.put("stdlib::Integer", cls);
+		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.lang", "String"));
+			cls.addMethod("contains", new JavaSourceMethod((formatter, calle) -> {
+				CallExpression call = (CallExpression)calle;
+				ExpressionString str = call.arguments.arguments[0].accept(formatter);
+				ExpressionString character = call.arguments.arguments[1].accept(formatter);
+				return str.unaryPostfix(JavaOperator.GREATER_EQUALS, ".indexOf(" + character.value + ")");
+			}));
+			cls.addInstanceMethod("indexOf", "indexOf");
+			cls.addInstanceMethod("indexOfFrom", "indexOf");
+			cls.addInstanceMethod("lastIndexOf", "lastIndexOf");
+			cls.addInstanceMethod("lastIndexOfFrom", "lastIndexOf");
+			cls.addInstanceMethod("trim", "trim");
+			nativeClasses.put("stdlib::String", cls);
+		}
+		
+		{
+			JavaSourceClass arrays = new JavaSourceClass("java.lang", "Arrays");
+			JavaNativeClass cls = new JavaNativeClass(arrays);
+			cls.addMethod("sort", new JavaSourceMethod(arrays, JavaSourceMethod.Kind.EXPANSION, "sort", false));
+			cls.addMethod("sorted", new JavaSourceMethod((formatter, calle) -> {
+				Expression target = formatter.duplicable(((CallExpression)calle).target);
+				ExpressionString targetString = target.accept(formatter);
+				ExpressionString copy = new ExpressionString("Arrays.copyOf(" + targetString.value + ", " + targetString.value + ".length).sort()", JavaOperator.CALL);
+				ExpressionString source = formatter.hoist(copy, formatter.scope.type(target.type));
+				formatter.target.writeLine("Arrays.sort(" + source.value + ");");
+				return source;
+			}));
+			cls.addMethod("sortWithComparator", new JavaSourceMethod(arrays, JavaSourceMethod.Kind.EXPANSION, "sort", false));
+			cls.addMethod("sortedWithComparator", new JavaSourceMethod((formatter, calle) -> {
+				Expression target = formatter.duplicable(((CallExpression)calle).target);
+				ExpressionString comparator = ((CallExpression)calle).arguments.arguments[0].accept(formatter);
+				ExpressionString targetString = target.accept(formatter);
+				ExpressionString copy = new ExpressionString("Arrays.copyOf(" + targetString.value + ", " + targetString.value + ".length).sort()", JavaOperator.CALL);
+				ExpressionString source = formatter.hoist(copy, formatter.scope.type(target.type));
+				formatter.target.writeLine("Arrays.sort(" + source.value + ", " + comparator.value + ");");
+				return source;
+			}));
+			cls.addMethod("copy", new JavaSourceMethod((formatter, calle) -> {
+				Expression target = formatter.duplicable(((CallExpression)calle).target);
+				ExpressionString source = target.accept(formatter);
+				return new ExpressionString("Arrays.copyOf(" + source.value + ", " + source.value + ".length)", JavaOperator.CALL);
+			}));
+			cls.addMethod("copyResize", new JavaSourceMethod(arrays, JavaSourceMethod.Kind.EXPANSION, "copyOf", false));
+			cls.addMethod("copyTo", new JavaSourceMethod((formatter, calle) -> {
+				CallExpression call = (CallExpression)calle;
+				Expression source = call.target;
+				Expression target = call.arguments.arguments[0];
+				Expression sourceOffset = call.arguments.arguments[1];
+				Expression targetOffset = call.arguments.arguments[2];
+				Expression length = call.arguments.arguments[3];
+				return new ExpressionString("System.arraycopy("
+					+ source.accept(formatter) + ", "
+					+ sourceOffset.accept(formatter) + ", "
+					+ target.accept(formatter) + ", "
+					+ targetOffset.accept(formatter) + ", "
+					+ length.accept(formatter) + ")", JavaOperator.CALL);
+			}));
+			nativeClasses.put("stdlib::Arrays", cls);
+		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.lang", "IllegalArgumentException"));
+			cls.addConstructor("constructor", "");
+			nativeClasses.put("stdlib::IllegalArgumentException", cls);
+		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.lang", "Exception"));
+			cls.addConstructor("constructor", "");
+			cls.addConstructor("constructorWithCause", "");
+			nativeClasses.put("stdlib::Exception", cls);
+		}
+	}
+	
+	private final String filename;
+	
+	public JavaSourcePrepareDefinitionVisitor(String filename) {
+		this.filename = filename;
 	}
 	
 	@Override
-	public Void visitClass(ClassDefinition definition) {
-		visitClassCompiled(definition);
-		return null;
+	public JavaSourceClass visitClass(ClassDefinition definition) {
+		return visitClassCompiled(definition, true);
 	}
 
 	@Override
-	public Void visitInterface(InterfaceDefinition definition) {
-		visitClassCompiled(definition);
-		return null;
+	public JavaSourceClass visitInterface(InterfaceDefinition definition) {
+		return visitClassCompiled(definition, true);
 	}
 
 	@Override
-	public Void visitEnum(EnumDefinition definition) {
-		visitClassCompiled(definition);
-		return null;
+	public JavaSourceClass visitEnum(EnumDefinition definition) {
+		return visitClassCompiled(definition, false);
 	}
 
 	@Override
-	public Void visitStruct(StructDefinition definition) {
-		visitClassCompiled(definition);
-		return null;
+	public JavaSourceClass visitStruct(StructDefinition definition) {
+		return visitClassCompiled(definition, true);
 	}
 
 	@Override
-	public Void visitFunction(FunctionDefinition definition) {
-		JavaSourceClass cls = new JavaSourceClass(file.getName(), definition.pkg.fullName + "." + file.getName());
+	public JavaSourceClass visitFunction(FunctionDefinition definition) {
+		JavaSourceClass cls = new JavaSourceClass(definition.pkg.fullName, filename);
 		definition.setTag(JavaSourceClass.class, cls);
-		JavaSourceMethod method = new JavaSourceMethod(cls, JavaSourceMethod.Kind.STATIC, definition.name);
+		JavaSourceMethod method = new JavaSourceMethod(cls, JavaSourceMethod.Kind.STATIC, definition.name, true);
 		definition.caller.setTag(JavaSourceMethod.class, method);
-		return null;
+		return cls;
 	}
 
 	@Override
-	public Void visitExpansion(ExpansionDefinition definition) {
-		JavaSourceClass cls = new JavaSourceClass(file.getName(), definition.pkg.fullName + "." + file.getName());
-		definition.setTag(JavaSourceClass.class, cls);
-		JavaSourcePrepareExpansionMethodVisitor methodVisitor = new JavaSourcePrepareExpansionMethodVisitor(cls);
-		for (IDefinitionMember member : definition.members) {
-			member.accept(methodVisitor);
+	public JavaSourceClass visitExpansion(ExpansionDefinition definition) {
+		NativeTag nativeTag = definition.getTag(NativeTag.class);
+		JavaNativeClass nativeClass = null;
+		if (nativeTag != null) {
+			nativeClass = nativeClasses.get(nativeTag.value);
 		}
-		return null;
+		
+		JavaSourceClass cls = new JavaSourceClass(definition.pkg.fullName, filename);
+		definition.setTag(JavaSourceClass.class, cls);
+		visitExpansionMembers(definition, cls, nativeClass);
+		return cls;
 	}
 
 	@Override
-	public Void visitAlias(AliasDefinition definition) {
+	public JavaSourceClass visitAlias(AliasDefinition definition) {
 		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
 	}
 
 	@Override
-	public Void visitVariant(VariantDefinition variant) {
-		JavaSourceClass cls = new JavaSourceClass(variant.name, variant.pkg.fullName + "." + variant.name);
+	public JavaSourceClass visitVariant(VariantDefinition variant) {
+		JavaSourceClass cls = new JavaSourceClass(variant.pkg.fullName, variant.name);
 		variant.setTag(JavaSourceClass.class, cls);
 		
 		for (VariantDefinition.Option option : variant.options) {
-			JavaSourceClass variantCls = new JavaSourceClass(option.name, cls.fullName + "." + option.name);
+			JavaSourceClass variantCls = new JavaSourceClass(cls.fullName, option.name);
 			option.setTag(JavaSourceVariantOption.class, new JavaSourceVariantOption(cls, variantCls));
 		}
 		
-		visitClassMembers(variant, cls);
-		return null;
+		visitClassMembers(variant, cls, null, false);
+		return cls;
 	}
 	
-	private void visitClassCompiled(HighLevelDefinition definition) {
+	private JavaSourceClass visitClassCompiled(HighLevelDefinition definition, boolean startsEmpty) {
 		NativeTag nativeTag = definition.getTag(NativeTag.class);
-		if (nativeTag == null) {
-			JavaSourceClass cls = new JavaSourceClass(definition.name, definition.pkg.fullName + "." + definition.name);
+		JavaNativeClass nativeClass = nativeTag == null ? null : nativeClasses.get(nativeTag.value);
+		if (nativeClass == null) {
+			JavaSourceClass cls = new JavaSourceClass(definition.pkg.fullName, definition.name);
 			definition.setTag(JavaSourceClass.class, cls);
-			visitClassMembers(definition, cls);
+			visitClassMembers(definition, cls, null, startsEmpty);
+			return cls;
 		} else {
-			JavaSourceClass cls = getNativeClass(nativeTag.value);
-			definition.setTag(JavaSourceClass.class, cls);
-			visitClassMembers(definition, cls);
+			JavaSourceClass cls = new JavaSourceClass(definition.pkg.fullName, filename);
+			definition.setTag(JavaSourceClass.class, nativeClass.cls);
+			definition.setTag(JavaNativeClass.class, nativeClass);
+			visitExpansionMembers(definition, cls, nativeClass);
+			return cls;
 		}
 	}
 	
-	private JavaSourceClass getNativeClass(String name) {
-		if (name.equals("stdlib::StringBuilder"))
-			return new JavaSourceClass("StringBuilder", "java.lang.StringBuilder");
-		else if (name.equals("stdlib::List"))
-			return new JavaSourceClass("List", "java.util.List");
-		
-		throw new UnsupportedOperationException("Unknown native class: " + name);
+	private void visitClassMembers(HighLevelDefinition definition, JavaSourceClass cls, JavaNativeClass nativeClass, boolean startsEmpty) {
+		JavaSourcePrepareClassMethodVisitor methodVisitor = new JavaSourcePrepareClassMethodVisitor(cls, nativeClass, startsEmpty);
+		for (IDefinitionMember member : definition.members) {
+			member.accept(methodVisitor);
+		}
 	}
 	
-	private void visitClassMembers(HighLevelDefinition definition, JavaSourceClass cls) {
-		JavaSourcePrepareClassMethodVisitor methodVisitor = new JavaSourcePrepareClassMethodVisitor(cls);
+	private void visitExpansionMembers(HighLevelDefinition definition, JavaSourceClass cls, JavaNativeClass nativeClass) {
+		JavaSourcePrepareExpansionMethodVisitor methodVisitor = new JavaSourcePrepareExpansionMethodVisitor(cls, nativeClass);
 		for (IDefinitionMember member : definition.members) {
 			member.accept(methodVisitor);
 		}

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

 package org.openzen.zenscript.javasource.prepare;
 
 import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.annotations.NativeTag;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.ConstMember;
  */
 public class JavaSourcePrepareExpansionMethodVisitor implements MemberVisitor<Void> {
 	private final JavaSourceClass cls;
+	private final JavaNativeClass nativeClass;
 	
-	public JavaSourcePrepareExpansionMethodVisitor(JavaSourceClass cls) {
+	public JavaSourcePrepareExpansionMethodVisitor(JavaSourceClass cls, JavaNativeClass nativeClass) {
 		this.cls = cls;
+		this.nativeClass = nativeClass;
+		cls.empty = true;
 	}
 	
 	@Override
 	public Void visitConst(ConstMember member) {
 		member.setTag(JavaSourceField.class, new JavaSourceField(cls, member.name));
+		cls.empty = false;
 		return null;
 	}
 	
 	public Void visitField(FieldMember member) {
 		// TODO: expansion fields
 		member.setTag(JavaSourceField.class, new JavaSourceField(cls, member.name));
+		cls.empty = false;
 		return null;
 	}
 
 	@Override
 	public Void visitConstructor(ConstructorMember member) {
+		visitFunctional(member, "");
 		return null;
 	}
 
 	@Override
 	public Void visitDestructor(DestructorMember member) {
-		return null;
+		throw new UnsupportedOperationException("Destructors not allowed on expansions");
 	}
 
 	@Override
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
 		// TODO: implementation merge check
+		cls.empty = false;
 		return null;
 	}
 
 	@Override
 	public Void visitInnerDefinition(InnerDefinitionMember member) {
 		// TODO
+		cls.empty = false;
 		return null;
 	}
 
 	@Override
 	public Void visitStaticInitializer(StaticInitializerMember member) {
+		cls.empty = false;
 		return null;
 	}
 	
 	private void visitFunctional(DefinitionMember member, String name) {
-		member.setTag(
-				JavaSourceMethod.class,
-				new JavaSourceMethod(cls, getKind(member), name));
+		NativeTag nativeTag = member.getTag(NativeTag.class);
+		JavaSourceMethod method = null;
+		if (nativeTag != null && nativeClass != null)
+			method = nativeClass.getMethod(nativeTag.value);
+		if (method == null)
+			method = new JavaSourceMethod(cls, getKind(member), name, true); 
+		
+		if (method.compile)
+			cls.empty = false;
+		
+		member.setTag(JavaSourceMethod.class, method);
 	}
 	
 	private JavaSourceMethod.Kind getKind(DefinitionMember member) {
 			case CONTAINS:
 				return "contains";
 			case EQUALS:
-				return "equals";
+				return "equals_";
 			case COMPARE:
 				return "compareTo";
 			case RANGE:

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/scope/JavaSourceFileScope.java

 import org.openzen.zenscript.javasource.JavaSourceSyntheticHelperGenerator;
 import org.openzen.zenscript.javasource.JavaSourceSyntheticTypeGenerator;
 import org.openzen.zenscript.javasource.JavaSourceTypeVisitor;
+import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 
 /**
  *
 	public final JavaSourceImporter importer;
 	public final JavaSourceSyntheticTypeGenerator typeGenerator;
 	public final JavaSourceSyntheticHelperGenerator helperGenerator;
-	public final String className;
+	public final JavaSourceClass cls;
 	public final JavaSourceTypeVisitor typeVisitor;
 	public final JavaSourceObjectTypeVisitor objectTypeVisitor;
 	public final TypeScope semanticScope;
 			JavaSourceImporter importer, 
 			JavaSourceSyntheticTypeGenerator typeGenerator,
 			JavaSourceSyntheticHelperGenerator helperGenerator,
-			String className,
+			JavaSourceClass cls,
 			TypeScope semanticScope,
 			boolean isInterface)
 	{
 		this.importer = importer;
 		this.typeGenerator = typeGenerator;
 		this.helperGenerator = helperGenerator;
-		this.className = className;
+		this.cls = cls;
 		this.semanticScope = semanticScope;
 		this.isInterface = isInterface;
 		
 	public String type(ITypeID type) {
 		return type.accept(typeVisitor);
 	}
+	
+	public String type(ITypeID type, JavaSourceClass rename) {
+		return type.accept(new JavaSourceTypeVisitor(importer, typeGenerator, rename));
+	}
 }

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/scope/JavaSourceStatementScope.java

 		return fileScope.type(type);
 	}
 	
-	public String type(JavaSourceClass cls) {
-		return fileScope.importer.importType(cls.fullName);
+	public String type(ITypeID type, JavaSourceClass renamed) {
+		return fileScope.type(type, renamed);
 	}
 	
-	public String sourceClass(JavaSourceClass cls) {
-		return fileScope.importer.importType(cls.fullName);
+	public String type(JavaSourceClass cls) {
+		return fileScope.importer.importType(cls);
 	}
 	
 	public void addLocalVariable(String localVariable) {

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/tags/JavaSourceClass.java

  *
  * @author Hoofdgebruiker
  */
-public class JavaSourceClass {
+public class JavaSourceClass implements Comparable<JavaSourceClass> {
+	public final String pkg;
 	public final String name;
 	public final String fullName;
+	public boolean empty = false;
 	
-	public JavaSourceClass(String name, String fullName) {
+	public JavaSourceClass(String pkg, String name) {
+		this.pkg = pkg;
 		this.name = name;
-		this.fullName = fullName;
+		this.fullName = pkg + '.' + name;
+	}
+
+	@Override
+	public int compareTo(JavaSourceClass o) {
+		return fullName.compareTo(o.fullName);
 	}
 }

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/tags/JavaSourceMethod.java

 	public final JavaSourceClass cls;
 	public final Kind kind;
 	public final String name;
+	public final boolean compile;
 	public final JavaCallCompiler compiler;
 	
-	public JavaSourceMethod(JavaSourceClass cls, Kind kind, String name) {
+	public JavaSourceMethod(JavaSourceClass cls, Kind kind, String name, boolean compile) {
 		this.cls = cls;
 		this.kind = kind;
 		this.name = name;
+		this.compile = compile;
 		compiler = null;
 	}
 	
 		this.cls = null;
 		this.kind = Kind.COMPILED;
 		this.name = null;
+		this.compile = false;
 		this.compiler = compiler;
 	}
 	
 		STATIC,
 		INSTANCE,
 		EXPANSION,
+		CONSTRUCTOR,
 		COMPILED
 	}
 }

Shared/src/main/java/org/openzen/zenscript/shared/ConcatMap.java

 	}
 	
 	public V get(K key) {
-		if (key == null)
+		if (this.key == null)
 			return null;
 		if (key.equals(this.key))
 			return value;
 	}
 	
 	public V get(K key, V defaultValue) {
-		if (key == null)
+		if (this.key == null)
 			return defaultValue;
 		if (key.equals(this.key))
 			return value;

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

 		SETTING_FINAL_VARIABLE,
 		INVALID_SUPERTYPE,
 		MULTIPLE_DESTRUCTORS,
-		PANIC_ARGUMENT_NO_STRING
+		PANIC_ARGUMENT_NO_STRING,
+		THROW_WITHOUT_THROWS,
+		DESTRUCTOR_CANNOT_THROW,
+		STATIC_INITIALIZER_CANNOT_THROW
 	}
 }

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

 import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 		} else {
 			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header));
 			member.body.accept(statementValidator);
-			
+			validateThrow(member);
+				
 			if (member.definition.superType != null && !statementValidator.constructorForwarded) {
 				validator.logError(ValidationLogEntry.Code.CONSTRUCTOR_FORWARD_MISSING, member.position, "Constructor not forwarded to base type");
 			}
 		if (member.body != null) {
 			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header));
 			member.body.accept(statementValidator);
+			validateThrow(member);
+			
+			if (member.header.thrownType != null)
+				validator.logError(ValidationLogEntry.Code.DESTRUCTOR_CANNOT_THROW, member.position, "Destructor cannot throw");
 		}
 		return null;
 	}
 		if (member.body != null) {
 			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header));
 			member.body.accept(statementValidator);
+			validateThrow(member);
 		}
 		return null;
 	}
 		if (member.body != null) {
 			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header));
 			member.body.accept(statementValidator);
+			validateThrow(member);
 		}
 		
 		return null;
 		if (member.body != null) {
 			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header));
 			member.body.accept(statementValidator);
+			validateThrow(member);
 		}
 		
 		return null;
 		if (member.body != null) {
 			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header));
 			member.body.accept(statementValidator);
+			validateThrow(member);
 		}
 		
 		return null;
 		if (member.body != null) {
 			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header));
 			member.body.accept(statementValidator);
+			validateThrow(member);
 		}
 		
 		return null;
 		if (member.body != null) {
 			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header));
 			member.body.accept(statementValidator);
+			validateThrow(member);
 		}
 		
 		return null;
 	@Override
 	public Void visitStaticInitializer(StaticInitializerMember member) {
 		member.body.accept(new StatementValidator(validator, new StaticInitializerScope()));
+		if (member.body.thrownType != null)
+			validator.logError(ValidationLogEntry.Code.STATIC_INITIALIZER_CANNOT_THROW, member.position, "Static initializer cannot throw");
 		return null;
 	}
 	
+	private void validateThrow(FunctionalMember member) {
+		if (member.body.thrownType != null && member.header.thrownType == null) // TODO: validate thrown type
+			validator.logError(ValidationLogEntry.Code.THROW_WITHOUT_THROWS, member.position, "Method is throwing but doesn't declare throws type");
+	}
+	
 	private class FieldInitializerScope implements ExpressionScope {
 		private final FieldMember field;
 		

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

 	@Override
 	public Void visitPanic(PanicExpression expression) {
 		expression.value.accept(this);
-		if (expression.type != BasicTypeID.STRING)
+		if (expression.value.type != BasicTypeID.STRING)
 			validator.logError(ValidationLogEntry.Code.PANIC_ARGUMENT_NO_STRING, expression.position, "Argument to a panic must be a string");
 		return null;
 	}