- Added package info to definitions

- Added parameter index to function parameters
- Removed unnecessary expression types; these can be implemented differently
- WIP on a code (re)formatter

CodeFormatter/build.gradle

@@ -0,0 +1,18 @@
+// Note: "common.gradle" in the root project contains additional initialization
+//   for this project. This initialization is applied in the "build.gradle"
+//   of the root project.
+
+// NetBeans will automatically add "run" and "debug" tasks relying on the
+// "mainClass" property. You may however define the property prior executing
+// tasks by passing a "-PmainClass=<QUALIFIED_CLASS_NAME>" argument.
+//
+// Note however, that you may define your own "run" and "debug" task if you
+// prefer. In this case NetBeans will not add these tasks but you may rely on
+// your own implementation.
+if (!hasProperty('mainClass')) {
+    ext.mainClass = ''
+}
+
+dependencies {
+	compile project(':CodeModel')
+}

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/ExpressionFormatter.java

@@ -0,0 +1,617 @@
+/*
+ * 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.formatter;
+
+import org.openzen.zenscript.codemodel.expression.AndAndExpression;
+import org.openzen.zenscript.codemodel.expression.ArrayExpression;
+import org.openzen.zenscript.codemodel.expression.BasicCompareExpression;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.CallExpression;
+import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedClosureExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedDirectExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedParameterExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedThisExpression;
+import org.openzen.zenscript.codemodel.expression.CheckNullExpression;
+import org.openzen.zenscript.codemodel.expression.CoalesceExpression;
+import org.openzen.zenscript.codemodel.expression.ConditionalExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantBoolExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantDoubleExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantFloatExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantLongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantSByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
+import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
+import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
+import org.openzen.zenscript.codemodel.expression.EqualsExpression;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.ExpressionVisitor;
+import org.openzen.zenscript.codemodel.expression.FunctionExpression;
+import org.openzen.zenscript.codemodel.expression.GenericCompareExpression;
+import org.openzen.zenscript.codemodel.expression.GetFieldExpression;
+import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
+import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
+import org.openzen.zenscript.codemodel.expression.GetterExpression;
+import org.openzen.zenscript.codemodel.expression.InterfaceCastExpression;
+import org.openzen.zenscript.codemodel.expression.IsExpression;
+import org.openzen.zenscript.codemodel.expression.MakeConstExpression;
+import org.openzen.zenscript.codemodel.expression.MapExpression;
+import org.openzen.zenscript.codemodel.expression.NewExpression;
+import org.openzen.zenscript.codemodel.expression.NotExpression;
+import org.openzen.zenscript.codemodel.expression.NullExpression;
+import org.openzen.zenscript.codemodel.expression.OrOrExpression;
+import org.openzen.zenscript.codemodel.expression.RangeExpression;
+import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
+import org.openzen.zenscript.codemodel.expression.SetFunctionParameterExpression;
+import org.openzen.zenscript.codemodel.expression.SetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.SetStaticFieldExpression;
+import org.openzen.zenscript.codemodel.expression.SetterExpression;
+import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
+import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
+import org.openzen.zenscript.codemodel.expression.ThisExpression;
+import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
+import org.openzen.zenscript.codemodel.member.CasterMember;
+import org.openzen.zenscript.codemodel.member.OperatorMember;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.StringUtils;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ExpressionFormatter implements ExpressionVisitor<ExpressionString> {
+	private final FormattingSettings settings;
+	public final TypeFormatter typeFormatter;
+	
+	public ExpressionFormatter(FormattingSettings settings, TypeFormatter typeFormatter) {
+		this.settings = settings;
+		this.typeFormatter = typeFormatter;
+	}
+
+	@Override
+	public ExpressionString visitAndAnd(AndAndExpression expression) {
+		return binary(expression.left, expression.right, OperatorPriority.ANDAND, " && ");
+	}
+
+	@Override
+	public ExpressionString visitArray(ArrayExpression expression) {
+		StringBuilder result = new StringBuilder();
+		result.append("[");
+		int index = 0;
+		for (Expression element : expression.expressions) {
+			if (index > 0)
+				result.append(", ");
+			
+			result.append(element.accept(this).value);
+			index++;
+		}
+		result.append("]");
+		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+	}
+
+	@Override
+	public ExpressionString visitCompare(BasicCompareExpression expression) {
+		return binary(
+				expression.left,
+				expression.right,
+				OperatorPriority.COMPARE,
+				" " + expression.operator.str + " ");
+	}
+
+	@Override
+	public ExpressionString visitCall(CallExpression expression) {
+		if (expression.member instanceof OperatorMember) {
+			OperatorMember operator = (OperatorMember) expression.member;
+			switch (operator.operator) {
+				case NOT:
+					return unaryPrefix(expression.target, OperatorPriority.NOT, "!");
+				case NEG:
+					return unaryPrefix(expression.target, OperatorPriority.NEG, "-");
+				case CAT:
+					if (expression.arguments.arguments.length == 0) {
+						return unaryPrefix(expression.target, OperatorPriority.INVERT, "~");
+					} else {
+						return binary(expression.target, expression.getFirstArgument(), OperatorPriority.CAT, " ~ ");
+					}
+				case ADD:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.ADD, " + ");
+				case SUB:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.SUB, " - ");
+				case MUL:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.MUL, " * ");
+				case DIV:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.DIV, " / ");
+				case MOD:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.MOD, " % ");
+				case AND:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.AND, " & ");
+				case OR:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.OR, " | ");
+				case XOR:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XOR, " ^ ");
+				case CONTAINS:
+					return binary(expression.getFirstArgument(), expression.target, OperatorPriority.CONTAINS, " in ");
+				case EQUALS:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.COMPARE, " == ");
+				case INDEXSET: {
+					StringBuilder result = new StringBuilder();
+					result.append(expression.target);
+					result.append("[");
+					for (int i = 0; i < expression.arguments.arguments.length - 1; i++) {
+						if (i > 0)
+							result.append(", ");
+						
+						result.append(expression.arguments.arguments[i].accept(this).value);
+					}
+					result.append("] = ");
+					result.append(expression.arguments.arguments[expression.arguments.arguments.length - 1].accept(this).value);
+					return new ExpressionString(result.toString(), OperatorPriority.ASSIGN);
+				}
+				case INDEXGET: {
+					StringBuilder result = new StringBuilder();
+					result.append(expression.target);
+					result.append("[");
+					for (int i = 0; i < expression.arguments.arguments.length - 1; i++) {
+						if (i > 0)
+							result.append(", ");
+						
+						result.append(expression.arguments.arguments[i].accept(this));
+					}
+					result.append("]");
+					return new ExpressionString(result.toString(), OperatorPriority.INDEX);
+				}
+				case MEMBERGETTER: {
+					StringBuilder result = new StringBuilder();
+					result.append(expression.target);
+					result.append(".get(");
+					result.append(expression.getFirstArgument().accept(this));
+					result.append(")");
+					return new ExpressionString(result.toString(), OperatorPriority.MEMBER);
+				}
+				case MEMBERSETTER: {
+					StringBuilder result = new StringBuilder();
+					result.append(expression.target);
+					result.append(".set(");
+					result.append(expression.getFirstArgument().accept(this));
+					result.append(", ");
+					result.append(expression.arguments.arguments[1].accept(this));
+					result.append(")");
+					return new ExpressionString(result.toString(), OperatorPriority.MEMBER);
+				}
+				case ADDASSIGN:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " += ");
+				case SUBASSIGN:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " -= ");
+				case MULASSIGN:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " *= ");
+				case DIVASSIGN:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " /= ");
+				case MODASSIGN:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " %= ");
+				case CATASSIGN:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " ~= ");
+				case ORASSIGN:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " |= ");
+				case ANDASSIGN:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " &= ");
+				case XORASSIGN:
+					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " ^= ");
+				case POST_INCREMENT:
+					return unaryPostfix(expression.target, OperatorPriority.DECREMENT, "++");
+				case POST_DECREMENT:
+					return unaryPostfix(expression.target, OperatorPriority.DECREMENT, "--");
+				case PRE_INCREMENT:
+					return unaryPrefix(expression.target, OperatorPriority.DECREMENT, "++");
+				case PRE_DECREMENT:
+					return unaryPrefix(expression.target, OperatorPriority.DECREMENT, "--");
+				case CALL: {
+					StringBuilder result = new StringBuilder();
+					result.append(".");
+					format(result, expression.arguments);
+					return new ExpressionString(result.toString(), OperatorPriority.CALL);
+				}
+				case CAST: {
+					StringBuilder result = new StringBuilder();
+					result.append(" as ");
+					result.append(expression.arguments.typeArguments[0].accept(typeFormatter));
+					return new ExpressionString(result.toString(), OperatorPriority.CAST);
+				}
+				default:
+					throw new UnsupportedOperationException("Unknown operator: " + operator.operator);
+			}
+		} else if (expression.member instanceof CasterMember) {
+			CasterMember casterMember = (CasterMember) expression.member;
+			
+			StringBuilder result = new StringBuilder();
+			result.append(expression.target.accept(this).value);
+			if (!casterMember.isImplicit()) {
+				result.append(" as ");
+				result.append(casterMember.toType.accept(typeFormatter));
+			}
+			return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+		} else {
+			StringBuilder result = new StringBuilder();
+			result.append(expression.target.accept(this).value);
+			result.append(".");
+			result.append(expression.member.name);
+			format(result, expression.arguments);
+			return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+		}
+	}
+
+	@Override
+	public ExpressionString visitCallStatic(CallStaticExpression expression) {
+		StringBuilder result = new StringBuilder();
+		result.append(expression.type.accept(typeFormatter));
+		result.append(".");
+		result.append(expression.member.name);
+		format(result, expression.arguments);
+		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+	}
+	
+	private void format(StringBuilder result, CallArguments arguments) {
+		if (arguments.typeArguments.length > 0) {
+			result.append("<");
+			
+			int index = 0;
+			for (ITypeID typeArgument : arguments.typeArguments) {
+				if (index > 0)
+					result.append(", ");
+				result.append(typeArgument.accept(typeFormatter));
+				index++;
+			}
+			result.append(">");
+		}
+		result.append("(");
+		int index = 0;
+		for (Expression argument : arguments.arguments) {
+			if (index > 0)
+				result.append(", ");
+			result.append(argument.accept(this).value);
+			index++;
+		}
+		result.append(")");
+	}
+
+	@Override
+	public ExpressionString visitCapturedClosure(CapturedClosureExpression expression) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public ExpressionString visitCapturedDirect(CapturedDirectExpression expression) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public ExpressionString visitCapturedLocalVariable(CapturedLocalVariableExpression expression) {
+		return new ExpressionString(expression.variable.name, OperatorPriority.PRIMARY);
+	}
+
+	@Override
+	public ExpressionString visitCapturedParameter(CapturedParameterExpression expression) {
+		return new ExpressionString(expression.parameter.name, OperatorPriority.PRIMARY);
+	}
+
+	@Override
+	public ExpressionString visitCapturedThis(CapturedThisExpression expression) {
+		return new ExpressionString("this", OperatorPriority.PRIMARY);
+	}
+
+	@Override
+	public ExpressionString visitCheckNull(CheckNullExpression expression) {
+		return expression.value.accept(this);
+	}
+
+	@Override
+	public ExpressionString visitCoalesce(CoalesceExpression expression) {
+		return binary(expression.left, expression.right, OperatorPriority.COALESCE, " ?? ");
+	}
+
+	@Override
+	public ExpressionString visitConditional(ConditionalExpression expression) {
+		StringBuilder result = new StringBuilder();
+		result.append(expression.condition.accept(this));
+		result.append(" ? ");
+		result.append(expression.ifThen.accept(this));
+		result.append(" : ");
+		result.append(expression.ifElse.accept(this));
+		return new ExpressionString(result.toString(), OperatorPriority.TERNARY);
+	}
+
+	@Override
+	public ExpressionString visitConstantBool(ConstantBoolExpression expression) {
+		return new ExpressionString(expression.value ? "true" : "false", OperatorPriority.PRIMARY);
+	}
+
+	@Override
+	public ExpressionString visitConstantByte(ConstantByteExpression expression) {
+		return new ExpressionString(Byte.toString(expression.value) + " as byte", OperatorPriority.CAST);
+	}
+
+	@Override
+	public ExpressionString visitConstantChar(ConstantCharExpression expression) {
+		return new ExpressionString(
+				StringUtils.escape(Character.toString(expression.value), '\'', true),
+				OperatorPriority.PRIMARY);
+	}
+
+	@Override
+	public ExpressionString visitConstantDouble(ConstantDoubleExpression expression) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public ExpressionString visitConstantFloat(ConstantFloatExpression expression) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public ExpressionString visitConstantInt(ConstantIntExpression expression) {
+		return new ExpressionString(Integer.toString(expression.value), OperatorPriority.PRIMARY);
+	}
+
+	@Override
+	public ExpressionString visitConstantLong(ConstantLongExpression expression) {
+		return new ExpressionString(Long.toString(expression.value), OperatorPriority.PRIMARY);
+	}
+
+	@Override
+	public ExpressionString visitConstantSByte(ConstantSByteExpression expression) {
+		return new ExpressionString(Byte.toString(expression.value) + " as sbyte", OperatorPriority.CAST);
+	}
+
+	@Override
+	public ExpressionString visitConstantShort(ConstantShortExpression expression) {
+		return new ExpressionString(Integer.toString(expression.value) + " as short", OperatorPriority.CAST);
+	}
+
+	@Override
+	public ExpressionString visitConstantString(ConstantStringExpression expression) {
+		return new ExpressionString(StringUtils.escape(
+				expression.value,
+				settings.useSingleQuotesForStrings ? '\'' : '"',
+				true), OperatorPriority.CAST);
+	}
+
+	@Override
+	public ExpressionString visitConstantUInt(ConstantUIntExpression expression) {
+		return new ExpressionString(Integer.toString(expression.value) + " as uint", OperatorPriority.CAST);
+	}
+
+	@Override
+	public ExpressionString visitConstantULong(ConstantULongExpression expression) {
+		return new ExpressionString(Long.toString(expression.value) + " as ulong", OperatorPriority.CAST);
+	}
+
+	@Override
+	public ExpressionString visitConstantUShort(ConstantUShortExpression expression) {
+		return new ExpressionString(Integer.toString(expression.value) + " as ushort", OperatorPriority.CAST);
+	}
+
+	@Override
+	public ExpressionString visitConstructorThisCall(ConstructorThisCallExpression expression) {
+		StringBuilder result = new StringBuilder();
+		result.append("this");
+		format(result, expression.arguments);
+		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+	}
+
+	@Override
+	public ExpressionString visitConstructorSuperCall(ConstructorSuperCallExpression expression) {
+		StringBuilder result = new StringBuilder();
+		result.append("super");
+		format(result, expression.arguments);
+		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+	}
+
+	@Override
+	public ExpressionString visitEnumConstant(EnumConstantExpression expression) {
+		return new ExpressionString(expression.type.accept(typeFormatter) + "." + expression.value.name, OperatorPriority.MEMBER);
+	}
+
+	@Override
+	public ExpressionString visitEquals(EqualsExpression expression) {
+		return binary(expression.left, expression.right, OperatorPriority.COMPARE, " === ");
+	}
+
+	@Override
+	public ExpressionString visitFunction(FunctionExpression expression) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public ExpressionString visitGenericCompare(GenericCompareExpression expression) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public ExpressionString visitGetField(GetFieldExpression expression) {
+		StringBuilder result = new StringBuilder();
+		result.append(expression.target.accept(this));
+		result.append('.');
+		result.append(expression.field.name);
+		return new ExpressionString(result.toString(), OperatorPriority.MEMBER);
+	}
+
+	@Override
+	public ExpressionString visitGetFunctionParameter(GetFunctionParameterExpression expression) {
+		return new ExpressionString(expression.parameter.name, OperatorPriority.PRIMARY);
+	}
+
+	@Override
+	public ExpressionString visitGetLocalVariable(GetLocalVariableExpression expression) {
+		return new ExpressionString(expression.variable.name, OperatorPriority.PRIMARY);
+	}
+
+	@Override
+	public ExpressionString visitGetStaticField(GetStaticFieldExpression expression) {
+		StringBuilder result = new StringBuilder();
+		result.append(expression.type.accept(typeFormatter));
+		result.append('.');
+		result.append(expression.field.name);
+		return new ExpressionString(result.toString(), OperatorPriority.MEMBER);
+	}
+
+	@Override
+	public ExpressionString visitGetter(GetterExpression expression) {
+		StringBuilder result = new StringBuilder();
+		result.append(expression.target.accept(this));
+		result.append('.');
+		result.append(expression.getter.name);
+		return new ExpressionString(result.toString(), OperatorPriority.MEMBER);
+	}
+
+	@Override
+	public ExpressionString visitInterfaceCast(InterfaceCastExpression expression) {
+		StringBuilder result = new StringBuilder();
+		result.append(expression.value.accept(this).value);
+		result.append(" as ");
+		result.append(expression.type.accept(typeFormatter));
+		return new ExpressionString(result.toString(), OperatorPriority.CAST);
+	}
+
+	@Override
+	public ExpressionString visitIs(IsExpression expression) {
+		StringBuilder result = new StringBuilder();
+		result.append(expression.value.accept(this).value);
+		result.append(" is ");
+		result.append(expression.type.accept(typeFormatter));
+		return new ExpressionString(result.toString(), OperatorPriority.COMPARE);
+	}
+
+	@Override
+	public ExpressionString visitMakeConst(MakeConstExpression expression) {
+		return expression.accept(this);
+	}
+
+	@Override
+	public ExpressionString visitMap(MapExpression expression) {
+		StringBuilder result = new StringBuilder();
+		result.append("{");
+		for (int i = 0; i < expression.keys.length; i++) {
+			if (i > 0)
+				result.append(", ");
+			result.append(expression.keys[i].accept(this));
+			result.append(": ");
+			result.append(expression.values[i].accept(this));
+		}
+		result.append("}");
+		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+	}
+
+	@Override
+	public ExpressionString visitNew(NewExpression expression) {
+		StringBuilder result = new StringBuilder();
+		result.append("new ");
+		result.append(expression.type.accept(typeFormatter));
+		format(result, expression.arguments);
+		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+	}
+
+	@Override
+	public ExpressionString visitNot(NotExpression expression) {
+		return unaryPrefix(expression.value, OperatorPriority.NOT, "!");
+	}
+
+	@Override
+	public ExpressionString visitNull(NullExpression expression) {
+		return new ExpressionString("null", OperatorPriority.PRIMARY);
+	}
+
+	@Override
+	public ExpressionString visitOrOr(OrOrExpression expression) {
+		return binary(expression.left, expression.right, OperatorPriority.OROR, " || ");
+	}
+
+	@Override
+	public ExpressionString visitRange(RangeExpression expression) {
+		return binary(expression.from, expression.to, OperatorPriority.RANGE, " .. ");
+	}
+
+	@Override
+	public ExpressionString visitSetField(SetFieldExpression expression) {
+		return new ExpressionString(
+				expression.target.accept(this) + "." + expression.field.name + " = " + expression.value.accept(this).value, 
+				OperatorPriority.ASSIGN);
+	}
+
+	@Override
+	public ExpressionString visitSetFunctionParameter(SetFunctionParameterExpression expression) {
+		return new ExpressionString(
+				expression.parameter.name + " = " + expression.value.accept(this).value,
+				OperatorPriority.ASSIGN);
+	}
+
+	@Override
+	public ExpressionString visitSetLocalVariable(SetLocalVariableExpression expression) {
+		return new ExpressionString(
+				expression.variable.name + " = " + expression.value.accept(this).value,
+				OperatorPriority.ASSIGN);
+	}
+
+	@Override
+	public ExpressionString visitSetStaticField(SetStaticFieldExpression expression) {
+		return new ExpressionString(
+				expression.type.accept(typeFormatter) + "." + expression.field.name + " = " + expression.value.accept(this).value,
+				OperatorPriority.ASSIGN);
+	}
+
+	@Override
+	public ExpressionString visitSetter(SetterExpression expression) {
+		return new ExpressionString(
+				expression.target.accept(this) + "." + expression.setter.name + " = " + expression.value.accept(this),
+				OperatorPriority.ASSIGN);
+	}
+
+	@Override
+	public ExpressionString visitStaticGetter(StaticGetterExpression expression) {
+		return new ExpressionString(
+				expression.type.accept(typeFormatter) + "." + expression.getter.name, 
+				OperatorPriority.MEMBER);
+	}
+
+	@Override
+	public ExpressionString visitStaticSetter(StaticSetterExpression expression) {
+		return new ExpressionString(
+				expression.type.accept(typeFormatter) + "." + expression.setter.name + " = " + expression.setter.name,
+				OperatorPriority.ASSIGN);
+	}
+
+	@Override
+	public ExpressionString visitThis(ThisExpression expression) {
+		return new ExpressionString("this", OperatorPriority.PRIMARY);
+	}
+
+	@Override
+	public ExpressionString visitWrapOptional(WrapOptionalExpression expression) {
+		return expression.value.accept(this);
+	}
+	
+	private ExpressionString unaryPrefix(Expression value, OperatorPriority operator, String operatorString) {
+		return new ExpressionString(operatorString + value.accept(this).value, operator);
+	}
+	
+	private ExpressionString unaryPostfix(Expression value, OperatorPriority operator, String operatorString) {
+		return new ExpressionString(value.accept(this).value + operatorString, operator);
+	}
+	
+	private ExpressionString binary(Expression left, Expression right, OperatorPriority operator, String operatorString) {
+		String value = left.accept(this).wrapLeft(operator)
+				+ operatorString + right.accept(this).wrapRight(operator);
+		return new ExpressionString(value, operator);
+	}
+}

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/ExpressionString.java

@@ -0,0 +1,33 @@
+/*
+ * 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.formatter;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ExpressionString {
+	public final String value;
+	public final OperatorPriority priority;
+	
+	public ExpressionString(String value, OperatorPriority priority) {
+		this.value = value;
+		this.priority = priority;
+	}
+	
+	public String wrapLeft(OperatorPriority outer) {
+		return OperatorPriority.shouldWrapLeft(priority, outer) ? "(" + value + ")" : value;
+	}
+	
+	public String wrapRight(OperatorPriority outer) {
+		return OperatorPriority.shouldWrapRight(priority, outer) ? "(" + value + ")" : value;
+	}
+	
+	@Override
+	public String toString() {
+		return value;
+	}
+}

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/FileFormatter.java

@@ -0,0 +1,91 @@
+/*
+ * 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.formatter;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.statement.Statement;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class FileFormatter {
+	private final FormattingSettings settings;
+	
+	public FileFormatter(FormattingSettings settings) {
+		this.settings = settings;
+	}
+	
+	// Formats the given scripts and definitions into a file
+	public String format(ZSPackage pkg, ScriptBlock script, List<HighLevelDefinition> definitions) {
+		FileImporter importer = new FileImporter(pkg);
+		
+		TypeFormatter typeFormatter = new TypeFormatter(settings, importer);
+		ExpressionFormatter expressionFormatter = new ExpressionFormatter(settings, typeFormatter);
+		
+		StatementFormatter scriptFormatter = new StatementFormatter("", settings, expressionFormatter);
+		for (Statement statement : script.statements) {
+			statement.accept(scriptFormatter);
+		}
+		
+		StringBuilder output = new StringBuilder();
+		importer.write(output);
+		output.append(scriptFormatter.toString().trim());
+		return output.toString();
+	}
+	
+	private class FileImporter implements Importer {
+		private final ZSPackage pkg;
+		private final Map<String, HighLevelDefinition> imports = new HashMap<>();
+		
+		public FileImporter(ZSPackage pkg) {
+			this.pkg = pkg;
+		}
+		
+		public void write(StringBuilder output) {
+			Map<ZSPackage, List<HighLevelDefinition>> importsByPackage = new HashMap<>();
+			for (HighLevelDefinition definition : imports.values()) {
+				if (!importsByPackage.containsKey(definition.pkg))
+					importsByPackage.put(definition.pkg, new ArrayList<>());
+				
+				importsByPackage.get(definition.pkg).add(definition);
+			}
+			
+			List<ZSPackage> sortedPackages = new ArrayList<>(importsByPackage.keySet());
+			Collections.sort(sortedPackages, (a, b) -> a.fullName.compareTo(b.fullName));
+			for (ZSPackage pkg : sortedPackages) {
+				for (HighLevelDefinition definition : importsByPackage.get(pkg))
+					output.append("import ").append(pkg.fullName).append('.').append(definition.name).append(";\n");
+			}
+			
+			if (imports.size() > 0)
+				output.append("\n");
+		}
+		
+		@Override
+		public String importDefinition(HighLevelDefinition definition) {
+			if (definition.pkg == pkg)
+				return definition.name;
+			
+			if (imports.get(definition.name) == definition)
+				return definition.name;
+			
+			if (imports.containsKey(definition.name) || pkg.contains(definition.name)) {
+				return definition.pkg.fullName + '.' + definition.name;
+			} else {
+				imports.put(definition.name, definition);
+				return definition.name;
+			}
+		}
+	}
+}

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/FormattingSettings.java

@@ -0,0 +1,272 @@
+/*
+ * 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.formatter;
+
+import org.openzen.zenscript.shared.StringUtils;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class FormattingSettings {
+	public final boolean showAnyInFunctionHeaders;
+	public final boolean useSingleQuotesForStrings;
+	public final boolean useTabs; // use tabs instead of spaces
+	public final int spacesPerTab; // number of spaces per tab
+	public final boolean spaceBeforeLabelColon;
+	public final boolean spaceAfterLabelColon;
+	public final boolean bracketsAroundConditions;
+	public final boolean ifElseForceBrackets;
+	public final boolean ifElseAvoidBrackets;
+	public final boolean loopForceBrackets;
+	public final boolean loopAvoidBrackets;
+	public final boolean tryCatchForceBrackets;
+	public final boolean tryCatchAvoidBrackets;
+	public final boolean ifSingleLineOnSameLine;
+	public final boolean elseSingleLineOnSameLine;
+	public final boolean loopSingleLineOnSameLine;
+	public final boolean ifBracketOnSameLine;
+	public final boolean elseBracketOnSameLine;
+	public final boolean loopBracketOnSameLine;
+	public final boolean tryCatchNewLine; // new line between } and catch or } and finally
+	public final boolean tryCatchBracketOnSameLine;
+	
+	public final String indent;
+	
+	private FormattingSettings(Builder builder) {
+		showAnyInFunctionHeaders = builder.showAnyInFunctionHeaders;
+		useSingleQuotesForStrings = builder.useSingleQuotesForStrings;
+		useTabs = builder.useTabs;
+		spacesPerTab = builder.spacesPerTab;
+		spaceBeforeLabelColon = builder.spaceBeforeLabelColon;
+		spaceAfterLabelColon = builder.spaceAfterLabelColon;
+		bracketsAroundConditions = builder.bracketsAroundConditions;
+		ifElseForceBrackets = builder.ifElseForceBrackets;
+		ifElseAvoidBrackets = builder.ifElseAvoidBrackets;
+		loopForceBrackets = builder.loopForceBrackets;
+		loopAvoidBrackets = builder.loopAvoidBrackets;
+		tryCatchForceBrackets = builder.tryCatchForceBrackets;
+		tryCatchAvoidBrackets = builder.tryCatchAvoidBrackets;
+		ifSingleLineOnSameLine = builder.ifSingleLineOnSameLine;
+		elseSingleLineOnSameLine = builder.elseSingleLineOnSameLine;
+		loopSingleLineOnSameLine = builder.loopSingleLineOnSameLine;
+		ifBracketOnSameLine = builder.ifBracketOnSameLine;
+		elseBracketOnSameLine = builder.elseBracketOnSameLine;
+		loopBracketOnSameLine = builder.loopBracketOnSameLine;
+		tryCatchNewLine = builder.tryCatchNewLine;
+		tryCatchBracketOnSameLine = builder.tryCatchBracketOnSameLine;
+		
+		if (useTabs) {
+			indent = "\t";
+		} else {
+			indent = StringUtils.times(' ', spacesPerTab);
+		}
+	}
+	
+	public String getSingleLineSeparator(String indent, ParentStatementType position) {
+		switch (position) {
+			case NONE:
+				return "\n" + indent;
+				
+			case IF:
+			case IF_WITH_ELSE:
+				if (ifSingleLineOnSameLine)
+					return " ";
+				else
+					return "\n" + indent + this.indent;
+				
+			case ELSE:
+				if (elseSingleLineOnSameLine)
+					return " ";
+				else
+					return "\n" + indent + this.indent;
+				
+			case LOOP:
+				if (loopSingleLineOnSameLine)
+					return " ";
+				else
+					return "\n" + indent + this.indent;
+				
+			case TRY:
+			case CATCH:
+			case FINALLY:
+				return "\n" + indent + this.indent;
+			
+			default:
+				return "\n" + indent + this.indent;
+		}
+	}
+	
+	public String getBlockSeparator(String indent, ParentStatementType position) {
+		switch (position) {
+			case NONE:
+				return "\n" + indent + "{";
+				
+			case IF:
+			case IF_WITH_ELSE:
+				if (ifBracketOnSameLine)
+					return " {";
+				else
+					return "\n" + indent + "{";
+				
+			case ELSE:
+				if (elseBracketOnSameLine)
+					return " {";
+				else
+					return "\n" + indent + "{";
+				
+			case LOOP:
+				if (loopBracketOnSameLine)
+					return " {";
+				else
+					return "\n" + indent + "{";
+			
+			case TRY:
+			case CATCH:
+			case FINALLY:
+				if (tryCatchBracketOnSameLine)
+					return " {";
+				else
+					return "\n" + indent + "{";
+			
+			default:
+				return "\n" + indent + this.indent;
+		}
+	}
+	
+	public static class Builder {
+		private boolean showAnyInFunctionHeaders = false;
+		private boolean useSingleQuotesForStrings = true;
+		private boolean useTabs = false;
+		private int spacesPerTab = 4;
+		private boolean spaceBeforeLabelColon = true;
+		private boolean spaceAfterLabelColon = false;
+		private boolean bracketsAroundConditions = false;
+		private boolean ifElseForceBrackets = false;
+		private boolean ifElseAvoidBrackets = true;
+		private boolean loopForceBrackets = false;
+		private boolean loopAvoidBrackets = true;
+		private boolean tryCatchForceBrackets = true;
+		private boolean tryCatchAvoidBrackets = false;
+		private boolean ifSingleLineOnSameLine = false;
+		private boolean elseSingleLineOnSameLine = false;
+		private boolean loopSingleLineOnSameLine = false;
+		private boolean ifBracketOnSameLine = true;
+		private boolean elseBracketOnSameLine = true;
+		private boolean loopBracketOnSameLine = true;
+		private boolean tryCatchNewLine = true;
+		private boolean tryCatchBracketOnSameLine = true;
+		
+		public Builder showAnyInFunctionHeaders(boolean show) {
+			showAnyInFunctionHeaders = show;
+			return this;
+		}
+		
+		public Builder useSingleQuotesForStrings(boolean single) {
+			useSingleQuotesForStrings = single;
+			return this;
+		}
+		
+		public Builder useTabs(boolean tabs) {
+			useTabs = tabs;
+			return this;
+		}
+		
+		public Builder spacesPerTabs(int spaces) {
+			spacesPerTab = spaces;
+			return this;
+		}
+		
+		public Builder spaceBeforeLabelColon(boolean space) {
+			spaceBeforeLabelColon = space;
+			return this;
+		}
+		
+		public Builder spaceAfterLabelColon(boolean space) {
+			spaceAfterLabelColon = space;
+			return this;
+		}
+		
+		public Builder bracketsAroundConditions(boolean brackets) {
+			bracketsAroundConditions = brackets;
+			return this;
+		}
+		
+		public Builder ifElseForceBrackets(boolean force) {
+			ifElseForceBrackets = force;
+			return this;
+		}
+		
+		public Builder ifElseAvoidBrackets(boolean avoid) {
+			ifElseAvoidBrackets = avoid;
+			return this;
+		}
+		
+		public Builder loopForceBrackets(boolean force) {
+			loopForceBrackets = force;
+			return this;
+		}
+		
+		public Builder loopAvoidBrackets(boolean avoid) {
+			loopAvoidBrackets = avoid;
+			return this;
+		}
+		
+		public Builder tryCatchForceBrackets(boolean force) {
+			tryCatchForceBrackets = force;
+			return this;
+		}
+		
+		public Builder tryCatchAvoidBrackets(boolean avoid) {
+			tryCatchAvoidBrackets = avoid;
+			return this;
+		}
+		
+		public Builder ifSingleLineOnSameLine(boolean sameLine) {
+			ifSingleLineOnSameLine = sameLine;
+			return this;
+		}
+		
+		public Builder elseSingleLineOnSameLine(boolean sameLine) {
+			elseSingleLineOnSameLine = sameLine;
+			return this;
+		}
+		
+		public Builder loopSingleLineOnSameLine(boolean sameLine) {
+			loopSingleLineOnSameLine = sameLine;
+			return this;
+		}
+		
+		public Builder ifBracketOnSameLine(boolean sameLine) {
+			ifBracketOnSameLine = sameLine;
+			return this;
+		}
+		
+		public Builder elseBracketOnSameLine(boolean sameLine) {
+			elseBracketOnSameLine = sameLine;
+			return this;
+		}
+		
+		public Builder loopBracketOnSameLine(boolean sameLine) {
+			loopBracketOnSameLine = sameLine;
+			return this;
+		}
+		
+		public Builder tryCatchNewLine(boolean newLine) {
+			tryCatchNewLine = newLine;
+			return this;
+		}
+		
+		public Builder tryCatchBracketOnSameLine(boolean sameLine) {
+			tryCatchBracketOnSameLine = sameLine;
+			return this;
+		}
+		
+		public FormattingSettings build() {
+			return new FormattingSettings(this);
+		}
+	}
+}

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/Importer.java

@@ -0,0 +1,16 @@
+/*
+ * 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.formatter;
+
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface Importer {
+	String importDefinition(HighLevelDefinition definition);
+}

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/OperatorPriority.java

@@ -0,0 +1,73 @@
+/*
+ * 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.formatter;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public enum OperatorPriority {
+	ADD(6),
+	SUB(6),
+	MUL(7),
+	DIV(7),
+	MOD(7),
+	CAT(6),
+	OR(4),
+	AND(4),
+	XOR(4),
+	NEG(8),
+	NOT(8),
+	INVERT(8),
+	CONTAINS(5),
+	COMPARE(5),
+	ASSIGN(0),
+	ADDASSIGN(0),
+	SUBASSIGN(0),
+	MULASSIGN(0),
+	DIVASSIGN(0),
+	MODASSIGN(0),
+	CATASSIGN(0),
+	ORASSIGN(0),
+	ANDASSIGN(0),
+	XORASSIGN(0),
+	
+	ANDAND(3),
+	OROR(2),
+	
+	TERNARY(1),
+	COALESCE(2),
+	
+	INCREMENT(8),
+	DECREMENT(8),
+	MEMBER(9),
+	RANGE(9),
+	INDEX(9),
+	CALL(9),
+	CAST(9),
+	
+	PRIMARY(10);
+	
+	private final int priority;
+	private final boolean isCommutative;
+	
+	private OperatorPriority(int priority) {
+		this(priority, false);
+	}
+	
+	private OperatorPriority(int priority, boolean isCommutative) {
+		this.priority = priority;
+		this.isCommutative = isCommutative;
+	}
+	
+	public static boolean shouldWrapLeft(OperatorPriority inner, OperatorPriority outer) {
+		return inner == outer || inner.priority > outer.priority;
+	}
+	
+	public static boolean shouldWrapRight(OperatorPriority inner, OperatorPriority outer) {
+		return (inner == outer && inner.isCommutative) || (inner.priority > outer.priority);
+	}
+}

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/ParentStatementType.java

@@ -0,0 +1,21 @@
+/*
+ * 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.formatter;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public enum ParentStatementType {
+	NONE,
+	IF,
+	IF_WITH_ELSE,
+	ELSE,
+	LOOP,
+	TRY,
+	CATCH,
+	FINALLY;
+}

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/StatementFormatter.java

@@ -0,0 +1,296 @@
+/*
+ * 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.formatter;
+
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.statement.BlockStatement;
+import org.openzen.zenscript.codemodel.statement.BreakStatement;
+import org.openzen.zenscript.codemodel.statement.CatchClause;
+import org.openzen.zenscript.codemodel.statement.ContinueStatement;
+import org.openzen.zenscript.codemodel.statement.DoWhileStatement;
+import org.openzen.zenscript.codemodel.statement.EmptyStatement;
+import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
+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.ReturnStatement;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.StatementVisitor;
+import org.openzen.zenscript.codemodel.statement.ThrowStatement;
+import org.openzen.zenscript.codemodel.statement.TryCatchStatement;
+import org.openzen.zenscript.codemodel.statement.VarStatement;
+import org.openzen.zenscript.codemodel.statement.WhileStatement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class StatementFormatter implements StatementVisitor<Void> {
+	private final FormattingSettings settings;
+	private final StringBuilder result;
+	private final ExpressionFormatter expressionFormatter;
+	
+	private String indent;
+	private ParentStatementType position = ParentStatementType.NONE;
+	
+	public StatementFormatter(String indent, FormattingSettings settings, ExpressionFormatter expressionFormatter) {
+		this.indent = indent;
+		this.settings = settings;
+		result = new StringBuilder();
+		this.expressionFormatter = expressionFormatter;
+	}
+	
+	@Override
+	public String toString() {
+		return result.toString();
+	}
+
+	@Override
+	public Void visitBlock(BlockStatement statement) {
+		beginBlock();
+		
+		String oldIndent = indent;
+		indent = oldIndent + settings.indent;
+		for (Statement subStatement : statement.statements) {
+			format(ParentStatementType.NONE, subStatement);
+		}
+		indent = oldIndent;
+		endBlock();
+		return null;
+	}
+
+	@Override
+	public Void visitBreak(BreakStatement statement) {
+		beginSingleLine();
+		result.append("break");
+		if (statement.target != null)
+			result.append(' ').append(statement.target.label);
+		result.append(";");
+		endSingleLine();
+		return null;
+	}
+
+	@Override
+	public Void visitContinue(ContinueStatement statement) {
+		beginSingleLine();
+		result.append("continue");
+		if (statement.target != null)
+			result.append(' ').append(statement.target.label);
+		result.append(";");
+		endSingleLine();
+		return null;
+	}
+
+	@Override
+	public Void visitDoWhile(DoWhileStatement statement) {
+		beginSingleLine();
+		result.append("do");
+		if (statement.label != null) {
+			if (settings.spaceBeforeLabelColon)
+				result.append(' ');
+			result.append(':');
+			if (settings.spaceAfterLabelColon)
+				result.append(' ');
+			result.append(statement.label);
+		}
+		format(ParentStatementType.LOOP, statement.content);
+		result.append(" while ");
+		appendCondition(statement.condition);
+		result.append(";");
+		endSingleLine();
+		return null;
+	}
+
+	@Override
+	public Void visitEmpty(EmptyStatement statement) {
+		beginSingleLine();
+		result.append(";\n");
+		endSingleLine();
+		return null;
+	}
+
+	@Override
+	public Void visitExpression(ExpressionStatement statement) {
+		beginSingleLine();
+		result.append(statement.expression.accept(expressionFormatter).value)
+			  .append(";");
+		endSingleLine();
+		return null;
+	}
+
+	@Override
+	public Void visitForeach(ForeachStatement statement) {
+		beginSingleLine();
+		result.append("for ");
+		for (int i = 0; i < statement.loopVariables.length; i++) {
+			if (i > 0)
+				result.append(", ");
+			
+			result.append(statement.loopVariables[i].name);
+		}
+		result.append(" in ");
+		result.append(statement.list.accept(expressionFormatter).value);
+		format(ParentStatementType.LOOP, statement.content);
+		endSingleLine();
+		return null;
+	}
+
+	@Override
+	public Void visitIf(IfStatement statement) {
+		ParentStatementType position = this.position;
+		beginSingleLine();
+		result.append("if ");
+		appendCondition(statement.condition);
+		format(statement.onElse == null ? ParentStatementType.IF : ParentStatementType.IF_WITH_ELSE, statement.onThen);
+		if (statement.onElse != null) {
+			result.append("else");
+			format(ParentStatementType.ELSE, statement.onElse);
+		}
+		endSingleLine();
+		return null;
+	}
+
+	@Override
+	public Void visitLock(LockStatement statement) {
+		beginSingleLine();
+		result.append("lock ");
+		result.append(statement.object.accept(expressionFormatter).value);
+		statement.content.accept(this);
+		endSingleLine();
+		return null;
+	}
+
+	@Override
+	public Void visitReturn(ReturnStatement statement) {
+		beginSingleLine();
+		result.append("return");
+		if (statement.value != null) {
+			result.append(' ');
+			result.append(statement.value.accept(expressionFormatter).value);
+		}
+		result.append(";");
+		endSingleLine();
+		return null;
+	}
+
+	@Override
+	public Void visitThrow(ThrowStatement statement) {
+		beginSingleLine();
+		result.append("throw ").append(statement.value.accept(expressionFormatter));
+		endSingleLine();
+		return null;
+	}
+
+	@Override
+	public Void visitTryCatch(TryCatchStatement statement) {
+		beginSingleLine();
+		result.append("try");
+		if (statement.resourceName != null) {
+			result.append(' ').append(statement.resourceName);
+			result.append(" = ");
+			result.append(statement.resourceInitializer.accept(expressionFormatter).value);
+		}
+		
+		format(ParentStatementType.TRY, statement.content);
+		
+		for (CatchClause catchClause : statement.catchClauses) {
+			result.append(indent).append("catch ");
+			if (catchClause.exceptionName != null)
+				result.append(catchClause.exceptionName);
+			if (catchClause.exceptionType != BasicTypeID.ANY) {
+				result.append(" as ");
+				catchClause.exceptionType.accept(expressionFormatter.typeFormatter);
+			}
+			
+			format(ParentStatementType.CATCH, catchClause.content);
+		}
+		if (statement.finallyClause != null) {
+			result.append(indent).append("finally ");
+			
+			format(ParentStatementType.FINALLY, statement.finallyClause);
+		}
+		endSingleLine();
+		return null;
+	}
+
+	@Override
+	public Void visitVar(VarStatement statement) {
+		beginSingleLine();
+		result.append(statement.isFinal ? "val " : "var ");
+		result.append(statement.name);
+		
+		if (statement.initializer == null || statement.initializer.type != statement.type) {
+			result.append(" as ");
+			result.append(statement.type.accept(expressionFormatter.typeFormatter));
+		}
+		if (statement.initializer != null) {
+			result.append(" = ");
+			result.append(statement.initializer.accept(expressionFormatter).value);
+		}
+		result.append(";");
+		endSingleLine();
+		return null;
+	}
+
+	@Override
+	public Void visitWhile(WhileStatement statement) {
+		beginSingleLine();
+		result.append("while");
+		if (statement.label != null) {
+			if (settings.spaceBeforeLabelColon)
+				result.append(' ');
+			result.append(':');
+			if (settings.spaceAfterLabelColon)
+				result.append(' ');
+			result.append(statement.label);
+		}
+		result.append(' ');
+		appendCondition(statement.condition);
+		
+		format(ParentStatementType.LOOP, statement.content);
+		endSingleLine();
+		return null;
+	}
+	
+	private void format(ParentStatementType position, Statement statement) {
+		ParentStatementType oldPosition = this.position;
+		this.position = position;
+		statement.accept(this);
+		this.position = oldPosition;
+	}
+	
+	private void appendCondition(Expression condition) {
+		if (settings.bracketsAroundConditions)
+			result.append('(');
+		result.append(condition.accept(expressionFormatter).value);
+		if (settings.bracketsAroundConditions)
+			result.append(')');
+	}
+	
+	private void beginBlock() {
+		result.append(settings.getBlockSeparator(indent, position));
+	}
+	
+	private void endBlock() {
+		result.append("\n").append(indent).append("}");
+		if (position == ParentStatementType.IF_WITH_ELSE) {
+			if (settings.elseBracketOnSameLine)
+				result.append(" ");
+			else
+				result.append("\n").append(indent);
+		}
+	}
+	
+	private void beginSingleLine() {
+		result.append(settings.getSingleLineSeparator(indent, position));
+	}
+	
+	private void endSingleLine() {
+		if (position == ParentStatementType.IF_WITH_ELSE)
+			result.append("\n").append(indent);
+	}
+}

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/TypeFormatter.java

@@ -0,0 +1,171 @@
+/*
+ * 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.formatter;
+
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.GenericParameterBoundVisitor;
+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.codemodel.type.ArrayTypeID;
+import org.openzen.zenscript.codemodel.type.AssocTypeID;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.ConstTypeID;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.FunctionTypeID;
+import org.openzen.zenscript.codemodel.type.GenericTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.ITypeVisitor;
+import org.openzen.zenscript.codemodel.type.IteratorTypeID;
+import org.openzen.zenscript.codemodel.type.OptionalTypeID;
+import org.openzen.zenscript.codemodel.type.RangeTypeID;
+import org.openzen.zenscript.shared.StringUtils;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class TypeFormatter implements ITypeVisitor<String>, GenericParameterBoundVisitor<String> {
+	private final FormattingSettings settings;
+	private final Importer importer;
+	
+	public TypeFormatter(FormattingSettings settings, Importer importer) {
+		this.settings = settings;
+		this.importer = importer;
+	}
+
+	@Override
+	public String visitBasic(BasicTypeID basic) {
+		return basic.name;
+	}
+
+	@Override
+	public String visitArray(ArrayTypeID array) {
+		String element = array.elementType.accept(this);
+		if (array.dimension == 1) {
+			return element + "[]";
+		} else {
+			return element + "[" + StringUtils.times(',', array.dimension - 1) + "]";
+		}
+	}
+
+	@Override
+	public String visitAssoc(AssocTypeID assoc) {
+		return assoc.valueType.accept(this) + "[" + assoc.keyType.accept(this) + "]";
+	}
+
+	@Override
+	public String visitIterator(IteratorTypeID iterator) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public String visitFunction(FunctionTypeID function) {
+		StringBuilder result = new StringBuilder();
+		result.append("function");
+		
+		FunctionHeader header = function.header;
+		formatTypeParameters(result, header.typeParameters);
+		result.append("(");
+		int parameterIndex = 0;
+		for (FunctionParameter parameter : header.parameters) {
+			if (parameterIndex > 0)
+				result.append(", ");
+			
+			result.append(parameter.name);
+			if (parameter.variadic)
+				result.append("...");
+			
+			if (!settings.showAnyInFunctionHeaders || parameter.type != BasicTypeID.ANY) {
+				result.append(" as ");
+				result.append(header.returnType.accept(this));
+			}
+			
+			parameterIndex++;
+		}
+		result.append(")");
+		if (!settings.showAnyInFunctionHeaders || header.returnType != BasicTypeID.ANY) {
+			result.append(" as ");
+			result.append(header.returnType.accept(this));
+		}
+		return result.toString();
+	}
+
+	@Override
+	public String visitDefinition(DefinitionTypeID definition) {
+		String importedName = importer.importDefinition(definition.definition);
+		if (definition.typeParameters.length == 0)
+			return importedName;
+		
+		StringBuilder result = new StringBuilder();
+		result.append(importedName);
+		result.append("<");
+		int index = 0;
+		for (ITypeID typeParameter : definition.typeParameters) {
+			if (index > 0)
+				result.append(", ");
+			
+			result.append(typeParameter.accept(this));
+		}
+		result.append(">");
+		return result.toString();
+	}
+
+	@Override
+	public String visitGeneric(GenericTypeID generic) {
+		return generic.parameter.name;
+	}
+
+	@Override
+	public String visitRange(RangeTypeID range) {
+		return range.from.accept(this) + " .. " + range.to.accept(this);
+	}
+
+	@Override
+	public String visitConst(ConstTypeID type) {
+		return "const " + type.accept(this);
+	}
+
+	@Override
+	public String visitOptional(OptionalTypeID optional) {
+		return optional.accept(this) + "?";
+	}
+	
+	private void formatTypeParameters(StringBuilder result, TypeParameter[] parameters) {
+		if (parameters.length > 0) {
+			result.append("<");
+			int index = 0;
+			for (TypeParameter parameter : parameters) {
+				if (index > 0)
+					result.append(", ");
+				
+				result.append(parameter.name);
+				
+				if (parameter.bounds.size() > 0) {
+					for (GenericParameterBound bound : parameter.bounds) {
+						result.append(": ");
+						result.append(bound.accept(this));
+					}
+				}
+				
+				index++;
+			}
+			result.append(">");
+		}
+	}
+
+	@Override
+	public String visitSuper(ParameterSuperBound bound) {
+		return "super " + bound.type.accept(this);
+	}
+
+	@Override
+	public String visitType(ParameterTypeBound bound) {
+		return bound.type.accept(this);
+	}
+}

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

@@ -38,12 +38,18 @@ public class FunctionHeader {
 		this.typeParameters = NO_GENERIC_PARAMETERS;
 		this.returnType = returnType;
 		this.parameters = parameters;
+		
+		for (int i = 0; i < parameters.length; i++)
+			parameters[i].index = i;
 	}
 	
 	public FunctionHeader(TypeParameter[] genericParameters, ITypeID returnType, FunctionParameter[] parameters) {
 		this.typeParameters = genericParameters;
 		this.returnType = returnType;
 		this.parameters = parameters;
+		
+		for (int i = 0; i < parameters.length; i++)
+			parameters[i].index = i;
 	}
 	
 	public FunctionHeader instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {

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

@@ -17,6 +17,7 @@ import org.openzen.zenscript.codemodel.type.ITypeID;
  * @author Hoofdgebruiker
  */
 public class FunctionParameter {
+	public int index = -1;
 	public final ITypeID type;
 	public final String name;
 	public final Expression defaultValue;

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

@@ -8,6 +8,7 @@ package org.openzen.zenscript.codemodel;
 import java.util.ArrayList;
 import java.util.List;
 import org.openzen.zenscript.codemodel.definition.DefinitionVisitor;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
@@ -19,6 +20,7 @@ import org.openzen.zenscript.shared.Taggable;
  * @author Hoofdgebruiker
  */
 public abstract class HighLevelDefinition extends Taggable {
+	public final ZSPackage pkg;
 	public final String name;
 	public final int modifiers;
 	public final List<IDefinitionMember> members = new ArrayList<>();
@@ -27,7 +29,8 @@ public abstract class HighLevelDefinition extends Taggable {
 	public HighLevelDefinition outerDefinition;
 	public ITypeID superType;
 	
-	public HighLevelDefinition(String name, int modifiers, HighLevelDefinition outerDefinition) {
+	public HighLevelDefinition(ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		this.pkg = pkg;
 		this.name = name;
 		this.modifiers = modifiers;
 		this.outerDefinition = outerDefinition;

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

@@ -15,8 +15,8 @@ import org.openzen.zenscript.codemodel.type.ITypeID;
 public class AliasDefinition extends HighLevelDefinition {
 	public ITypeID type;
 	
-	public AliasDefinition(String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(name, modifiers, outerDefinition);
+	public AliasDefinition(ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(pkg, name, modifiers, outerDefinition);
 	}
 	
 	public void setType(ITypeID type) {

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

@@ -13,12 +13,12 @@ import org.openzen.zenscript.codemodel.type.ITypeID;
  * @author Hoofdgebruiker
  */
 public class ClassDefinition extends HighLevelDefinition {
-	public ClassDefinition(String name, int modifiers) {
-		this(name, modifiers, null);
+	public ClassDefinition(ZSPackage pkg, String name, int modifiers) {
+		this(pkg, name, modifiers, null);
 	}
 	
-	public ClassDefinition(String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(name, modifiers, outerDefinition);
+	public ClassDefinition(ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(pkg, name, modifiers, outerDefinition);
 	}
 	
 	public void setSuperclass(ITypeID superclass) {

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

@@ -12,8 +12,8 @@ import org.openzen.zenscript.codemodel.HighLevelDefinition;
  * @author Hoofdgebruiker
  */
 public class EnumDefinition extends HighLevelDefinition {
-	public EnumDefinition(String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(name, modifiers, outerDefinition);
+	public EnumDefinition(ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override

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

@@ -15,8 +15,8 @@ import org.openzen.zenscript.codemodel.type.ITypeID;
 public class ExpansionDefinition extends HighLevelDefinition {
 	public ITypeID target;
 	
-	public ExpansionDefinition(int modifiers, HighLevelDefinition outerDefinition) {
-		super(null, modifiers, outerDefinition);
+	public ExpansionDefinition(ZSPackage pkg, int modifiers, HighLevelDefinition outerDefinition) {
+		super(pkg, null, modifiers, outerDefinition);
 	}
 
 	@Override

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

@@ -18,8 +18,8 @@ public class FunctionDefinition extends HighLevelDefinition {
 	public FunctionHeader header;
 	public List<Statement> statements;
 	
-	public FunctionDefinition(String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(name, modifiers, outerDefinition);
+	public FunctionDefinition(ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(pkg, name, modifiers, outerDefinition);
 	}
 	
 	public void setHeader(FunctionHeader header) {

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

@@ -17,8 +17,8 @@ import org.openzen.zenscript.codemodel.type.ITypeID;
 public class InterfaceDefinition extends HighLevelDefinition {
 	private final List<ITypeID> baseInterfaces = new ArrayList<>();
 	
-	public InterfaceDefinition(String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(name, modifiers, outerDefinition);
+	public InterfaceDefinition(ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(pkg, name, modifiers, outerDefinition);
 	}
 	
 	public void addBaseInterface(ITypeID baseInterface) {

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

@@ -12,8 +12,8 @@ import org.openzen.zenscript.codemodel.HighLevelDefinition;
  * @author Hoofdgebruiker
  */
 public class StructDefinition extends HighLevelDefinition {
-	public StructDefinition(String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(name, modifiers, outerDefinition);
+	public StructDefinition(ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override

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

@@ -25,6 +25,12 @@ import org.openzen.zenscript.codemodel.scope.TypeScope;
  * @author Hoofdgebruiker
  */
 public class ZSPackage {
+	public final String fullName;
+	
+	public ZSPackage(String fullName) {
+		this.fullName = fullName;
+	}
+	
 	private final Map<String, ZSPackage> subPackages = new HashMap<>();
 	private final Map<String, HighLevelDefinition> types = new HashMap<>();
 	
@@ -42,6 +48,10 @@ public class ZSPackage {
 		return null;
 	}
 	
+	public boolean contains(String name) {
+		return types.containsKey(name) || subPackages.containsKey(name);
+	}
+	
 	public HighLevelDefinition getImport(List<String> name, int depth) {
 		if (depth >= name.size())
 			return null;
@@ -83,7 +93,7 @@ public class ZSPackage {
 		if (subPackages.containsKey(name))
 			return subPackages.get(name);
 		
-		ZSPackage result = new ZSPackage();
+		ZSPackage result = new ZSPackage(fullName.isEmpty() ? name : fullName + '.' + name);
 		subPackages.put(name, result);
 		return result;
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/ExpressionVisitor.java

@@ -116,10 +116,6 @@ public interface ExpressionVisitor<T> {
 	
 	public T visitStaticSetter(StaticSetterExpression expression);
 	
-	public T visitStringConcat(StringConcatExpression expression);
-	
-	public T visitSubstring(SubstringExpression expression);
-	
 	public T visitThis(ThisExpression expression);
 	
 	public T visitWrapOptional(WrapOptionalExpression expression);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/StringConcatExpression.java

@@ -1,31 +0,0 @@
-/*
- * 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.codemodel.expression;
-
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.shared.CodePosition;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class StringConcatExpression extends Expression {
-	// either of these must be a basic type
-	public final Expression left;
-	public final Expression right;
-	
-	public StringConcatExpression(CodePosition position, Expression left, Expression right) {
-		super(position, BasicTypeID.STRING);
-		
-		this.left = left;
-		this.right = right;
-	}
-
-	@Override
-	public <T> T accept(ExpressionVisitor<T> visitor) {
-		return visitor.visitStringConcat(this);
-	}
-}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/SubstringExpression.java

@@ -1,29 +0,0 @@
-/*
- * 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.codemodel.expression;
-
-import org.openzen.zenscript.shared.CodePosition;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class SubstringExpression extends Expression {
-	public final Expression value;
-	public final Expression range;
-	
-	public SubstringExpression(CodePosition position, Expression value, Expression range) {
-		super(position, value.type);
-		
-		this.value = value;
-		this.range = range;
-	}
-
-	@Override
-	public <T> T accept(ExpressionVisitor<T> visitor) {
-		return visitor.visitSubstring(this);
-	}
-}

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

@@ -1,91 +0,0 @@
-/*
- * 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.codemodel.member.builtin;
-
-import java.util.Map;
-import org.openzen.zenscript.codemodel.CompareType;
-import org.openzen.zenscript.codemodel.FunctionHeader;
-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.SubstringExpression;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.member.ICallableMember;
-import org.openzen.zenscript.codemodel.member.IDefinitionMember;
-import org.openzen.zenscript.codemodel.member.MemberVisitor;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
-import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-import org.openzen.zenscript.shared.CodePosition;
-import org.openzen.zenscript.shared.Taggable;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class SubstringMember extends Taggable implements ICallableMember {
-	private final FunctionHeader header;
-	
-	public SubstringMember(FunctionHeader header) {
-		this.header = header;
-	}
-
-	@Override
-	public boolean isStatic() {
-		return false;
-	}
-
-	@Override
-	public FunctionHeader getHeader() {
-		return header;
-	}
-
-	@Override
-	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments) {
-		return new SubstringExpression(position, target, arguments.arguments[0]);
-	}
-
-	@Override
-	public Expression callWithComparator(CodePosition position, CompareType operator, Expression target, FunctionHeader instancedHeader, CallArguments arguments) {
-		throw new UnsupportedOperationException("Not comparable");
-	}
-
-	@Override
-	public Expression callStatic(CodePosition position, FunctionHeader instancedHeader, CallArguments arguments) {
-		throw new UnsupportedOperationException("Not a static member");
-	}
-
-	@Override
-	public Expression callStaticWithComparator(CodePosition position, CompareType operator, FunctionHeader instancedHeader, CallArguments arguments) {
-		throw new UnsupportedOperationException("Not comparable");
-	}
-
-	@Override
-	public CodePosition getPosition() {
-		return CodePosition.BUILTIN;
-	}
-
-	@Override
-	public String describe() {
-		return "substring";
-	}
-
-	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addOperator(OperatorType.INDEXGET, this, priority);
-	}
-
-	@Override
-	public IDefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return this; // string member; no instancing
-	}
-
-	@Override
-	public <T> T accept(MemberVisitor<T> visitor) {
-		throw new UnsupportedOperationException("Not a compilable member");
-	}
-}

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

@@ -38,7 +38,6 @@ import org.openzen.zenscript.codemodel.member.builtin.ArrayIteratorValues;
 import org.openzen.zenscript.codemodel.member.builtin.ComparatorMember;
 import org.openzen.zenscript.codemodel.member.builtin.ConstantGetterMember;
 import org.openzen.zenscript.codemodel.member.builtin.RangeIterator;
-import org.openzen.zenscript.codemodel.member.builtin.SubstringMember;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
@@ -411,8 +410,8 @@ public class TypeMemberBuilder implements ITypeVisitor<Void> {
 
 		members.addGetter(new GetterMember(BUILTIN, 0, "length", INT), TypeMemberPriority.SPECIFIED);
 
-		FunctionHeader substringHeader = new FunctionHeader(STRING, new FunctionParameter(cache.getRegistry().getRange(INT, INT)));
-		members.addOperator(OperatorType.INDEXGET, new SubstringMember(substringHeader), TypeMemberPriority.SPECIFIED);
+		//FunctionHeader substringHeader = new FunctionHeader(STRING, new FunctionParameter(cache.getRegistry().getRange(INT, INT)));
+		//members.addOperator(OperatorType.INDEXGET, new SubstringMember(substringHeader), TypeMemberPriority.SPECIFIED);
 		
 		members.addConstructor(new ConstructorMember(BUILTIN, 0, new FunctionHeader(VOID, new FunctionParameter(cache.getRegistry().getArray(CHAR, 1), "characters"))), TypeMemberPriority.SPECIFIED);
 		

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

@@ -1,8 +1,6 @@
 package org.openzen.zenscript.javabytecode.compiler;
 
-import com.sun.javafx.image.IntPixelGetter;
 import org.objectweb.asm.Type;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.member.DefinitionMember;
 import org.openzen.zenscript.implementations.IntRange;
@@ -16,8 +14,7 @@ import org.openzen.zenscript.shared.CompileExceptionCode;
 import java.util.Map;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
-
-    private JavaWriter javaWriter;
+    private final JavaWriter javaWriter;
 
     public JavaExpressionVisitor(final JavaWriter javaWriter) {
         this.javaWriter = javaWriter;
@@ -379,16 +376,6 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
         return null;
     }
 
-    @Override
-    public Void visitStringConcat(StringConcatExpression expression) {
-        return null;
-    }
-
-    @Override
-    public Void visitSubstring(SubstringExpression expression) {
-        return null;
-    }
-
     @Override
     public Void visitThis(ThisExpression expression) {
         return null;

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

@@ -2,7 +2,6 @@ package org.openzen.zenscript.javabytecode.compiler;
 
 import org.objectweb.asm.Label;
 import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
-import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;

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

@@ -10,7 +10,6 @@ public class JavaStatementVisitor implements StatementVisitor<Void> {
     private final JavaExpressionVisitor expressionVisitor;
 
     public JavaStatementVisitor(final JavaWriter javaWriter) {
-
         this.javaWriter = javaWriter;
         this.expressionVisitor = new JavaExpressionVisitor(javaWriter);
     }

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

@@ -12,7 +12,7 @@ import static org.objectweb.asm.Opcodes.*;
 
 public class JavaWriter {
     final LocalVariablesSorter visitor;
-    private boolean debug = true;
+    private boolean debug = false;
     private int labelIndex = 1;
     private Map<Label, String> labelNames = new HashMap<>();
 

Parser/src/main/java/org/openzen/zenscript/parser/ParsedDefinition.java

@@ -6,6 +6,7 @@
 package org.openzen.zenscript.parser;
 
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.lexer.ZSTokenStream;
 import static org.openzen.zenscript.lexer.ZSTokenType.K_ALIAS;
@@ -29,21 +30,21 @@ import org.openzen.zenscript.parser.definitions.ParsedStruct;
  * @author Hoofdgebruiker
  */
 public abstract class ParsedDefinition {
-	public static ParsedDefinition parse(CodePosition position, int modifiers, ZSTokenStream tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedDefinition parse(ZSPackage pkg, CodePosition position, int modifiers, ZSTokenStream tokens, HighLevelDefinition outerDefinition) {
 		if (tokens.optional(K_CLASS) != null) {
-			return ParsedClass.parseClass(position, modifiers, tokens, outerDefinition);
+			return ParsedClass.parseClass(pkg, position, modifiers, tokens, outerDefinition);
 		} else if (tokens.optional(K_INTERFACE) != null) {
-			return ParsedInterface.parseInterface(position, modifiers, tokens, outerDefinition);
+			return ParsedInterface.parseInterface(pkg, position, modifiers, tokens, outerDefinition);
 		} else if (tokens.optional(K_ENUM) != null) {
-			return ParsedEnum.parseEnum(position, modifiers, tokens, outerDefinition);
+			return ParsedEnum.parseEnum(pkg, position, modifiers, tokens, outerDefinition);
 		} else if (tokens.optional(K_STRUCT) != null) {
-			return ParsedStruct.parse(position, modifiers, tokens, outerDefinition);
+			return ParsedStruct.parse(pkg, position, modifiers, tokens, outerDefinition);
 		} else if (tokens.optional(K_ALIAS) != null) {
-			return ParsedAlias.parseAlias(position, modifiers, tokens, outerDefinition);
+			return ParsedAlias.parseAlias(pkg, position, modifiers, tokens, outerDefinition);
 		} else if (tokens.optional(K_FUNCTION) != null) {
-			return ParsedFunction.parseFunction(position, modifiers, tokens, outerDefinition);
+			return ParsedFunction.parseFunction(pkg, position, modifiers, tokens, outerDefinition);
 		} else if (tokens.optional(K_EXPAND) != null) {
-			return ParsedExpansion.parseExpansion(position, modifiers, tokens, outerDefinition);
+			return ParsedExpansion.parseExpansion(pkg, position, modifiers, tokens, outerDefinition);
 		} else {
 			//tokens.required(EOF, "An import, class, interface, enum, struct, function or alias expected.");
 			return null;

Parser/src/main/java/org/openzen/zenscript/parser/ParsedFile.java

@@ -39,22 +39,22 @@ import org.openzen.zenscript.shared.SourceFile;
  * @author Hoofdgebruiker
  */
 public class ParsedFile {
-	public static ParsedFile parse(File file) throws IOException {
+	public static ParsedFile parse(ZSPackage pkg, File file) throws IOException {
 		String filename = file.toString();
 		try (FileReader reader = new FileReader(file)) {
-			return parse(filename, reader);
+			return parse(pkg, filename, reader);
 		}
 	}
 	
-	public static ParsedFile parse(String filename, String content) {
+	public static ParsedFile parse(ZSPackage pkg, String filename, String content) {
 		try (StringReader reader = new StringReader(content)) {
-			return parse(filename, reader);
+			return parse(pkg, filename, reader);
 		} catch (IOException ex) {
 			throw new AssertionError(); // supposed to never happen in a StringReader
 		}
 	}
 	
-	public static ParsedFile parse(String filename, Reader reader) throws IOException {
+	public static ParsedFile parse(ZSPackage pkg, String filename, Reader reader) throws IOException {
 		ParsedFile result = new ParsedFile(filename);
 		
 		ZSTokenStream tokens = new ZSTokenStream(filename, reader);
@@ -87,7 +87,7 @@ public class ParsedFile {
 			} else if (tokens.optional(EOF) != null) {
 				break;
 			} else {
-				ParsedDefinition definition = ParsedDefinition.parse(position, modifiers, tokens, null);
+				ParsedDefinition definition = ParsedDefinition.parse(pkg, position, modifiers, tokens, null);
 				if (definition == null) {
 					result.statements.add(ParsedStatement.parse(tokens));
 				} else {

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

@@ -8,6 +8,7 @@ package org.openzen.zenscript.parser.definitions;
 import java.util.List;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.lexer.ZSTokenStream;
 import org.openzen.zenscript.lexer.ZSTokenType;
@@ -22,11 +23,11 @@ import org.openzen.zenscript.shared.CodePosition;
  * @author Hoofdgebruiker
  */
 public class ParsedAlias extends ParsedDefinition {
-	public static ParsedAlias parseAlias(CodePosition position, int modifiers, ZSTokenStream tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedAlias parseAlias(ZSPackage pkg, CodePosition position, int modifiers, ZSTokenStream tokens, HighLevelDefinition outerDefinition) {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		List<ParsedGenericParameter> parameters = ParsedGenericParameter.parseAll(tokens);
 		IParsedType type = IParsedType.parse(tokens);
-		return new ParsedAlias(position, modifiers, name, parameters, type, outerDefinition);
+		return new ParsedAlias(pkg, position, modifiers, name, parameters, type, outerDefinition);
 	}
 	
 	private final String name;
@@ -35,14 +36,14 @@ public class ParsedAlias extends ParsedDefinition {
 	
 	private final AliasDefinition compiled;
 	
-	public ParsedAlias(CodePosition position, int modifiers, String name, List<ParsedGenericParameter> parameters, IParsedType type, HighLevelDefinition outerDefinition) {
+	public ParsedAlias(ZSPackage pkg, CodePosition position, int modifiers, String name, List<ParsedGenericParameter> parameters, IParsedType type, HighLevelDefinition outerDefinition) {
 		super(position, modifiers);
 		
 		this.name = name;
 		this.parameters = parameters;
 		this.type = type;
 		
-		compiled = new AliasDefinition(name, modifiers, outerDefinition);
+		compiled = new AliasDefinition(pkg, name, modifiers, outerDefinition);
 	}
 	
 	@Override

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

@@ -8,6 +8,7 @@ package org.openzen.zenscript.parser.definitions;
 import java.util.List;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.lexer.ZSTokenStream;
 import org.openzen.zenscript.lexer.ZSTokenType;
@@ -22,7 +23,7 @@ import org.openzen.zenscript.shared.CodePosition;
  * @author Stan Hebben
  */
 public class ParsedClass extends BaseParsedDefinition {
-	public static ParsedClass parseClass(CodePosition position, int modifiers, ZSTokenStream tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedClass parseClass(ZSPackage pkg, CodePosition position, int modifiers, ZSTokenStream tokens, HighLevelDefinition outerDefinition) {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		List<ParsedGenericParameter> genericParameters = ParsedGenericParameter.parseAll(tokens);
 		
@@ -33,7 +34,7 @@ public class ParsedClass extends BaseParsedDefinition {
 		
 		tokens.required(ZSTokenType.T_AOPEN, "{ expected");
 		
-		ParsedClass result = new ParsedClass(position, modifiers, name, genericParameters, superclass, outerDefinition);
+		ParsedClass result = new ParsedClass(pkg, position, modifiers, name, genericParameters, superclass, outerDefinition);
 		while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
 			result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled));
 		}
@@ -45,13 +46,13 @@ public class ParsedClass extends BaseParsedDefinition {
 	
 	private final ClassDefinition compiled;
 	
-	public ParsedClass(CodePosition position, int modifiers, String name, List<ParsedGenericParameter> genericParameters, IParsedType superclass, HighLevelDefinition outerDefinition) {
+	public ParsedClass(ZSPackage pkg, CodePosition position, int modifiers, String name, List<ParsedGenericParameter> genericParameters, IParsedType superclass, HighLevelDefinition outerDefinition) {
 		super(position, modifiers);
 		
 		this.genericParameters = genericParameters;
 		this.superclass = superclass;
 		
-		compiled = new ClassDefinition(name, modifiers, outerDefinition);
+		compiled = new ClassDefinition(pkg, name, modifiers, outerDefinition);
 		for (ParsedGenericParameter parameter : genericParameters)
 			compiled.addGenericParameter(parameter.compiled);
 	}

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

@@ -9,6 +9,7 @@ import java.util.ArrayList;
 import java.util.List;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenStream;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
@@ -19,7 +20,7 @@ import org.openzen.zenscript.shared.CodePosition;
  * @author Hoofdgebruiker
  */
 public class ParsedEnum extends BaseParsedDefinition {
-	public static ParsedEnum parseEnum(CodePosition position, int modifiers, ZSTokenStream tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedEnum parseEnum(ZSPackage pkg, CodePosition position, int modifiers, ZSTokenStream tokens, HighLevelDefinition outerDefinition) {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		tokens.required(ZSTokenType.T_AOPEN, "{ expected");
 		
@@ -30,7 +31,7 @@ public class ParsedEnum extends BaseParsedDefinition {
 				break;
 		}
 		
-		ParsedEnum result = new ParsedEnum(position, modifiers, name, enumValues, outerDefinition);
+		ParsedEnum result = new ParsedEnum(pkg, position, modifiers, name, enumValues, outerDefinition);
 		if (tokens.optional(ZSTokenType.T_SEMICOLON) != null) {
 			while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
 				result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled));
@@ -45,12 +46,12 @@ public class ParsedEnum extends BaseParsedDefinition {
 	
 	private final EnumDefinition compiled;
 	
-	public ParsedEnum(CodePosition position, int modifiers, String name, List<ParsedEnumConstant> enumValues, HighLevelDefinition outerDefinition) {
+	public ParsedEnum(ZSPackage pkg, CodePosition position, int modifiers, String name, List<ParsedEnumConstant> enumValues, HighLevelDefinition outerDefinition) {
 		super(position, modifiers);
 		
 		this.enumValues = enumValues;
 		
-		compiled = new EnumDefinition(name, modifiers, outerDefinition);
+		compiled = new EnumDefinition(pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override

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

@@ -8,6 +8,7 @@ package org.openzen.zenscript.parser.definitions;
 import java.util.List;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.lexer.ZSTokenStream;
 import org.openzen.zenscript.lexer.ZSTokenType;
@@ -22,12 +23,12 @@ import org.openzen.zenscript.shared.CodePosition;
  * @author Hoofdgebruiker
  */
 public class ParsedExpansion extends BaseParsedDefinition {
-	public static ParsedExpansion parseExpansion(CodePosition position, int modifiers, ZSTokenStream tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedExpansion parseExpansion(ZSPackage pkg, CodePosition position, int modifiers, ZSTokenStream tokens, HighLevelDefinition outerDefinition) {
 		List<ParsedGenericParameter> parameters = ParsedGenericParameter.parseAll(tokens);
 		IParsedType target = IParsedType.parse(tokens);
 		tokens.required(ZSTokenType.T_AOPEN, "{ expected");
 		
-		ParsedExpansion result = new ParsedExpansion(position, modifiers, parameters, target, outerDefinition);
+		ParsedExpansion result = new ParsedExpansion(pkg, position, modifiers, parameters, target, outerDefinition);
 		while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
 			result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled));
 		}
@@ -38,13 +39,13 @@ public class ParsedExpansion extends BaseParsedDefinition {
 	private final IParsedType target;
 	private final ExpansionDefinition compiled;
 	
-	public ParsedExpansion(CodePosition position, int modifiers, List<ParsedGenericParameter> parameters, IParsedType target, HighLevelDefinition outerDefinition) {
+	public ParsedExpansion(ZSPackage pkg, CodePosition position, int modifiers, List<ParsedGenericParameter> parameters, IParsedType target, HighLevelDefinition outerDefinition) {
 		super(position, modifiers);
 		
 		this.parameters = parameters;
 		this.target = target;
 		
-		this.compiled = new ExpansionDefinition(modifiers, outerDefinition);
+		this.compiled = new ExpansionDefinition(pkg, modifiers, outerDefinition);
 		for (ParsedGenericParameter parameter : parameters)
 			compiled.addGenericParameter(parameter.compiled);
 	}

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

@@ -9,6 +9,7 @@ package org.openzen.zenscript.parser.definitions;
 import static org.openzen.zenscript.lexer.ZSTokenType.*;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenStream;
 import org.openzen.zenscript.linker.BaseScope;
 import org.openzen.zenscript.linker.FunctionScope;
@@ -22,27 +23,25 @@ import org.openzen.zenscript.shared.CodePosition;
  * @author Stanneke
  */
 public class ParsedFunction extends ParsedDefinition {
-	public static ParsedFunction parseFunction(CodePosition position, int modifiers, ZSTokenStream parser, HighLevelDefinition outerDefinition) {
+	public static ParsedFunction parseFunction(ZSPackage pkg, CodePosition position, int modifiers, ZSTokenStream parser, HighLevelDefinition outerDefinition) {
 		String name = parser.required(T_IDENTIFIER, "identifier expected").content;
 		ParsedFunctionHeader header = ParsedFunctionHeader.parse(parser);
 		ParsedFunctionBody body = ParsedStatement.parseFunctionBody(parser);
-		return new ParsedFunction(position, modifiers, name, header, body, outerDefinition);
+		return new ParsedFunction(pkg, position, modifiers, name, header, body, outerDefinition);
 	}
 	
-	private final String name;
 	private final ParsedFunctionHeader header;
 	private final ParsedFunctionBody body;
 
 	private final FunctionDefinition compiled;
 	
-	private ParsedFunction(CodePosition position, int modifiers, String name, ParsedFunctionHeader header, ParsedFunctionBody body, HighLevelDefinition outerDefinition) {
+	private ParsedFunction(ZSPackage pkg, CodePosition position, int modifiers, String name, ParsedFunctionHeader header, ParsedFunctionBody body, HighLevelDefinition outerDefinition) {
 		super(position, modifiers);
 		
-		this.name = name;
 		this.header = header;
 		this.body = body;
 		
-		compiled = new FunctionDefinition(name, modifiers, outerDefinition);
+		compiled = new FunctionDefinition(pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override

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

@@ -10,6 +10,7 @@ import java.util.Collections;
 import java.util.List;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenStream;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.linker.BaseScope;
@@ -22,7 +23,7 @@ import org.openzen.zenscript.shared.CodePosition;
  * @author Hoofdgebruiker
  */
 public class ParsedInterface extends BaseParsedDefinition {
-	public static ParsedInterface parseInterface(CodePosition position, int modifiers, ZSTokenStream tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedInterface parseInterface(ZSPackage pkg, CodePosition position, int modifiers, ZSTokenStream tokens, HighLevelDefinition outerDefinition) {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		List<ParsedGenericParameter> genericParameters = ParsedGenericParameter.parseAll(tokens);
 		List<IParsedType> superInterfaces = Collections.emptyList();
@@ -35,27 +36,25 @@ public class ParsedInterface extends BaseParsedDefinition {
 		
 		tokens.required(ZSTokenType.T_AOPEN, "{ expected");
 		
-		ParsedInterface result = new ParsedInterface(position, modifiers, name, genericParameters, superInterfaces, outerDefinition);
+		ParsedInterface result = new ParsedInterface(pkg, position, modifiers, name, genericParameters, superInterfaces, outerDefinition);
 		while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
 			result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled));
 		}
 		return result;
 	}
 	
-	private final String name;
 	private final List<ParsedGenericParameter> genericParameters;
 	private final List<IParsedType> superInterfaces;
 	
 	private final InterfaceDefinition compiled;
 	
-	public ParsedInterface(CodePosition position, int modifiers, String name, List<ParsedGenericParameter> genericParameters, List<IParsedType> superInterfaces, HighLevelDefinition outerDefinition) {
+	public ParsedInterface(ZSPackage pkg, CodePosition position, int modifiers, String name, List<ParsedGenericParameter> genericParameters, List<IParsedType> superInterfaces, HighLevelDefinition outerDefinition) {
 		super(position, modifiers);
 		
-		this.name = name;
 		this.genericParameters = genericParameters;
 		this.superInterfaces = superInterfaces;
 		
-		compiled = new InterfaceDefinition(name, modifiers, outerDefinition);
+		compiled = new InterfaceDefinition(pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override

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

@@ -8,6 +8,7 @@ package org.openzen.zenscript.parser.definitions;
 import java.util.List;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.StructDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenStream;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.linker.BaseScope;
@@ -19,31 +20,29 @@ import org.openzen.zenscript.shared.CodePosition;
  * @author Hoofdgebruiker
  */
 public class ParsedStruct extends BaseParsedDefinition {
-	public static ParsedStruct parseStruct(CodePosition position, int modifiers, ZSTokenStream tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedStruct parseStruct(ZSPackage pkg, CodePosition position, int modifiers, ZSTokenStream tokens, HighLevelDefinition outerDefinition) {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		List<ParsedGenericParameter> parameters = ParsedGenericParameter.parseAll(tokens);
 		
 		tokens.required(ZSTokenType.T_AOPEN, "{");
 		
-		ParsedStruct result = new ParsedStruct(position, modifiers, name, parameters, outerDefinition);
+		ParsedStruct result = new ParsedStruct(pkg, position, modifiers, name, parameters, outerDefinition);
 		while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
 			result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled));
 		}
 		return result;
 	}
 	
-	private final String name;
 	private final List<ParsedGenericParameter> parameters;
 	
 	private final StructDefinition compiled;
 	
-	public ParsedStruct(CodePosition position, int modifiers, String name, List<ParsedGenericParameter> parameters, HighLevelDefinition outerDefinition) {
+	public ParsedStruct(ZSPackage pkg, CodePosition position, int modifiers, String name, List<ParsedGenericParameter> parameters, HighLevelDefinition outerDefinition) {
 		super(position, modifiers);
 		
-		this.name = name;
 		this.parameters = parameters;
 		
-		compiled = new StructDefinition(name, modifiers, outerDefinition);
+		compiled = new StructDefinition(pkg, name, modifiers, outerDefinition);
 		for (ParsedGenericParameter parameter : parameters)
 			compiled.addGenericParameter(parameter.compiled);
 	}

Parser/src/main/java/org/openzen/zenscript/parser/member/ParsedDefinitionMember.java

@@ -15,6 +15,7 @@ import org.openzen.zenscript.parser.statements.ParsedFunctionBody;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.lexer.ZSToken;
 import org.openzen.zenscript.lexer.ZSTokenStream;
@@ -189,7 +190,7 @@ public abstract class ParsedDefinitionMember {
 			case K_ALIAS:
 			case K_STRUCT:
 			case K_ENUM:
-				return new ParsedInnerDefinition(ParsedDefinition.parse(start, modifiers, tokens, forDefinition));
+				return new ParsedInnerDefinition(ParsedDefinition.parse(forDefinition.pkg, start, modifiers, tokens, forDefinition));
 			case K_FOR: {
 				tokens.next();
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);

ScriptingExample/build.gradle

@@ -16,4 +16,5 @@ if (!hasProperty('mainClass')) {
 dependencies {
 	compile project(':Parser')
 	compile project(':JavaBytecodeCompiler')
+	compile project(':CodeFormatter')
 }

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

@@ -36,24 +36,32 @@ import org.openzen.zenscript.shared.CodePosition;
  * @author Hoofdgebruiker
  */
 public class GlobalRegistry {
+	private final ZSPackage rootPackage = new ZSPackage("");
+	private final ZSPackage javaIo = rootPackage.getOrCreatePackage("java").getOrCreatePackage("io");
+	private final ZSPackage javaLang = rootPackage.getOrCreatePackage("java").getOrCreatePackage("lang");
 	
+	public GlobalRegistry() {
+		JavaClassInfo jPrintStream = new JavaClassInfo("java/io/PrintStream");
+		PRINTSTREAM_PRINTLN.setTag(JavaMethodInfo.class, new JavaMethodInfo(jPrintStream, "println", "(Ljava/lang/String;)V"));
+		
+		JavaClassInfo jSystem = new JavaClassInfo("java/lang/System");
+		SYSTEM_OUT.setTag(JavaFieldInfo.class, new JavaFieldInfo(jSystem, "out", "Ljava/io/PrintStream;"));
+	}
 	
 	public ZSPackage collectPackages() {
-		ZSPackage rootPackage = new ZSPackage();
-		
 		// register packages here
 		
 		{
 			// eg. package my.package with a class MyClass with a single native method test() returning a string
 			// the visitors can then during compilation check if a method is an instance of NativeMethodMember and treat it accordingly
-			ClassDefinition myClassDefinition = new ClassDefinition("MyClass", Modifiers.MODIFIER_PUBLIC, null);
+			ZSPackage packageMyPackage = rootPackage.getOrCreatePackage("my").getOrCreatePackage("package");
+			ClassDefinition myClassDefinition = new ClassDefinition(packageMyPackage, "MyClass", Modifiers.MODIFIER_PUBLIC, null);
 			JavaClassInfo myClassInfo = new JavaClassInfo("my/test/MyClass");
 			
 			MethodMember member = new MethodMember(CodePosition.NATIVE, Modifiers.MODIFIER_PUBLIC, "test", new FunctionHeader(BasicTypeID.STRING));
 			member.setTag(JavaMethodInfo.class, new JavaMethodInfo(myClassInfo, "test", "()Ljava/lang/String;"));
 			myClassDefinition.addMember(member);
 			
-			ZSPackage packageMyPackage = rootPackage.getOrCreatePackage("my").getOrCreatePackage("package");
 			packageMyPackage.register(myClassDefinition);
 		}
 		
@@ -75,28 +83,21 @@ public class GlobalRegistry {
 		return globals;
 	}
 	
-	private static final ClassDefinition PRINTSTREAM = new ClassDefinition("PrintStream", Modifiers.MODIFIER_EXPORT);
-	private static final MethodMember PRINTSTREAM_PRINTLN = new MethodMember(
+	private final ClassDefinition PRINTSTREAM = new ClassDefinition(javaIo, "PrintStream", Modifiers.MODIFIER_EXPORT);
+	private final ClassDefinition SYSTEM = new ClassDefinition(javaLang, "System", Modifiers.MODIFIER_EXPORT);
+	private final MethodMember PRINTSTREAM_PRINTLN = new MethodMember(
 			CodePosition.NATIVE,
 			Modifiers.MODIFIER_EXPORT,
 			"println",
 			new FunctionHeader(BasicTypeID.VOID, new FunctionParameter(BasicTypeID.STRING)));
 	
-	private static final FieldMember SYSTEM_OUT = new FieldMember(
+	private final FieldMember SYSTEM_OUT = new FieldMember(
 			CodePosition.NATIVE,
 			Modifiers.MODIFIER_EXPORT,
 			"out",
-			DefinitionTypeID.forType(PRINTSTREAM),
+			DefinitionTypeID.forType(SYSTEM),
 			true);
 	
-	static {
-		JavaClassInfo jPrintStream = new JavaClassInfo("java/io/PrintStream");
-		PRINTSTREAM_PRINTLN.setTag(JavaMethodInfo.class, new JavaMethodInfo(jPrintStream, "println", "(Ljava/lang/String;)V"));
-		
-		JavaClassInfo jSystem = new JavaClassInfo("java/lang/System");
-		SYSTEM_OUT.setTag(JavaFieldInfo.class, new JavaFieldInfo(jSystem, "out", "Ljava/io/PrintStream;"));
-	}
-	
 	private class PrintlnSymbol implements ISymbol {
 
 		@Override

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

@@ -3,6 +3,7 @@ package org.openzen.zenscript.scriptingexample;
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -13,10 +14,13 @@ import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.formatter.FileFormatter;
+import org.openzen.zenscript.formatter.FormattingSettings;
 import org.openzen.zenscript.javabytecode.JavaCompiler;
 import org.openzen.zenscript.javabytecode.JavaModule;
 import org.openzen.zenscript.linker.symbol.ISymbol;
 import org.openzen.zenscript.parser.ParsedFile;
+import org.openzen.zenscript.shared.SourceFile;
 
 public class Main {
     /**
@@ -27,19 +31,27 @@ public class Main {
 		File inputDirectory = new File("scripts");
 		File[] inputFiles = Optional.ofNullable(inputDirectory.listFiles((dir, name) -> name.endsWith(".zs"))).orElseGet(() -> new File[0]);
 		
-		ParsedFile[] parsedFiles = parse(inputFiles);
+		ZSPackage pkg = new ZSPackage("");
+		ParsedFile[] parsedFiles = parse(pkg, inputFiles);
 		
 		GlobalRegistry registry = new GlobalRegistry();
 		SemanticModule module = compileSyntaxToSemantic(parsedFiles, registry);
 		
+		FormattingSettings settings = new FormattingSettings.Builder().build();
+		for (ScriptBlock block : module.scripts) {
+			FileFormatter formatter = new FileFormatter(settings);
+			System.out.println("== " + block.getTag(SourceFile.class).filename + " ==");
+			System.out.println(formatter.format(pkg, block, Collections.emptyList()));
+		}
+		
 		JavaModule javaModule = compileSemanticToJava(module);
 		javaModule.execute();
     }
 	
-	private static ParsedFile[] parse(File[] files) throws IOException {
+	private static ParsedFile[] parse(ZSPackage pkg, File[] files) throws IOException {
 		ParsedFile[] parsedFiles = new ParsedFile[files.length];
 		for (int i = 0; i < files.length; i++) {
-			parsedFiles[i] = ParsedFile.parse(files[i]);
+			parsedFiles[i] = ParsedFile.parse(pkg, files[i]);
 		}
 		return parsedFiles;
 	}
@@ -81,7 +93,7 @@ public class Main {
 	}
 	
 	private static JavaModule compileSemanticToJava(SemanticModule module) {
-		JavaCompiler compiler = new JavaCompiler(true);
+		JavaCompiler compiler = new JavaCompiler(false);
 		for (HighLevelDefinition definition : module.definitions.getAll()) {
 			compiler.addDefinition(definition);
 		}