- Refactored some formatting things to be reusable for source code translation targets

- Removed generic compare
- Rewrote the way builtins are handled and implemented nearly all operations for all supported basic / builtin types
- Added java source code compilation
- Added throw expression, allowing a throw to be formulated as expression (handy inside matches)

CodeFormatter/build.gradle

 
 dependencies {
 	compile project(':CodeModel')
+	compile project(':CodeFormatterShared')
 }

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

 public class CommentFormatter {
 	private CommentFormatter() {}
 	
-	public static String[] format(String[] comments) {
-		if (comments.length == 0)
-			return comments;
+	public static String[] format(String[] commentLines) {
+		if (commentLines.length == 0)
+			return commentLines;
 		
 		boolean isInMultilineComment = false;
-		String[] result = new String[comments.length];
-		for (int i = 0; i < comments.length; i++) {
-			String comment = comments[i];
+		String[] result = new String[commentLines.length];
+		for (int i = 0; i < commentLines.length; i++) {
+			String comment = commentLines[i];
 			if (isInMultilineComment) {
 				if (!comment.startsWith("*"))
 					comment = "* " + comment;

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

  * @author Hoofdgebruiker
  */
 public class DefinitionFormatter implements DefinitionVisitor<Void> {
-	private final FormattingSettings settings;
+	private final ScriptFormattingSettings settings;
 	private final TypeFormatter typeFormatter;
 	private final StringBuilder output = new StringBuilder();
 	private final String indent;
 	
-	public DefinitionFormatter(FormattingSettings settings, TypeFormatter typeFormatter, String indent) {
+	public DefinitionFormatter(ScriptFormattingSettings settings, TypeFormatter typeFormatter, String indent) {
 		this.settings = settings;
 		this.typeFormatter = typeFormatter;
 		this.indent = indent;

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

  */
 package org.openzen.zenscript.formatter;
 
+import org.openzen.zenscript.formattershared.ExpressionString;
 import org.openzen.zenscript.codemodel.OperatorType;
 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.CompareExpression;
 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.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.StaticSetterExpression;
 import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
+import org.openzen.zenscript.codemodel.expression.ThrowExpression;
 import org.openzen.zenscript.codemodel.expression.TryConvertExpression;
 import org.openzen.zenscript.codemodel.expression.TryRethrowAsExceptionExpression;
 import org.openzen.zenscript.codemodel.expression.TryRethrowAsResultExpression;
  * @author Hoofdgebruiker
  */
 public class ExpressionFormatter implements ExpressionVisitor<ExpressionString> {
-	private final FormattingSettings settings;
+	private final ScriptFormattingSettings settings;
 	public final TypeFormatter typeFormatter;
 	
-	public ExpressionFormatter(FormattingSettings settings, TypeFormatter typeFormatter) {
+	public ExpressionFormatter(ScriptFormattingSettings settings, TypeFormatter typeFormatter) {
 		this.settings = settings;
 		this.typeFormatter = typeFormatter;
 	}
 
 	@Override
 	public ExpressionString visitAndAnd(AndAndExpression expression) {
-		return binary(expression.left, expression.right, OperatorPriority.ANDAND, " && ");
+		return binary(expression.left, expression.right, ZenScriptOperator.ANDAND);
 	}
 
 	@Override
 			index++;
 		}
 		result.append("]");
-		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+		return new ExpressionString(result.toString(), ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
-	public ExpressionString visitCompare(BasicCompareExpression expression) {
+	public ExpressionString visitCompare(CompareExpression expression) {
 		return binary(
 				expression.left,
 				expression.right,
-				OperatorPriority.COMPARE,
-				" " + expression.operator.str + " ");
+				ZenScriptOperator.getComparison(expression.comparison));
 	}
 
 	@Override
 			OperatorMember operator = (OperatorMember) expression.member;
 			switch (operator.operator) {
 				case NOT:
-					return unaryPrefix(expression.target, OperatorPriority.NOT, "!");
+					return unaryPrefix(expression.target, ZenScriptOperator.NOT, "!");
 				case NEG:
-					return unaryPrefix(expression.target, OperatorPriority.NEG, "-");
+					return unaryPrefix(expression.target, ZenScriptOperator.NEG, "-");
 				case CAT:
 					if (expression.arguments.arguments.length == 0) {
-						return unaryPrefix(expression.target, OperatorPriority.INVERT, "~");
+						return unaryPrefix(expression.target, ZenScriptOperator.INVERT, "~");
 					} else {
-						return binary(expression.target, expression.getFirstArgument(), OperatorPriority.CAT, " ~ ");
+						return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.CAT);
 					}
 				case ADD:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.ADD, " + ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.ADD);
 				case SUB:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.SUB, " - ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.SUB);
 				case MUL:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.MUL, " * ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.MUL);
 				case DIV:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.DIV, " / ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.DIV);
 				case MOD:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.MOD, " % ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.MOD);
 				case AND:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.AND, " & ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.AND);
 				case OR:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.OR, " | ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.OR);
 				case XOR:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XOR, " ^ ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.XOR);
 				case CONTAINS:
-					return binary(expression.getFirstArgument(), expression.target, OperatorPriority.CONTAINS, " in ");
+					return binary(expression.getFirstArgument(), expression.target, ZenScriptOperator.CONTAINS);
 				case EQUALS:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.COMPARE, " == ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.EQUALS);
+				case NOTEQUALS:
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.NOTEQUALS);
 				case INDEXSET: {
 					StringBuilder result = new StringBuilder();
 					result.append(expression.target);
 					}
 					result.append("] = ");
 					result.append(expression.arguments.arguments[expression.arguments.arguments.length - 1].accept(this).value);
-					return new ExpressionString(result.toString(), OperatorPriority.ASSIGN);
+					return new ExpressionString(result.toString(), ZenScriptOperator.ASSIGN);
 				}
 				case INDEXGET: {
 					StringBuilder result = new StringBuilder();
 						result.append(expression.arguments.arguments[i].accept(this));
 					}
 					result.append("]");
-					return new ExpressionString(result.toString(), OperatorPriority.INDEX);
+					return new ExpressionString(result.toString(), ZenScriptOperator.INDEX);
 				}
 				case MEMBERGETTER: {
 					StringBuilder result = new StringBuilder();
 					result.append(".get(");
 					result.append(expression.getFirstArgument().accept(this));
 					result.append(")");
-					return new ExpressionString(result.toString(), OperatorPriority.MEMBER);
+					return new ExpressionString(result.toString(), ZenScriptOperator.MEMBER);
 				}
 				case MEMBERSETTER: {
 					StringBuilder result = new StringBuilder();
 					result.append(", ");
 					result.append(expression.arguments.arguments[1].accept(this));
 					result.append(")");
-					return new ExpressionString(result.toString(), OperatorPriority.MEMBER);
+					return new ExpressionString(result.toString(), ZenScriptOperator.MEMBER);
 				}
 				case ADDASSIGN:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " += ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.ADDASSIGN);
 				case SUBASSIGN:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " -= ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.SUBASSIGN);
 				case MULASSIGN:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " *= ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.MULASSIGN);
 				case DIVASSIGN:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " /= ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.DIVASSIGN);
 				case MODASSIGN:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " %= ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.MODASSIGN);
 				case CATASSIGN:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " ~= ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.CATASSIGN);
 				case ORASSIGN:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " |= ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.ORASSIGN);
 				case ANDASSIGN:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " &= ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.ANDASSIGN);
 				case XORASSIGN:
-					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " ^= ");
+					return binary(expression.target, expression.getFirstArgument(), ZenScriptOperator.XORASSIGN);
 				case INCREMENT:
-					return unaryPrefix(expression.target, OperatorPriority.DECREMENT, "++");
+					return unaryPrefix(expression.target, ZenScriptOperator.DECREMENT, "++");
 				case DECREMENT:
-					return unaryPrefix(expression.target, OperatorPriority.DECREMENT, "--");
+					return unaryPrefix(expression.target, ZenScriptOperator.DECREMENT, "--");
 				case CALL: {
 					StringBuilder result = new StringBuilder();
 					result.append(".");
 					FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
-					return new ExpressionString(result.toString(), OperatorPriority.CALL);
+					return new ExpressionString(result.toString(), ZenScriptOperator.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);
+					return new ExpressionString(result.toString(), ZenScriptOperator.CAST);
 				}
 				default:
 					throw new UnsupportedOperationException("Unknown operator: " + operator.operator);
 			result.append(".");
 			result.append(expression.member.name);
 			FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
-			return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+			return new ExpressionString(result.toString(), ZenScriptOperator.PRIMARY);
 		}
 	}
 
 			result.append(expression.member.name);
 		}
 		FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
-		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+		return new ExpressionString(result.toString(), ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 
 	@Override
 	public ExpressionString visitCapturedLocalVariable(CapturedLocalVariableExpression expression) {
-		return new ExpressionString(expression.variable.name, OperatorPriority.PRIMARY);
+		return new ExpressionString(expression.variable.name, ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 	public ExpressionString visitCapturedParameter(CapturedParameterExpression expression) {
-		return new ExpressionString(expression.parameter.name, OperatorPriority.PRIMARY);
+		return new ExpressionString(expression.parameter.name, ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 	public ExpressionString visitCapturedThis(CapturedThisExpression expression) {
-		return new ExpressionString("this", OperatorPriority.PRIMARY);
+		return new ExpressionString("this", ZenScriptOperator.PRIMARY);
 	}
 	
 	@Override
 			result.append(" as ");
 			result.append(expression.member.toType.accept(typeFormatter));
 		}
-		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+		return new ExpressionString(result.toString(), ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 
 	@Override
 	public ExpressionString visitCoalesce(CoalesceExpression expression) {
-		return binary(expression.left, expression.right, OperatorPriority.COALESCE, " ?? ");
+		return binary(expression.left, expression.right, ZenScriptOperator.COALESCE);
 	}
 
 	@Override
 		result.append(expression.ifThen.accept(this));
 		result.append(" : ");
 		result.append(expression.ifElse.accept(this));
-		return new ExpressionString(result.toString(), OperatorPriority.TERNARY);
+		return new ExpressionString(result.toString(), ZenScriptOperator.TERNARY);
 	}
 
 	@Override
 	public ExpressionString visitConstantBool(ConstantBoolExpression expression) {
-		return new ExpressionString(expression.value ? "true" : "false", OperatorPriority.PRIMARY);
+		return new ExpressionString(expression.value ? "true" : "false", ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 	public ExpressionString visitConstantByte(ConstantByteExpression expression) {
-		return new ExpressionString(Byte.toString(expression.value) + " as byte", OperatorPriority.CAST);
+		return new ExpressionString(Byte.toString(expression.value) + " as byte", ZenScriptOperator.CAST);
 	}
 
 	@Override
 	public ExpressionString visitConstantChar(ConstantCharExpression expression) {
 		return new ExpressionString(
 				StringUtils.escape(Character.toString(expression.value), '\'', true),
-				OperatorPriority.PRIMARY);
+				ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 
 	@Override
 	public ExpressionString visitConstantInt(ConstantIntExpression expression) {
-		return new ExpressionString(Integer.toString(expression.value), OperatorPriority.PRIMARY);
+		return new ExpressionString(Integer.toString(expression.value), ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 	public ExpressionString visitConstantLong(ConstantLongExpression expression) {
-		return new ExpressionString(Long.toString(expression.value), OperatorPriority.PRIMARY);
+		return new ExpressionString(Long.toString(expression.value), ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 	public ExpressionString visitConstantSByte(ConstantSByteExpression expression) {
-		return new ExpressionString(Byte.toString(expression.value) + " as sbyte", OperatorPriority.CAST);
+		return new ExpressionString(Byte.toString(expression.value) + " as sbyte", ZenScriptOperator.CAST);
 	}
 
 	@Override
 	public ExpressionString visitConstantShort(ConstantShortExpression expression) {
-		return new ExpressionString(Integer.toString(expression.value) + " as short", OperatorPriority.CAST);
+		return new ExpressionString(Integer.toString(expression.value) + " as short", ZenScriptOperator.CAST);
 	}
 
 	@Override
 		return new ExpressionString(StringUtils.escape(
 				expression.value,
 				settings.useSingleQuotesForStrings ? '\'' : '"',
-				true), OperatorPriority.CAST);
+				true), ZenScriptOperator.CAST);
 	}
 
 	@Override
 	public ExpressionString visitConstantUInt(ConstantUIntExpression expression) {
-		return new ExpressionString(Integer.toString(expression.value) + " as uint", OperatorPriority.CAST);
+		return new ExpressionString(Integer.toString(expression.value) + " as uint", ZenScriptOperator.CAST);
 	}
 
 	@Override
 	public ExpressionString visitConstantULong(ConstantULongExpression expression) {
-		return new ExpressionString(Long.toString(expression.value) + " as ulong", OperatorPriority.CAST);
+		return new ExpressionString(Long.toString(expression.value) + " as ulong", ZenScriptOperator.CAST);
 	}
 
 	@Override
 	public ExpressionString visitConstantUShort(ConstantUShortExpression expression) {
-		return new ExpressionString(Integer.toString(expression.value) + " as ushort", OperatorPriority.CAST);
+		return new ExpressionString(Integer.toString(expression.value) + " as ushort", ZenScriptOperator.CAST);
 	}
 
 	@Override
 		StringBuilder result = new StringBuilder();
 		result.append("this");
 		FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
-		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+		return new ExpressionString(result.toString(), ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 		StringBuilder result = new StringBuilder();
 		result.append("super");
 		FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
-		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+		return new ExpressionString(result.toString(), ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 	public ExpressionString visitEnumConstant(EnumConstantExpression expression) {
-		return new ExpressionString(expression.type.accept(typeFormatter) + "." + expression.value.name, OperatorPriority.MEMBER);
+		return new ExpressionString(expression.type.accept(typeFormatter) + "." + expression.value.name, ZenScriptOperator.MEMBER);
 	}
 
 	@Override
 		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);
+		return new ExpressionString(result.toString(), ZenScriptOperator.MEMBER);
 	}
 
 	@Override
 	public ExpressionString visitGetFunctionParameter(GetFunctionParameterExpression expression) {
-		return new ExpressionString(expression.parameter.name, OperatorPriority.PRIMARY);
+		return new ExpressionString(expression.parameter.name, ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 	public ExpressionString visitGetLocalVariable(GetLocalVariableExpression expression) {
-		return new ExpressionString(expression.variable.name, OperatorPriority.PRIMARY);
+		return new ExpressionString(expression.variable.name, ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 		result.append(expression.type.accept(typeFormatter));
 		result.append('.');
 		result.append(expression.field.name);
-		return new ExpressionString(result.toString(), OperatorPriority.MEMBER);
+		return new ExpressionString(result.toString(), ZenScriptOperator.MEMBER);
 	}
 
 	@Override
 		result.append(expression.target.accept(this));
 		result.append('.');
 		result.append(expression.getter.name);
-		return new ExpressionString(result.toString(), OperatorPriority.MEMBER);
+		return new ExpressionString(result.toString(), ZenScriptOperator.MEMBER);
 	}
 	
 	@Override
 	public ExpressionString visitGlobal(GlobalExpression expression) {
-		return new ExpressionString(expression.name, OperatorPriority.PRIMARY);
+		return new ExpressionString(expression.name, ZenScriptOperator.PRIMARY);
 	}
 	
 	@Override
 		StringBuilder result = new StringBuilder();
 		result.append(expression.name);
 		FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
-		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+		return new ExpressionString(result.toString(), ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 		result.append(expression.value.accept(this).value);
 		result.append(" as ");
 		result.append(expression.type.accept(typeFormatter));
-		return new ExpressionString(result.toString(), OperatorPriority.CAST);
+		return new ExpressionString(result.toString(), ZenScriptOperator.CAST);
 	}
 
 	@Override
 		result.append(expression.value.accept(this).value);
 		result.append(" is ");
 		result.append(expression.type.accept(typeFormatter));
-		return new ExpressionString(result.toString(), OperatorPriority.COMPARE);
+		return new ExpressionString(result.toString(), ZenScriptOperator.IS);
 	}
 
 	@Override
 			result.append(expression.values[i].accept(this));
 		}
 		result.append("}");
-		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+		return new ExpressionString(result.toString(), ZenScriptOperator.PRIMARY);
 	}
 	
 	@Override
 		result.append("new ");
 		result.append(expression.type.accept(typeFormatter));
 		FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
-		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+		return new ExpressionString(result.toString(), ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 	public ExpressionString visitNull(NullExpression expression) {
-		return new ExpressionString("null", OperatorPriority.PRIMARY);
+		return new ExpressionString("null", ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 	public ExpressionString visitOrOr(OrOrExpression expression) {
-		return binary(expression.left, expression.right, OperatorPriority.OROR, " || ");
+		return binary(expression.left, expression.right, ZenScriptOperator.OROR);
 	}
 	
 	@Override
 	public ExpressionString visitPostCall(PostCallExpression expression) {
-		return unaryPostfix(expression.target, OperatorPriority.INCREMENT, expression.member.operator == OperatorType.INCREMENT ? "++" : "--");
+		return unaryPostfix(expression.target, ZenScriptOperator.INCREMENT, expression.member.operator == OperatorType.INCREMENT ? "++" : "--");
 	}
 
 	@Override
 	public ExpressionString visitRange(RangeExpression expression) {
-		return binary(expression.from, expression.to, OperatorPriority.RANGE, " .. ");
+		return binary(expression.from, expression.to, ZenScriptOperator.RANGE);
 	}
 	
 	@Override
 	public ExpressionString visitSameObject(SameObjectExpression expression) {
-		return binary(expression.left, expression.right, OperatorPriority.COMPARE, expression.inverted ? " !== " : " === ");
+		return binary(expression.left, expression.right, expression.inverted ? ZenScriptOperator.NOTSAME : ZenScriptOperator.SAME);
 	}
 
 	@Override
 	public ExpressionString visitSetField(SetFieldExpression expression) {
 		return new ExpressionString(
 				expression.target.accept(this) + "." + expression.field.name + " = " + expression.value.accept(this).value, 
-				OperatorPriority.ASSIGN);
+				ZenScriptOperator.ASSIGN);
 	}
 
 	@Override
 	public ExpressionString visitSetFunctionParameter(SetFunctionParameterExpression expression) {
 		return new ExpressionString(
 				expression.parameter.name + " = " + expression.value.accept(this).value,
-				OperatorPriority.ASSIGN);
+				ZenScriptOperator.ASSIGN);
 	}
 
 	@Override
 	public ExpressionString visitSetLocalVariable(SetLocalVariableExpression expression) {
 		return new ExpressionString(
 				expression.variable.name + " = " + expression.value.accept(this).value,
-				OperatorPriority.ASSIGN);
+				ZenScriptOperator.ASSIGN);
 	}
 
 	@Override
 	public ExpressionString visitSetStaticField(SetStaticFieldExpression expression) {
 		return new ExpressionString(
 				expression.type.accept(typeFormatter) + "." + expression.field.name + " = " + expression.value.accept(this).value,
-				OperatorPriority.ASSIGN);
+				ZenScriptOperator.ASSIGN);
 	}
 
 	@Override
 	public ExpressionString visitSetter(SetterExpression expression) {
 		return new ExpressionString(
 				expression.target.accept(this) + "." + expression.setter.name + " = " + expression.value.accept(this),
-				OperatorPriority.ASSIGN);
+				ZenScriptOperator.ASSIGN);
 	}
 
 	@Override
 	public ExpressionString visitStaticGetter(StaticGetterExpression expression) {
 		return new ExpressionString(
 				expression.type.accept(typeFormatter) + "." + expression.getter.name, 
-				OperatorPriority.MEMBER);
+				ZenScriptOperator.MEMBER);
 	}
 
 	@Override
 	public ExpressionString visitStaticSetter(StaticSetterExpression expression) {
 		return new ExpressionString(
 				expression.type.accept(typeFormatter) + "." + expression.setter.name + " = " + expression.setter.name,
-				OperatorPriority.ASSIGN);
+				ZenScriptOperator.ASSIGN);
 	}
 	
 	@Override
 
 	@Override
 	public ExpressionString visitThis(ThisExpression expression) {
-		return new ExpressionString("this", OperatorPriority.PRIMARY);
+		return new ExpressionString("this", ZenScriptOperator.PRIMARY);
+	}
+
+	@Override
+	public ExpressionString visitThrow(ThrowExpression expression) {
+		return new ExpressionString("throw " + expression.value.accept(this), ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 		StringBuilder result = new StringBuilder();
 		result.append("new ");
 		// TODO: finish this
-		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+		return new ExpressionString(result.toString(), ZenScriptOperator.PRIMARY);
 	}
 
 	@Override
 		return expression.value.accept(this);
 	}
 	
-	private ExpressionString unaryPrefix(Expression value, OperatorPriority operator, String operatorString) {
+	private ExpressionString unaryPrefix(Expression value, ZenScriptOperator operator, String operatorString) {
 		return new ExpressionString(operatorString + value.accept(this).value, operator);
 	}
 	
-	private ExpressionString unaryPostfix(Expression value, OperatorPriority operator, String operatorString) {
+	private ExpressionString unaryPostfix(Expression value, ZenScriptOperator 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);
+	private ExpressionString binary(Expression left, Expression right, ZenScriptOperator operator) {
+		return ExpressionString.binary(left.accept(this), right.accept(this), operator);
 	}
 }

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

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.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

  */
 package org.openzen.zenscript.formatter;
 
+import org.openzen.zenscript.formattershared.Importer;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
  * @author Hoofdgebruiker
  */
 public class FileFormatter {
-	private final FormattingSettings settings;
+	private final ScriptFormattingSettings settings;
 	
-	public FileFormatter(FormattingSettings settings) {
+	public FileFormatter(ScriptFormattingSettings settings) {
 		this.settings = settings;
 	}
 	

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

 			output.append("const? ");
 	}
 	
-	public static void formatHeader(StringBuilder result, FormattingSettings settings, FunctionHeader header, TypeFormatter typeFormatter) {
+	public static void formatHeader(StringBuilder result, ScriptFormattingSettings settings, FunctionHeader header, TypeFormatter typeFormatter) {
 		FormattingUtils.formatTypeParameters(result, header.typeParameters, typeFormatter);
 		result.append("(");
 		int parameterIndex = 0;
 		}
 	}
 	
-	public static void formatBody(StringBuilder output, FormattingSettings settings, String indent, TypeFormatter typeFormatter, Statement body) {
+	public static void formatBody(StringBuilder output, ScriptFormattingSettings settings, String indent, TypeFormatter typeFormatter, Statement body) {
 		body.accept(new BodyFormatter(output, settings, indent, typeFormatter));
 		output.append("\n");
 	}
 	
 	private static class BodyFormatter implements StatementVisitor<Void> {
 		private final StringBuilder output;
-		private final FormattingSettings settings;
+		private final ScriptFormattingSettings settings;
 		private final StatementFormatter statementFormatter;
 		private final String indent;
 		private final TypeFormatter typeFormatter;
 		
-		public BodyFormatter(StringBuilder output, FormattingSettings settings, String indent, TypeFormatter typeFormatter) {
+		public BodyFormatter(StringBuilder output, ScriptFormattingSettings settings, String indent, TypeFormatter typeFormatter) {
 			this.output = output;
 			this.settings = settings;
 			this.indent = indent;

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

  * @author Hoofdgebruiker
  */
 public class MemberFormatter implements MemberVisitor<Void> {
-	private final FormattingSettings settings;
+	private final ScriptFormattingSettings settings;
 	private final StringBuilder output;
 	private final String indent;
 	private final TypeFormatter typeFormatter;
 	private boolean isFirst = true;
 	private boolean wasField = false;
 	
-	public MemberFormatter(FormattingSettings settings, StringBuilder output, String indent, TypeFormatter typeFormatter) {
+	public MemberFormatter(ScriptFormattingSettings settings, StringBuilder output, String indent, TypeFormatter typeFormatter) {
 		this.settings = settings;
 		this.output = output;
 		this.indent = indent;

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

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.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/FormattingSettings.java → CodeFormatter/src/main/java/org/openzen/zenscript/formatter/ScriptFormattingSettings.java

  */
 package org.openzen.zenscript.formatter;
 
-import org.openzen.zenscript.shared.StringUtils;
+import org.openzen.zenscript.formattershared.FormattingSettings;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class FormattingSettings {
+public class ScriptFormattingSettings extends 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 functionBracketOnSameLine;
 	public final boolean lambdaMethodOnSameLine;
 	
-	public final String indent;
-	
-	private FormattingSettings(Builder builder) {
+	private ScriptFormattingSettings(Builder builder) {
+		super(builder);
+		
 		showAnyInFunctionHeaders = builder.showAnyInFunctionHeaders;
 		useSingleQuotesForStrings = builder.useSingleQuotesForStrings;
-		useTabs = builder.useTabs;
-		spacesPerTab = builder.spacesPerTab;
 		spaceBeforeLabelColon = builder.spaceBeforeLabelColon;
 		spaceAfterLabelColon = builder.spaceAfterLabelColon;
 		bracketsAroundConditions = builder.bracketsAroundConditions;
 		classBracketOnSameLine = builder.classBracketOnSameLine;
 		functionBracketOnSameLine = builder.functionBracketOnSameLine;
 		lambdaMethodOnSameLine = builder.lambdaMethodOnSameLine;
-		
-		if (useTabs) {
-			indent = "\t";
-		} else {
-			indent = StringUtils.times(' ', spacesPerTab);
-		}
 	}
 	
 	public String getSingleLineSeparator(String indent, ParentStatementType position) {
 		}
 	}
 	
-	public static class Builder {
+	public static class Builder extends FormattingSettings.Builder<Builder> {
 		private boolean showAnyInFunctionHeaders = false;
 		private boolean useSingleQuotesForStrings = true;
 		private boolean useTabs = false;
 		private boolean functionBracketOnSameLine = false;
 		private boolean lambdaMethodOnSameLine = false;
 		
+		public Builder() {
+			super(CommentFormatter::format);
+			
+			instance = this;
+		}
+		
 		public Builder showAnyInFunctionHeaders(boolean show) {
 			showAnyInFunctionHeaders = show;
 			return this;
 			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;
 			return this;
 		}
 		
-		public FormattingSettings build() {
-			return new FormattingSettings(this);
+		@Override
+		public ScriptFormattingSettings build() {
+			return new ScriptFormattingSettings(this);
 		}
 	}
 }

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

  * @author Hoofdgebruiker
  */
 public class StatementFormatter implements StatementVisitor<Void> {
-	private final FormattingSettings settings;
+	private final ScriptFormattingSettings settings;
 	private final StringBuilder output;
 	private final ExpressionFormatter expressionFormatter;
 	
 	private String indent;
 	private ParentStatementType position = ParentStatementType.NONE;
 	
-	public StatementFormatter(StringBuilder output, String indent, FormattingSettings settings, ExpressionFormatter expressionFormatter) {
+	public StatementFormatter(StringBuilder output, String indent, ScriptFormattingSettings settings, ExpressionFormatter expressionFormatter) {
 		this.output = output;
 		this.indent = indent;
 		this.settings = settings;

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

  * @author Hoofdgebruiker
  */
 public class SwitchValueFormatter implements SwitchValueVisitor<String> {
-	private final FormattingSettings settings;
+	private final ScriptFormattingSettings settings;
 	
-	public SwitchValueFormatter(FormattingSettings settings) {
+	public SwitchValueFormatter(ScriptFormattingSettings settings) {
 		this.settings = settings;
 	}
 

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

  */
 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.formattershared.Importer;
 import org.openzen.zenscript.codemodel.generic.GenericParameterBoundVisitor;
 import org.openzen.zenscript.codemodel.generic.ParameterSuperBound;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
  * @author Hoofdgebruiker
  */
 public class TypeFormatter implements ITypeVisitor<String>, GenericParameterBoundVisitor<String> {
-	private final FormattingSettings settings;
+	private final ScriptFormattingSettings settings;
 	private final Importer importer;
 	
-	public TypeFormatter(FormattingSettings settings, Importer importer) {
+	public TypeFormatter(ScriptFormattingSettings settings, Importer importer) {
 		this.settings = settings;
 		this.importer = importer;
 	}
 	public String visitGenericMap(GenericMapTypeID map) {
 		StringBuilder result = new StringBuilder();
 		result.append(map.value.accept(this));
-		result.append("[");
-		FormattingUtils.formatTypeParameters(result, map.keys, this);
-		result.append("]");
+		result.append("[<");
+		FormattingUtils.formatTypeParameters(result, new TypeParameter[] { map.key }, this);
+		result.append("]>");
 		return result.toString();
 	}
 }

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.formatter;
+
+import org.openzen.zenscript.codemodel.CompareType;
+import org.openzen.zenscript.formattershared.FormattableOperator;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public enum ZenScriptOperator implements FormattableOperator {
+	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, " in "),
+	EQUALS(6, " == "),
+	NOTEQUALS(6, " != "),
+	GREATER(6, " > "),
+	LESS(6, " < "),
+	GREATER_EQUALS(6, " >= "),
+	LESS_EQUALS(6, " <= "),
+	IS(6, " is "),
+	SAME(6, " === "),
+	NOTSAME(6, " !== "),
+	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, null),
+	COALESCE(2, " ?? "),
+	
+	INCREMENT(8, "++"),
+	DECREMENT(8, "--"),
+	MEMBER(9, null),
+	RANGE(9, " .. "),
+	INDEX(9, null),
+	CALL(9, null),
+	CAST(9, null),
+	
+	PRIMARY(10, null);
+	
+	private final int priority;
+	private final boolean isCommutative;
+	private final String operatorString;
+	
+	private ZenScriptOperator(int priority, String operatorString) {
+		this(priority, false, operatorString);
+	}
+	
+	private ZenScriptOperator(int priority, boolean isCommutative, String operatorString) {
+		this.priority = priority;
+		this.isCommutative = isCommutative;
+		this.operatorString = operatorString;
+	}
+
+	@Override
+	public int getPriority() {
+		return priority;
+	}
+
+	@Override
+	public boolean isCommutative() {
+		return isCommutative;
+	}
+	
+	@Override
+	public String getOperatorString() {
+		return operatorString;
+	}
+	
+	public static ZenScriptOperator getComparison(CompareType compare) {
+		switch (compare) {
+			case EQ: return EQUALS;
+			case NE: return NOTEQUALS;
+			case LT: return LESS;
+			case GT: return GREATER;
+			case LE: return LESS_EQUALS;
+			case GE: return GREATER_EQUALS;
+			default:
+				return null;
+		}
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.formattershared;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface CommentFormatter {
+	String[] format(String[] lines);
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.formattershared;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ExpressionString {
+	public final String value;
+	public final FormattableOperator priority;
+	
+	public ExpressionString(String value, FormattableOperator priority) {
+		this.value = value;
+		this.priority = priority;
+	}
+	
+	public String wrapLeft(FormattableOperator outer) {
+		return FormattableOperator.shouldWrapLeft(priority, outer) ? "(" + value + ")" : value;
+	}
+	
+	public String wrapRight(FormattableOperator outer) {
+		return FormattableOperator.shouldWrapRight(priority, outer) ? "(" + value + ")" : value;
+	}
+	
+	@Override
+	public String toString() {
+		return value;
+	}
+	
+	public static ExpressionString binary(ExpressionString left, ExpressionString right, FormattableOperator operator) {
+		String value = left.wrapLeft(operator)
+				+ operator.getOperatorString() + right.wrapRight(operator);
+		return new ExpressionString(value, operator);
+	}
+	
+	public ExpressionString unaryPrefix(FormattableOperator operator) {
+		return new ExpressionString(operator.getOperatorString() + value, operator);
+	}
+	
+	public ExpressionString unaryPostfix(FormattableOperator operator) {
+		return new ExpressionString(value + operator.getOperatorString(), operator);
+	}
+	
+	public ExpressionString unaryPrefix(FormattableOperator operator, String operatorString) {
+		return new ExpressionString(operatorString + value, operator);
+	}
+	
+	public ExpressionString unaryPostfix(FormattableOperator operator, String operatorString) {
+		return new ExpressionString(value + operatorString, operator);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.formattershared;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface FormattableOperator {
+	int getPriority();
+	
+	boolean isCommutative();
+	
+	String getOperatorString();
+	
+	public static boolean shouldWrapLeft(FormattableOperator inner, FormattableOperator outer) {
+		return inner != outer && inner.getPriority() <= outer.getPriority();
+	}
+	
+	public static boolean shouldWrapRight(FormattableOperator inner, FormattableOperator outer) {
+		return (inner == outer && inner.isCommutative()) || (inner.getPriority() <= outer.getPriority());
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.formattershared;
+
+import org.openzen.zenscript.shared.StringUtils;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class FormattingSettings {
+	public final boolean useTabs; // use tabs instead of spaces
+	public final int spacesPerTab; // number of spaces per tab
+	public final String indent;
+	public final CommentFormatter commentFormatter;
+	
+	protected FormattingSettings(Builder builder) {
+		useTabs = builder.useTabs;
+		spacesPerTab = builder.spacesPerTab;
+		commentFormatter = builder.commentFormatter;
+		
+		if (useTabs) {
+			indent = "\t";
+		} else {
+			indent = StringUtils.times(' ', spacesPerTab);
+		}
+	}
+	
+	public static class Builder<T extends Builder<T>> {
+		private final CommentFormatter commentFormatter;
+		private boolean useTabs = false;
+		private int spacesPerTab = 4;
+		protected T instance;
+		
+		public Builder(CommentFormatter commentFormatter) {
+			this.commentFormatter = commentFormatter;
+		}
+		
+		public T useTabs(boolean tabs) {
+			useTabs = tabs;
+			return instance;
+		}
+		
+		public T spacesPerTabs(int spaces) {
+			spacesPerTab = spaces;
+			return instance;
+		}
+		
+		public FormattingSettings build() {
+			return new FormattingSettings(this);
+		}
+	}
+}

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/Importer.java → CodeFormatterShared/src/main/java/org/openzen/zenscript/formattershared/Importer.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.formatter;
+package org.openzen.zenscript.formattershared;
 
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.formattershared;
+
+import java.util.List;
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
+import org.openzen.zenscript.codemodel.statement.BlockStatement;
+import org.openzen.zenscript.codemodel.statement.BreakStatement;
+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.LoopStatement;
+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.SwitchStatement;
+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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class StatementFormatter implements StatementVisitor<Void>, StatementFormattingTarget {
+	private final StringBuilder output;
+	private final Formatter formatter;
+	private final String indent;
+	private final FormattingSettings settings;
+	private final LoopStatement innerLoop;
+	
+	public StatementFormatter(StringBuilder output, FormattingSettings settings, Formatter formatter, String indent, LoopStatement innerLoop) {
+		this.output = output;
+		this.formatter = formatter;
+		this.indent = indent;
+		this.settings = settings;
+		this.innerLoop = innerLoop;
+	}
+
+	@Override
+	public Void visitBlock(BlockStatement statement) {
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginBlock(whitespace);
+		formatter.formatBlock(this, statement);
+		endBlock(whitespace);
+		return null;
+	}
+
+	@Override
+	public Void visitBreak(BreakStatement statement) {
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
+		formatter.formatBreak(this, statement);
+		endSingleLine(whitespace);
+		return null;
+	}
+
+	@Override
+	public Void visitContinue(ContinueStatement statement) {
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
+		formatter.formatContinue(this, statement);
+		endSingleLine(whitespace);
+		return null;
+	}
+
+	@Override
+	public Void visitDoWhile(DoWhileStatement statement) {
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
+		formatter.formatDoWhile(this, statement);
+		endSingleLine(whitespace);
+		return null;
+	}
+
+	@Override
+	public Void visitEmpty(EmptyStatement statement) {
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
+		formatter.formatEmpty(this, statement);
+		endSingleLine(whitespace);
+		return null;
+	}
+
+	@Override
+	public Void visitExpression(ExpressionStatement statement) {
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
+		formatter.formatExpression(this, statement);
+		endSingleLine(whitespace);
+		return null;
+	}
+
+	@Override
+	public Void visitForeach(ForeachStatement statement) {
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
+		formatter.formatForeach(this, statement);
+		endSingleLine(whitespace);
+		return null;
+	}
+
+	@Override
+	public Void visitIf(IfStatement statement) {
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
+		formatter.formatIf(this, statement);
+		endSingleLine(whitespace);
+		return null;
+	}
+
+	@Override
+	public Void visitLock(LockStatement statement) {
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
+		formatter.formatLock(this, statement);
+		endSingleLine(whitespace);
+		return null;
+	}
+
+	@Override
+	public Void visitReturn(ReturnStatement statement) {
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
+		formatter.formatReturn(this, statement);
+		endSingleLine(whitespace);
+		return null;
+	}
+
+	@Override
+	public Void visitSwitch(SwitchStatement statement) {
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
+		formatter.formatSwitch(this, statement);
+		endSingleLine(whitespace);
+		return null;
+	}
+
+	@Override
+	public Void visitThrow(ThrowStatement statement) {
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
+		formatter.formatThrow(this, statement);
+		endSingleLine(whitespace);
+		return null;
+	}
+
+	@Override
+	public Void visitTryCatch(TryCatchStatement statement) {
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
+		formatter.formatTryCatch(this, statement);
+		endSingleLine(whitespace);
+		return null;
+	}
+
+	@Override
+	public Void visitVar(VarStatement statement) {
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
+		formatter.formatVar(this, statement);
+		endSingleLine(whitespace);
+		return null;
+	}
+
+	@Override
+	public Void visitWhile(WhileStatement statement) {
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
+		formatter.formatWhile(this, statement);
+		endSingleLine(whitespace);
+		return null;
+	}
+	
+	// == StatementFormattingTarget implementation ==
+	
+	@Override
+	public LoopStatement getInnerLoop() {
+		return innerLoop;
+	}
+
+	@Override
+	public String getIndent() {
+		return indent;
+	}
+	
+	@Override
+	public void writeLine(String line) {
+		output.append('\n').append(indent).append(line);
+	}
+
+	@Override
+	public void writeInner(String lineBefore, Statement contents, LoopStatement loop, String lineAfter) {
+		output.append('\n').append(indent).append(lineBefore);
+		contents.accept(new StatementFormatter(output, settings, formatter, indent + settings.indent, loop == null ? innerLoop : loop));
+		
+		if (!lineAfter.isEmpty())
+			output.append('\n').append(indent).append(lineAfter);
+	}
+
+	@Override
+	public void writeInnerMulti(String lineBefore, List<StatementFormattingSubBlock> contents, LoopStatement loop, String lineAfter) {
+		output.append('\n').append(indent).append(lineBefore);
+		
+		String newIndent = indent + settings.indent + settings.indent;
+		StatementFormatter inner = new StatementFormatter(output, settings, formatter, newIndent, innerLoop);
+		
+		for (StatementFormattingSubBlock subBlock : contents) {
+			output.append('\n').append(indent).append(settings.indent).append(subBlock.header);
+			for (String literal : subBlock.literalStatements)
+				output.append('\n').append(newIndent).append(literal);
+			for (Statement statement : subBlock.statements)
+				statement.accept(inner);
+		}
+		
+		if (!lineAfter.isEmpty())
+			output.append('\n').append(indent).append(lineAfter);
+	}
+
+	@Override
+	public void writeBlock(String lineBefore, BlockStatement contents, String lineAfter) {
+		output.append(' ').append(lineBefore);
+		
+		StatementFormatter inner = new StatementFormatter(output, settings, formatter, indent, innerLoop);
+		for (Statement statement : contents.statements)
+			statement.accept(inner);
+		
+		if (!lineAfter.isEmpty())
+			output.append('\n').append(indent.substring(0, indent.length() - settings.indent.length())).append(lineAfter);
+	}
+	
+	private void beginBlock(WhitespaceInfo whitespace) {
+		if (whitespace != null && whitespace.emptyLine) {
+			output.append("\n").append(indent);
+		}
+		
+		if (whitespace != null)
+			writeComments(whitespace.commentsBefore);
+	}
+	
+	private void endBlock(WhitespaceInfo whitespace) {
+		if (whitespace != null && !whitespace.commentsAfter.isEmpty())
+			output.append(' ').append(whitespace.commentsAfter);
+	}
+	
+	private void beginSingleLine(WhitespaceInfo whitespace) {
+		if (whitespace != null) {
+			if (whitespace.emptyLine) {
+				output.append("\n").append(indent);
+			}
+			writeComments(whitespace.commentsBefore);
+		}
+	}
+	
+	private void endSingleLine(WhitespaceInfo whitespace) {
+		if (whitespace != null && !whitespace.commentsAfter.isEmpty())
+			output.append(' ').append(whitespace.commentsAfter);
+	}
+	
+	private void writeComments(String[] comments) {
+		for (String comment : settings.commentFormatter.format(comments)) {
+			output.append(comment).append("\n").append(indent);
+		}
+	}
+	
+	private void writePostComments(String[] comments) {
+		for (String comment : settings.commentFormatter.format(comments)) {
+			output.append("\n").append(indent).append(comment);
+		}
+	}
+	
+	public interface Formatter {
+		public void formatBlock(StatementFormattingTarget target, BlockStatement statement);
+	
+		public void formatBreak(StatementFormattingTarget target, BreakStatement statement);
+
+		public void formatContinue(StatementFormattingTarget target, ContinueStatement statement);
+
+		public void formatDoWhile(StatementFormattingTarget target, DoWhileStatement statement);
+
+		public void formatEmpty(StatementFormattingTarget target, EmptyStatement statement);
+
+		public void formatExpression(StatementFormattingTarget target, ExpressionStatement statement);
+
+		public void formatForeach(StatementFormattingTarget target, ForeachStatement statement);
+
+		public void formatIf(StatementFormattingTarget target, IfStatement statement);
+
+		public void formatLock(StatementFormattingTarget target, LockStatement statement);
+
+		public void formatReturn(StatementFormattingTarget target, ReturnStatement statement);
+
+		public void formatSwitch(StatementFormattingTarget target, SwitchStatement statement);
+
+		public void formatThrow(StatementFormattingTarget target, ThrowStatement statement);
+
+		public void formatTryCatch(StatementFormattingTarget target, TryCatchStatement statement);
+
+		public void formatVar(StatementFormattingTarget target, VarStatement statement);
+
+		public void formatWhile(StatementFormattingTarget target, WhileStatement statement);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.formattershared;
+
+import java.util.List;
+import org.openzen.zenscript.codemodel.statement.Statement;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class StatementFormattingSubBlock {
+	public final String header;
+	public final List<String> literalStatements;
+	public final List<Statement> statements;
+	
+	public StatementFormattingSubBlock(String header, List<String> literalStatements, List<Statement> statements) {
+		this.header = header;
+		this.literalStatements = literalStatements;
+		this.statements = statements;
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.formattershared;
+
+import java.util.List;
+import org.openzen.zenscript.codemodel.statement.BlockStatement;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
+import org.openzen.zenscript.codemodel.statement.Statement;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface StatementFormattingTarget {
+	LoopStatement getInnerLoop();
+	
+	String getIndent();
+	
+	void writeLine(String line);
+	
+	void writeInner(String lineBefore, Statement contents, LoopStatement loop, String lineAfter);
+	
+	void writeInnerMulti(String lineBefore, List<StatementFormattingSubBlock> contents, LoopStatement loop, String lineAfter);
+	
+	void writeBlock(String lineBefore, BlockStatement contents, String lineAfter);
+}

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

 	EQ("=="),
 	NE("!="),
 	LE("<="),
-	GE(">="),
-	SAME("==="),
-	NOTSAME("!==");
+	GE(">=");
 	
 	public final String str;
 	

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

 	public final String name;
 	public final int modifiers;
 	public final List<IDefinitionMember> members = new ArrayList<>();
+	public final AccessScope access = new AccessScope();
 	public TypeParameter[] genericParameters = null;
 	
 	public HighLevelDefinition outerDefinition;

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

 	AND("&", "and"),
 	XOR("^", "xor"),
 	NEG("-", "negate"),
+	INVERT("~", "invert"),
 	NOT("!", "not"),
 	INDEXSET("[]=", "setElement"),
 	INDEXGET("[]", "getElement"),
 	MEMBERGETTER(".", "getMember"),
 	MEMBERSETTER(".=", "setMember"),
 	EQUALS("==", "equals"),
+	NOTEQUALS("!=", "notEquals"),
+	SAME("===", "same"),
+	NOTSAME("!==", "notSame"),
 	SHL("<<", "shl"),
 	SHR(">>", "shr"),
 	USHR(">>>", "ushr"),

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

 	
 	public void setHeader(FunctionHeader header) {
 		this.header = header;
-		addMember(caller = new CallerMember(position, this, modifiers | Modifiers.STATIC, header));
+		addMember(caller = new CallerMember(position, this, modifiers | Modifiers.STATIC, header, null));
 		callerGroup.addMethod(caller, TypeMemberPriority.SPECIFIED);
 	}
 	

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitAndAnd(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tLeft = left.transform(transformer);
+		Expression tRight = right.transform(transformer);
+		return tLeft == left && tRight == right
+				? this
+				: new AndAndExpression(position, tLeft, tRight);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitArray(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression[] tExpressions = Expression.transform(expressions, transformer);
+		return tExpressions == expressions ? this : new ArrayExpression(position, tExpressions, (ArrayTypeID)type);
+	}
 }

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

 		return typeArguments.length;
 	}
 	
+	public CallArguments transform(ExpressionTransformer transformer) {
+		Expression[] tArguments = Expression.transform(arguments, transformer);
+		return tArguments == arguments ? this : new CallArguments(typeArguments, tArguments);
+	}
+	
 	public CallArguments normalize(CodePosition position, TypeScope scope, FunctionHeader header) {
 		CallArguments result = this;
 		

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

 		
 		this.target = target;
 		this.member = member;
-		this.arguments = arguments.normalize(position, scope, instancedHeader);
+		this.arguments = scope == null ? arguments : arguments.normalize(position, scope, instancedHeader);
 		this.instancedHeader = instancedHeader;
 	}
 	
 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitCall(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tTarget = target.transform(transformer);
+		CallArguments tArguments = arguments.transform(transformer);
+		return tTarget == target && tArguments == arguments
+				? this
+				: new CallExpression(position, tTarget, member, instancedHeader, tArguments, null);
+	}
 }

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

 		
 		this.member = member;
 		this.target = target;
-		this.arguments = arguments.normalize(position, scope, instancedHeader);
+		this.arguments = scope == null ? arguments : arguments.normalize(position, scope, instancedHeader);
 		this.instancedHeader = instancedHeader;
 	}
 
 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitCallStatic(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		CallArguments tArguments = arguments.transform(transformer);
+		return arguments == tArguments ? this : new CallStaticExpression(position, target, member, tArguments, instancedHeader, null);
+	}
 }

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

 	public <T> T accept(CapturedExpressionVisitor<T> visitor) {
 		return visitor.visitRecaptured(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tValue = transformer.transform(value);
+		if (!(tValue instanceof CapturedExpression)) {
+			throw new IllegalStateException("Transformed CapturedExpression must also be a CapturedExpression!");
+		} else {
+			return tValue == value ? this : new CapturedClosureExpression(position, (CapturedExpression)tValue, closure);
+		}
+	}
 }

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
+import java.util.Map;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
 	public <T> T accept(CapturedExpressionVisitor<T> visitor) {
 		return visitor.visitCapturedDirect(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tValue = transformer.transform(value);
+		return tValue == value ? this : new CapturedDirectExpression(position, closure, tValue);
+	}
 }

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

 	public <T> T accept(CapturedExpressionVisitor<T> visitor) {
 		return visitor.visitCapturedLocal(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(CapturedExpressionVisitor<T> visitor) {
 		return visitor.visitCapturedParameter(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(CapturedExpressionVisitor<T> visitor) {
 		return visitor.visitCapturedThis(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
+import java.util.Map;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.shared.CodePosition;
 
 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitCast(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tTarget = target.transform(transformer);
+		return target == tTarget ? this : new CastExpression(position, tTarget, member, isImplicit);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitCheckNull(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tValue = transformer.transform(value);
+		return value == tValue ? this : new CheckNullExpression(position, tValue);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitCoalesce(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tLeft = left.transform(transformer);
+		Expression tRight = right.transform(transformer);
+		return tLeft == left && tRight == right ? this : new CoalesceExpression(position, tLeft, tRight);
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/BasicCompareExpression.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/CompareExpression.java

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zenscript.codemodel.CompareType;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.shared.CodePosition;
 
  * 
  * @author Hoofdgebruiker
  */
-public class BasicCompareExpression extends Expression {
+public class CompareExpression extends Expression {
 	public final Expression left;
 	public final Expression right;
-	public final CompareType operator;
+	public final FunctionalMember operator;
+	public final CompareType comparison;
 	
-	public BasicCompareExpression(CodePosition position, Expression left, Expression right, CompareType operator) {
+	public CompareExpression(CodePosition position, Expression left, Expression right, FunctionalMember operator, CompareType comparison, TypeScope scope) {
 		super(position, BasicTypeID.BOOL, binaryThrow(position, left.thrownType, right.thrownType));
 		
 		this.left = left;
-		this.right = right;
+		this.right = scope == null ? right : right.castImplicit(position, scope, operator.header.parameters[0].type);
 		this.operator = operator;
+		this.comparison = comparison;
 	}
 
 	@Override
 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitCompare(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tLeft = left.transform(transformer);
+		Expression tRight = right.transform(transformer);
+		return left == tLeft && right == tRight ? this : new CompareExpression(position, tLeft, tRight, operator, comparison, null);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitConditional(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tCondition = transformer.transform(condition);
+		Expression tIfThen = transformer.transform(ifThen);
+		Expression tIfElse = transformer.transform(ifElse);
+		return tCondition == condition && tIfThen == ifThen && tIfElse == ifElse
+				? this
+				: new ConditionalExpression(position, tCondition, tIfThen, tIfElse, type);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitConstantBool(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitConstantByte(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitConstantChar(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitConstantDouble(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitConstantFloat(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitConstantInt(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitConstantLong(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitConstantSByte(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitConstantShort(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitConstantString(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitConstantUInt(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitConstantULong(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitConstantUShort(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 		
 		this.objectType = type;
 		this.constructor = constructor;
-		this.arguments = arguments.normalize(position, scope, constructor.header);
+		this.arguments = scope == null ? arguments : arguments.normalize(position, scope, constructor.header);
 	}
 
 	@Override
 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitConstructorSuperCall(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		CallArguments tArguments = arguments.transform(transformer);
+		return tArguments == arguments ? this : new ConstructorSuperCallExpression(position, type, constructor, tArguments, null);
+	}
 }

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

 	public ConstructorThisCallExpression(CodePosition position, ITypeID type, ConstructorMember constructor, CallArguments arguments, TypeScope scope) {
 		super(position, BasicTypeID.VOID, binaryThrow(position, constructor.header.thrownType, multiThrow(position, arguments.arguments)));
 		
-		arguments = arguments.normalize(position, scope, constructor.header);
-		
 		this.objectType = type;
 		this.constructor = constructor;
-		this.arguments = arguments;
+		this.arguments = scope == null ? arguments : arguments.normalize(position, scope, constructor.header);
 	}
 
 	@Override
 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitConstructorThisCall(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		CallArguments tArguments = arguments.transform(transformer);
+		return tArguments == arguments ? this : new ConstructorThisCallExpression(position, type, constructor, tArguments, null);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitEnumConstant(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.GenericName;
 	
 	public abstract <T> T accept(ExpressionVisitor<T> visitor);
 	
+	public abstract Expression transform(ExpressionTransformer transformer);
+	
 	@Override
 	public List<ITypeID> getAssignHints() {
 		return Collections.singletonList(type);
 			result = binaryThrow(position, result, expression.thrownType);
 		return result;
 	}
+	
+	public static Expression[] transform(Expression[] expressions, ExpressionTransformer transformer) {
+		Expression[] tExpressions = new Expression[expressions.length];
+		boolean changed = false;
+		for (int i = 0; i < tExpressions.length; i++) {
+			Expression tExpression = expressions[i].transform(transformer);
+			changed |= tExpression != expressions[i];
+			tExpressions[i] = tExpression;
+		}
+		return changed ? tExpressions : expressions;
+	}
 }

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.expression;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface ExpressionTransformer {
+	Expression transform(Expression original);
+}

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

 	
 	public T visitArray(ArrayExpression expression);
 	
-	public T visitCompare(BasicCompareExpression expression);
+	public T visitCompare(CompareExpression expression);
 	
 	public T visitCall(CallExpression expression);
 	
 	
 	public T visitFunction(FunctionExpression expression);
 	
-	public T visitGenericCompare(GenericCompareExpression expression);
-	
 	public T visitGetField(GetFieldExpression expression);
 	
 	public T visitGetFunctionParameter(GetFunctionParameterExpression expression);
 	
 	public T visitThis(ThisExpression expression);
 	
+	public T visitThrow(ThrowExpression expression);
+	
 	public T visitTryConvert(TryConvertExpression expression);
 	
 	public T visitTryRethrowAsException(TryRethrowAsExceptionExpression expression);

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
+import java.util.HashMap;
+import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
+import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.shared.CodePosition;
+import org.openzen.zenscript.shared.ConcatMap;
 
 /**
  *
 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitFunction(this);
 	}
+
+	@Override
+	public FunctionExpression transform(ExpressionTransformer transformer) {
+		Statement tBody = body.transform(transformer, ConcatMap.empty());
+		return tBody == body ? this : new FunctionExpression(position, (FunctionTypeID)type, closure, tBody);
+	}
+	
+	/**
+	 * Checks if this is a simple function expression. A simple function
+	 * expression consists of a body with just a expression or return statement.
+	 * 
+	 * @return 
+	 */
+	public boolean isSimple() {
+		return body instanceof ReturnStatement || body instanceof ExpressionStatement;
+	}
+	
+	public Expression asReturnExpression(Expression... arguments) {
+		Map<FunctionParameter, Expression> filledArguments = new HashMap<>();
+		if (body instanceof ReturnStatement) {
+			return ((ReturnStatement)body).value.transform(new ReturnExpressionTransformer(closure, filledArguments));
+		} else {
+			return null;
+		}
+	}
+	
+	private static class ReturnExpressionTransformer implements ExpressionTransformer {
+		private final LambdaClosure closure;
+		private final Map<FunctionParameter, Expression> filledArguments;
+		
+		public ReturnExpressionTransformer(LambdaClosure closure, Map<FunctionParameter, Expression> filledArguments) {
+			this.closure = closure;
+			this.filledArguments = filledArguments;
+		}
+		
+		@Override
+		public Expression transform(Expression original) {
+			if (original instanceof GetFunctionParameterExpression) {
+				GetFunctionParameterExpression getParameter = (GetFunctionParameterExpression)original;
+				if (filledArguments.containsKey(getParameter.parameter)) {
+					return filledArguments.get(getParameter.parameter);
+				}
+			}
+			
+			return original;
+		}
+	}
 }

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

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.codemodel.expression;
-
-import org.openzen.zenscript.codemodel.CompareType;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.shared.CodePosition;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class GenericCompareExpression extends Expression {
-	public final Expression value;
-	public final CompareType operator;
-	
-	public GenericCompareExpression(CodePosition position, Expression value, CompareType operator) {
-		super(position, BasicTypeID.BOOL, value.thrownType);
-		
-		this.value = value;
-		this.operator = operator;
-	}
-
-	@Override
-	public <T> T accept(ExpressionVisitor<T> visitor) {
-		return visitor.visitGenericCompare(this);
-	}
-}

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

 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
-import org.openzen.zenscript.shared.CompileException;
-import org.openzen.zenscript.shared.CompileExceptionCode;
 
 /**
  *
 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitGetField(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tTarget = target.transform(transformer);
+		return tTarget == target ? this : new GetFieldExpression(position, tTarget, field);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitGetFunctionParameter(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitGetLocalVariable(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitGetStaticField(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitGetter(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tTarget = target.transform(transformer);
+		return target == tTarget ? this : new GetterExpression(position, tTarget, getter);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitGlobalCall(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		CallArguments tArguments = arguments.transform(transformer);
+		Expression tResolution = resolution.transform(transformer);
+		return tArguments == arguments && tResolution == resolution ? this : new GlobalCallExpression(position, name, tArguments, tResolution);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitGlobal(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tResolution = resolution.transform(transformer);
+		return resolution == tResolution ? this : new GlobalExpression(position, name, resolution);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitInterfaceCast(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tValue = value.transform(transformer);
+		return value == tValue ? this : new InterfaceCastExpression(position, tValue, type);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitIs(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tValue = value.transform(transformer);
+		return tValue == value ? this : new IsExpression(position, tValue, type);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitMakeConst(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tValue = value.transform(transformer);
+		return tValue == value ? this : new MakeConstExpression(position, tValue, type);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitMap(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression[] tKeys = Expression.transform(keys, transformer);
+		Expression[] tValues = Expression.transform(values, transformer);
+		return tKeys == keys && tValues == values ? this : new MapExpression(position, tKeys, tValues, type);
+	}
 }

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
+import java.util.Collections;
 import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
+import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
+import org.openzen.zenscript.codemodel.statement.SwitchCase;
+import org.openzen.zenscript.codemodel.statement.SwitchStatement;
+import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 
 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitMatch(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tValue = value.transform(transformer);
+		Case[] tCases = new Case[cases.length];
+		boolean unmodified = true;
+		for (int i = 0; i < tCases.length; i++) {
+			tCases[i] = cases[i].transform(transformer);
+			unmodified &= tCases[i] == cases[i];
+		}
+		return unmodified && tValue == value ? this : new MatchExpression(position, tValue, type, tCases);
+	}
+	
+	public SwitchedMatch convertToSwitch(String tempVariable) {
+		VarStatement result = new VarStatement(position, tempVariable, type, null, false);
+		SwitchStatement switchStatement = new SwitchStatement(position, null, value);
+		for (MatchExpression.Case matchCase : cases) {
+			Expression caseExpression = new SetLocalVariableExpression(matchCase.value.position, result, matchCase.value);
+			SwitchCase switchCase = new SwitchCase(matchCase.key, Collections.singletonList(new ExpressionStatement(matchCase.value.position, caseExpression)));
+			switchStatement.cases.add(switchCase);
+		}
+		return new SwitchedMatch(result, switchStatement);
+	}
+	
+	public static class SwitchedMatch {
+		public final VarStatement result;
+		public final SwitchStatement switchStatement;
+		
+		public SwitchedMatch(VarStatement temp, SwitchStatement switchStatement) {
+			this.result = temp;
+			this.switchStatement = switchStatement;
+		}
+	}
 	
 	public static class Case {
 		public final SwitchValue key;
-		public final FunctionExpression value;
+		public final Expression value;
 		
-		public Case(SwitchValue key, FunctionExpression value) {
+		public Case(SwitchValue key, Expression value) {
 			this.key = key;
 			this.value = value;
 		}
+		
+		public Case transform(ExpressionTransformer transformer) {
+			Expression tValue = value.transform(transformer);
+			return tValue == value ? this : new Case(key, tValue);
+		}
 	}
 	
 	private static ITypeID getThrownType(CodePosition position, Case[] cases) {

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
+import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 
 public class NewExpression extends Expression {
 	public final ConstructorMember constructor;
 	public final CallArguments arguments;
+	public final FunctionHeader instancedHeader;
 	
-	public NewExpression(CodePosition position, ITypeID type, ConstructorMember constructor, CallArguments arguments) {
+	public NewExpression(
+			CodePosition position,
+			ITypeID type,
+			ConstructorMember constructor,
+			CallArguments arguments)
+	{
 		super(position, type, binaryThrow(position, constructor.header.thrownType, multiThrow(position, arguments.arguments)));
 		
 		this.constructor = constructor;
 		this.arguments = arguments;
+		this.instancedHeader = constructor.header;
+	}
+	
+	public NewExpression(
+			CodePosition position,
+			ITypeID type,
+			ConstructorMember constructor,
+			CallArguments arguments,
+			FunctionHeader instancedHeader,
+			TypeScope scope)
+	{
+		super(position, type, binaryThrow(position, constructor.header.thrownType, multiThrow(position, arguments.arguments)));
+		
+		this.constructor = constructor;
+		this.arguments = scope == null ? arguments : arguments.normalize(position, scope, instancedHeader);
+		this.instancedHeader = instancedHeader;
 	}
 
 	@Override
 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitNew(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		CallArguments tArguments = arguments.transform(transformer);
+		return tArguments == arguments ? this : new NewExpression(position, type, constructor, tArguments, instancedHeader, null);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitNull(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitOrOr(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tLeft = left.transform(transformer);
+		Expression tRight = right.transform(transformer);
+		return tLeft == left && tRight == right ? this : new OrOrExpression(position, tLeft, tRight);
+	}
 }

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

 public class PostCallExpression extends Expression {
 	public final Expression target;
 	public final OperatorMember member;
+	public final FunctionHeader instancedHeader;
 	
 	public PostCallExpression(CodePosition position, Expression target, OperatorMember member, FunctionHeader instancedHeader) {
-		super(position, instancedHeader.returnType, binaryThrow(position, member.header.thrownType, target.thrownType));
+		super(position, instancedHeader.returnType, binaryThrow(position, instancedHeader.thrownType, target.thrownType));
 		
 		if (member.operator != OperatorType.DECREMENT && member.operator != OperatorType.INCREMENT)
 			throw new IllegalArgumentException("Operator must be increment or decrement");
 		
 		this.target = target;
 		this.member = member;
+		this.instancedHeader = instancedHeader;
 	}
 
 	@Override
 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitPostCall(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tTarget = target.transform(transformer);
+		return target == tTarget ? this : new PostCallExpression(position, tTarget, member, instancedHeader);
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
 		this.from = from;
 		this.to = to;
 	}
+	
+	private RangeExpression(CodePosition position, ITypeID type, Expression from, Expression to, ITypeID thrownType) {
+		super(position, type, thrownType);
+		
+		this.from = from;
+		this.to = to;
+	}
 
 	@Override
 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitRange(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tFrom = from.transform(transformer);
+		Expression tTo = to.transform(transformer);
+		return tFrom == from && tTo == to ? this : new RangeExpression(position, type, tFrom, tTo, thrownType);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitSameObject(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tLeft = left.transform(transformer);
+		Expression tRight = right.transform(transformer);
+		return tLeft == left && tRight == right ? this : new SameObjectExpression(position, tLeft, tRight, inverted);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitSetField(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tTarget = target.transform(transformer);
+		Expression tValue = value.transform(transformer);
+		return tTarget == target && tValue == value
+				? this
+				: new SetFieldExpression(position, tTarget, field, tValue);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitSetFunctionParameter(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tValue = value.transform(transformer);
+		return tValue == value ? this : new SetFunctionParameterExpression(position, parameter, tValue);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitSetLocalVariable(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tValue = value.transform(transformer);
+		return tValue == value ? this : new SetLocalVariableExpression(position, variable, tValue);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitSetStaticField(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tValue = value.transform(transformer);
+		return value == tValue ? this : new SetStaticFieldExpression(position, field, tValue);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitSetter(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tTarget = target.transform(transformer);
+		Expression tValue = value.transform(transformer);
+		return tTarget == target && tValue == value ? this : new SetterExpression(position, tTarget, setter, tValue);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitStaticGetter(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitStaticSetter(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tValue = value.transform(transformer);
+		return tValue == value ? this : new StaticSetterExpression(position, setter, tValue);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitSupertypeCast(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tValue = value.transform(transformer);
+		return tValue == value ? this : new SupertypeCastExpression(position, tValue, type);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitThis(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
 }

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.expression;
+
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ThrowExpression extends Expression {
+	public final Expression value;
+	
+	public ThrowExpression(CodePosition position, ITypeID type, Expression value) {
+		super(position, type, value.type);
+		
+		this.value = value;
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitThrow(this);
+	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tValue = transformer.transform(value);
+		return tValue == value ? this : new ThrowExpression(position, type, value);
+	}
+}

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitTryConvert(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tValue = value.transform(transformer);
+		return tValue == value ? this : new TryConvertExpression(position, type, tValue);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitTryRethrowAsException(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tValue = value.transform(transformer);
+		return tValue == value ? this : new TryRethrowAsExceptionExpression(position, type, tValue, thrownType);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitTryRethrowAsResult(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tValue = value.transform(transformer);
+		return tValue == value ? this : new TryRethrowAsResultExpression(position, type, tValue);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitVariantValue(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression[] tArguments = Expression.transform(arguments, transformer);
+		return tArguments == arguments ? this : new VariantValueExpression(position, type, option, tArguments);
+	}
 }

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

 	public <T> T accept(ExpressionVisitor<T> visitor) {
 		return visitor.visitWrapOptional(this);
 	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		Expression tValue = value.transform(transformer);
+		return tValue == value ? this : new WrapOptionalExpression(position, tValue, type);
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/switchvalue/VariantOptionSwitchValue.java

 package org.openzen.zenscript.codemodel.expression.switchvalue;
 
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+import org.openzen.zenscript.codemodel.statement.VarStatement;
 
 /**
  *
  */
 public class VariantOptionSwitchValue implements SwitchValue {
 	public final VariantDefinition.Option option;
-	public final String[] parameters;
+	public final VarStatement[] parameters;
 	
-	public VariantOptionSwitchValue(VariantDefinition.Option option, String[] parameters) {
+	public VariantOptionSwitchValue(VariantDefinition.Option option, VarStatement[] parameters) {
 		this.option = option;
 		this.parameters = parameters;
 	}

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

 	
 	T visitArrayKeyValueIterator();
 	
+	T visitStringCharacterIterator();
+	
 	T visitCustomIterator();
 }

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

 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.shared.CodePosition;
  * @author Hoofdgebruiker
  */
 public class CallerMember extends FunctionalMember {
-	public CallerMember(CodePosition position, HighLevelDefinition definition, int modifiers, FunctionHeader header) {
-		super(position, definition, modifiers, "()", header);
+	public CallerMember(
+			CodePosition position,
+			HighLevelDefinition definition,
+			int modifiers,
+			FunctionHeader header,
+			BuiltinID builtin)
+	{
+		super(position, definition, modifiers, "()", header, builtin);
 	}
 	
 	@Override
 
 	@Override
 	public DefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return new CallerMember(position, definition, modifiers, header.instance(registry, mapping));
+		return new CallerMember(
+				position,
+				definition,
+				modifiers,
+				header.instance(registry, mapping),
+				builtin);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.shared.CodePosition;
 
 public class CasterMember extends FunctionalMember implements ICasterMember {
 	public final ITypeID toType;
 	
-	public CasterMember(CodePosition position, HighLevelDefinition definition, int modifiers, ITypeID toType) {
-		super(position, definition, modifiers, "as", new FunctionHeader(toType));
+	public CasterMember(
+			CodePosition position,
+			HighLevelDefinition definition,
+			int modifiers,
+			ITypeID toType,
+			BuiltinID builtin)
+	{
+		super(position, definition, modifiers, "as", new FunctionHeader(toType), builtin);
 		
 		this.toType = toType;
 	}
 
 	@Override
 	public DefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return new CasterMember(position, definition, modifiers, toType.withGenericArguments(registry, mapping));
+		return new CasterMember(
+				position,
+				definition,
+				modifiers,
+				toType.withGenericArguments(registry, mapping),
+				builtin);
 	}
 	
 	@Override