Merge remote-tracking branch 'Stan/development' into development

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.CheckNullExpression;
 import org.openzen.zenscript.codemodel.expression.CoalesceExpression;
 import org.openzen.zenscript.codemodel.expression.ConditionalExpression;
+import org.openzen.zenscript.codemodel.expression.ConstExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantBoolExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
 import org.openzen.zenscript.codemodel.expression.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 visitConst(ConstExpression expression) {
+		StringBuilder result = new StringBuilder();
+		result.append(expression.type.accept(typeFormatter));
+		result.append('.');
+		result.append(expression.constant.name);
+		return new ExpressionString(result.toString(), ZenScriptOperator.MEMBER);
 	}
 
 	@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(Integer.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(expression.value.accept(this));
 		result.append(" {\n");
 
-		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
-//		throw new UnsupportedOperationException();
+		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

 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.CasterMember;
+import org.openzen.zenscript.codemodel.member.ConstMember;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
 import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
 import org.openzen.zenscript.codemodel.member.DestructorMember;
-import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
  * @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;
 		
 		wasField = field;
 	}
+	
+	@Override
+	public Void visitConst(ConstMember member) {
+		visit(true);
+		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		output.append("const")
+				.append(member.name)
+				.append(" as ")
+				.append(member.type.accept(typeFormatter))
+				.append(" = ")
+				.append(member.value.accept(new ExpressionFormatter(settings, typeFormatter)))
+				.append(";\n");
+		return null;
+	}
 
 	@Override
 	public Void visitField(FieldMember member) {
 			output.append(" = ")
 					.append(member.initializer.accept(new ExpressionFormatter(settings, typeFormatter)));
 		}
-		output.append(";").append("\n");
+		output.append(";\n");
 		return null;
 	}
 

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;
+		}
+	}
+}

Linker/build.gradle → CodeFormatterShared/build.gradle

 }
 
 dependencies {
-	compile project(':Shared')
 	compile project(':CodeModel')
 }

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/FunctionParameter.java

  */
 package org.openzen.zenscript.codemodel;
 
+import org.openzen.zenscript.codemodel.annotations.Annotation;
 import java.util.Map;
 import java.util.Objects;
 import org.openzen.zenscript.codemodel.expression.Expression;
 public class FunctionParameter extends Taggable {
 	public static final FunctionParameter[] NONE = new FunctionParameter[0];
 	
+	public Annotation[] annotations;
 	public final ITypeID type;
 	public final String name;
 	public final Expression defaultValue;
 	public final boolean variadic;
 	
 	public FunctionParameter(ITypeID type) {
+		this.annotations = Annotation.NONE;
 		this.type = type;
 		this.name = "";
 		this.defaultValue = null;
 	}
 	
 	public FunctionParameter(ITypeID type, String name) {
+		this.annotations = Annotation.NONE;
 		this.type = type;
 		this.name = name;
 		this.defaultValue = null;
 	}
 	
 	public FunctionParameter(ITypeID type, String name, Expression defaultValue, boolean variadic) {
+		this.annotations = Annotation.NONE;
 		this.type = type;
 		this.name = name;
 		this.defaultValue = defaultValue;
 	}
 	
 	public FunctionParameter withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
-		return new FunctionParameter(type.withGenericArguments(registry, arguments), name, defaultValue, variadic);
+		FunctionParameter result = new FunctionParameter(type.withGenericArguments(registry, arguments), name, defaultValue, variadic);
+		result.annotations = annotations;
+		return result;
 	}
 	
 	@Override

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

 
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zenscript.codemodel.annotations.DefinitionAnnotation;
 import org.openzen.zenscript.codemodel.definition.DefinitionVisitor;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
-import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	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 DefinitionAnnotation[] annotations = DefinitionAnnotation.NONE;
 	
 	public HighLevelDefinition outerDefinition;
 	public ITypeID superType;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/ModuleProcessor.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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface ModuleProcessor {
+	public ScriptBlock process(ScriptBlock block);
+	
+	public void process(HighLevelDefinition definition);
+}

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/ScriptBlock.java

  * @author Hoofdgebruiker
  */
 public class ScriptBlock extends Taggable {
+	public final AccessScope access;
 	public final List<Statement> statements;
 	
-	public ScriptBlock(List<Statement> statements) {
+	public ScriptBlock(AccessScope access, List<Statement> statements) {
+		this.access = access;
 		this.statements = statements;
 	}
+	
+	public ScriptBlock withStatements(List<Statement> newStatements) {
+		ScriptBlock result = new ScriptBlock(access, newStatements);
+		result.addAllTagsFrom(this);
+		return result;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/Annotation.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.annotations;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface Annotation {
+	public static final Annotation[] NONE = new Annotation[0];
+	
+	public void apply();
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/AnnotationDefinition.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.annotations;
+
+import java.util.List;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface AnnotationDefinition {
+	public String getAnnotationName();
+	
+	public List<FunctionHeader> getInitializers(BaseScope scope);
+	
+	public ExpressionScope getScopeForMember(IDefinitionMember member, BaseScope scope);
+	
+	public ExpressionScope getScopeForType(HighLevelDefinition definition, BaseScope scope);
+	
+	public ExpressionScope getScopeForStatement(Statement statement, StatementScope scope);
+	
+	public ExpressionScope getScopeForParameter(FunctionHeader header, FunctionParameter parameter, BaseScope scope);
+	
+	public MemberAnnotation createForMember(CodePosition position, CallArguments arguments);
+	
+	public DefinitionAnnotation createForDefinition(CodePosition position, CallArguments arguments);
+	
+	public StatementAnnotation createForStatement(CodePosition position, CallArguments arguments);
+	
+	public Annotation createForParameter(CodePosition position, CallArguments arguments);
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/AnnotationProcessor.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.annotations;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.ModuleProcessor;
+import org.openzen.zenscript.codemodel.PackageDefinitions;
+import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.member.CallerMember;
+import org.openzen.zenscript.codemodel.member.CasterMember;
+import org.openzen.zenscript.codemodel.member.ConstMember;
+import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
+import org.openzen.zenscript.codemodel.member.DestructorMember;
+import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.GetterMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.ImplementationMember;
+import org.openzen.zenscript.codemodel.member.InnerDefinitionMember;
+import org.openzen.zenscript.codemodel.member.MemberVisitor;
+import org.openzen.zenscript.codemodel.member.MethodMember;
+import org.openzen.zenscript.codemodel.member.OperatorMember;
+import org.openzen.zenscript.codemodel.member.SetterMember;
+import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
+import org.openzen.zenscript.codemodel.scope.DefinitionScope;
+import org.openzen.zenscript.codemodel.scope.FileScope;
+import org.openzen.zenscript.codemodel.scope.FunctionScope;
+import org.openzen.zenscript.codemodel.scope.GlobalScriptScope;
+import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class AnnotationProcessor implements ModuleProcessor {
+	private final ZSPackage rootPackage;
+	private final PackageDefinitions packageDefinitions;
+	private final GlobalTypeRegistry globalRegistry;
+	private final List<ExpansionDefinition> expansions;
+	private final List<AnnotationDefinition> annotations;
+	
+	public AnnotationProcessor(
+			ZSPackage rootPackage,
+			PackageDefinitions packageDefinitions,
+			GlobalTypeRegistry globalRegistry,
+			List<ExpansionDefinition> expansions,
+			List<AnnotationDefinition> annotations) {
+		this.rootPackage = rootPackage;
+		this.packageDefinitions = packageDefinitions;
+		this.globalRegistry = globalRegistry;
+		this.expansions = expansions;
+		this.annotations = annotations;
+	}
+	
+	@Override
+	public ScriptBlock process(ScriptBlock block) {
+		FileScope fileScope = new FileScope(block.access, rootPackage, packageDefinitions, globalRegistry, expansions, new HashMap<>(), annotations);
+		StatementScope scope = new GlobalScriptScope(fileScope);
+		List<Statement> transformed = new ArrayList<>();
+		boolean unchanged = true;
+		for (Statement statement : block.statements) {
+			Statement newStatement = process(statement, scope);
+			transformed.add(newStatement);
+			unchanged &= statement == newStatement;
+		}
+		return unchanged ? block : block.withStatements(transformed);
+	}
+	
+	@Override
+	public void process(HighLevelDefinition definition) {
+		FileScope fileScope = new FileScope(definition.access, rootPackage, packageDefinitions, globalRegistry, expansions, new HashMap<>(), annotations);
+		DefinitionScope scope = new DefinitionScope(fileScope, definition);
+		for (DefinitionAnnotation annotation : definition.annotations) {
+			annotation.apply(definition, scope);
+		}
+		
+		MemberAnnotationVisitor visitor = new MemberAnnotationVisitor(scope);
+		for (IDefinitionMember member : definition.members) {
+			member.accept(visitor);
+		}
+	}
+	
+	private Statement process(Statement statement, StatementScope scope) {
+		return statement.transform(s -> {
+			for (StatementAnnotation annotation : s.annotations) {
+				s = annotation.apply(s, scope);
+			}
+			return s;
+		});
+	}
+	
+	private class MemberAnnotationVisitor implements MemberVisitor<Void> {
+		private final DefinitionScope scope;
+		
+		public MemberAnnotationVisitor(DefinitionScope scope) {
+			this.scope = scope;
+		}
+		
+		@Override
+		public Void visitConst(ConstMember member) {
+			for (MemberAnnotation annotation : member.annotations)
+				annotation.apply(member, scope);
+			
+			return null;
+		}
+
+		@Override
+		public Void visitField(FieldMember member) {
+			for (MemberAnnotation annotation : member.annotations)
+				annotation.apply(member, scope);
+			
+			return null;
+		}
+
+		@Override
+		public Void visitConstructor(ConstructorMember member) {
+			return functional(member);
+		}
+
+		@Override
+		public Void visitDestructor(DestructorMember member) {
+			return functional(member);
+		}
+
+		@Override
+		public Void visitMethod(MethodMember member) {
+			return functional(member);
+		}
+
+		@Override
+		public Void visitGetter(GetterMember member) {
+			return functional(member);
+		}
+
+		@Override
+		public Void visitSetter(SetterMember member) {
+			return functional(member);
+		}
+
+		@Override
+		public Void visitOperator(OperatorMember member) {
+			return functional(member);
+		}
+
+		@Override
+		public Void visitCaster(CasterMember member) {
+			return functional(member);
+		}
+
+		@Override
+		public Void visitCustomIterator(CustomIteratorMember member) {
+			throw new UnsupportedOperationException("Not supported yet!");
+		}
+
+		@Override
+		public Void visitCaller(CallerMember member) {
+			return functional(member);
+		}
+
+		@Override
+		public Void visitImplementation(ImplementationMember implementation) {
+			for (IDefinitionMember member : implementation.members) {
+				member.accept(this);
+			}
+			return null;
+		}
+
+		@Override
+		public Void visitInnerDefinition(InnerDefinitionMember member) {
+			process(member.innerDefinition);
+			return null;
+		}
+
+		@Override
+		public Void visitStaticInitializer(StaticInitializerMember member) {
+			StatementScope scope = new FunctionScope(this.scope, new FunctionHeader(BasicTypeID.VOID));
+			member.body = process(member.body, scope);
+			return null;
+		}
+		
+		private Void functional(FunctionalMember member) {
+			for (MemberAnnotation annotation : member.annotations)
+				annotation.apply(member, scope);
+			
+			if (member.overrides != null) {
+				functional(member, member.overrides);
+			}
+			
+			if (member.body == null)
+				return null;
+			
+			StatementScope scope = new FunctionScope(this.scope, member.header);
+			member.body = process(member.body, scope);
+			return null;
+		}
+		
+		private void functional(FunctionalMember member, FunctionalMember overrides) {
+			for (MemberAnnotation annotation : overrides.annotations)
+				annotation.applyOnOverridingMethod(member, scope);
+			
+			if (overrides.overrides != null) {
+				functional(member, overrides.overrides);
+			}
+		}
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/DefinitionAnnotation.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.annotations;
+
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DefinitionAnnotation {
+	public static final DefinitionAnnotation[] NONE = new DefinitionAnnotation[0];
+	
+	public void apply(HighLevelDefinition definition, BaseScope scope);
+	
+	public void applyOnSubtype(HighLevelDefinition definition, BaseScope scope);
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/MemberAnnotation.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.annotations;
+
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface MemberAnnotation {
+	public static final MemberAnnotation[] NONE = new MemberAnnotation[0];
+	
+	public void apply(IDefinitionMember member, BaseScope scope);
+	
+	public void applyOnOverridingMethod(FunctionalMember member, BaseScope scope);
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/NativeAnnotationDefinition.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.annotations;
+
+import java.util.Collections;
+import java.util.List;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class NativeAnnotationDefinition implements AnnotationDefinition {
+	public static final NativeAnnotationDefinition INSTANCE = new NativeAnnotationDefinition();
+	
+	private static final List<FunctionHeader> INITIALIZERS = Collections.singletonList(
+			new FunctionHeader(BasicTypeID.VOID, BasicTypeID.STRING));
+	
+	private NativeAnnotationDefinition() {}
+
+	@Override
+	public String getAnnotationName() {
+		return "Native";
+	}
+
+	@Override
+	public List<FunctionHeader> getInitializers(BaseScope scope) {
+		return INITIALIZERS;
+	}
+
+	@Override
+	public ExpressionScope getScopeForMember(IDefinitionMember member, BaseScope scope) {
+		return new ExpressionScope(scope);
+	}
+
+	@Override
+	public ExpressionScope getScopeForType(HighLevelDefinition definition, BaseScope scope) {
+		return new ExpressionScope(scope);
+	}
+
+	@Override
+	public ExpressionScope getScopeForStatement(Statement statement, StatementScope scope) {
+		return new ExpressionScope(scope);
+	}
+
+	@Override
+	public ExpressionScope getScopeForParameter(FunctionHeader header, FunctionParameter parameter, BaseScope scope) {
+		return new ExpressionScope(scope);
+	}
+
+	@Override
+	public MemberAnnotation createForMember(CodePosition position, CallArguments arguments) {
+		Expression value = arguments.arguments[0];
+		String constant = value.evaluateStringConstant();
+		return new NativeMemberAnnotation(constant);
+	}
+
+	@Override
+	public DefinitionAnnotation createForDefinition(CodePosition position, CallArguments arguments) {
+		Expression value = arguments.arguments[0];
+		String constant = value.evaluateStringConstant();
+		return new NativeDefinitionAnnotation(constant);
+	}
+
+	@Override
+	public StatementAnnotation createForStatement(CodePosition position, CallArguments arguments) {
+		throw new UnsupportedOperationException("Not supported");
+	}
+
+	@Override
+	public Annotation createForParameter(CodePosition position, CallArguments arguments) {
+		throw new UnsupportedOperationException("Not supported");
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/NativeDefinitionAnnotation.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.annotations;
+
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class NativeDefinitionAnnotation implements DefinitionAnnotation {
+	private final String identifier;
+	
+	public NativeDefinitionAnnotation(String identifier) {
+		this.identifier = identifier;
+	}
+	
+	@Override
+	public void apply(HighLevelDefinition definition, BaseScope scope) {
+		definition.setTag(NativeTag.class, new NativeTag(identifier));
+	}
+
+	@Override
+	public void applyOnSubtype(HighLevelDefinition definition, BaseScope scope) {
+		// this annotation is not inherited
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/NativeMemberAnnotation.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.annotations;
+
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class NativeMemberAnnotation implements MemberAnnotation {
+	private final String identifier;
+	
+	public NativeMemberAnnotation(String identifier) {
+		this.identifier = identifier;
+	}
+	
+	@Override
+	public void apply(IDefinitionMember member, BaseScope scope) {
+		member.setTag(NativeTag.class, new NativeTag(identifier));
+	}
+
+	@Override
+	public void applyOnOverridingMethod(FunctionalMember member, BaseScope scope) {
+		// not inherited
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/NativeTag.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.annotations;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class NativeTag {
+	public final String value;
+	
+	public NativeTag(String value) {
+		this.value = value;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/PreconditionAnnotationDefinition.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.annotations;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.scope.FunctionScope;
+import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class PreconditionAnnotationDefinition implements AnnotationDefinition {
+	public static final PreconditionAnnotationDefinition INSTANCE = new PreconditionAnnotationDefinition();
+	
+	private final List<GenericName> enforcementLevelName = Arrays.asList(
+			new GenericName("stdlib"),
+			new GenericName("EnforcementLevel"));
+	
+	private PreconditionAnnotationDefinition() {}
+
+	@Override
+	public String getAnnotationName() {
+		return "Precondition";
+	}
+
+	@Override
+	public List<FunctionHeader> getInitializers(BaseScope scope) {
+		return Collections.singletonList(new FunctionHeader(
+				BasicTypeID.VOID,
+				scope.getType(CodePosition.BUILTIN, enforcementLevelName),
+				BasicTypeID.BOOL,
+				BasicTypeID.STRING));
+	}
+
+	@Override
+	public ExpressionScope getScopeForMember(IDefinitionMember member, BaseScope scope) {
+		if (member instanceof FunctionalMember) {
+			FunctionHeader header = ((FunctionalMember)member).header;
+			return new ExpressionScope(new FunctionScope(scope, header));
+		} else {
+			throw new UnsupportedOperationException("Can only assign preconditions to methods");
+		}
+	}
+
+	@Override
+	public ExpressionScope getScopeForType(HighLevelDefinition definition, BaseScope scope) {
+		if (definition instanceof FunctionDefinition) {
+			FunctionHeader header = ((FunctionDefinition)definition).header;
+			return new ExpressionScope(new FunctionScope(scope, header));
+		} else {
+			throw new UnsupportedOperationException("Can only assign preconditions to functions");
+		}
+	}
+
+	@Override
+	public ExpressionScope getScopeForStatement(Statement statement, StatementScope scope) {
+		throw new UnsupportedOperationException("Not supported");
+	}
+
+	@Override
+	public ExpressionScope getScopeForParameter(FunctionHeader header, FunctionParameter parameter, BaseScope scope) {
+		throw new UnsupportedOperationException("Not supported");
+	}
+
+	@Override
+	public MemberAnnotation createForMember(CodePosition position, CallArguments arguments) {
+		String enforcement = arguments.arguments[0].evaluateEnumConstant().name;
+		Expression condition = arguments.arguments[1];
+		Expression message = arguments.arguments[2];
+		return new PreconditionForMethod(position, enforcement, condition, message);
+	}
+
+	@Override
+	public DefinitionAnnotation createForDefinition(CodePosition position, CallArguments arguments) {
+		throw new UnsupportedOperationException("Not supported");
+	}
+
+	@Override
+	public StatementAnnotation createForStatement(CodePosition position, CallArguments arguments) {
+		throw new UnsupportedOperationException("Not supported");
+	}
+
+	@Override
+	public Annotation createForParameter(CodePosition position, CallArguments arguments) {
+		throw new UnsupportedOperationException("Not supported");
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/PreconditionForMethod.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.annotations;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.ExpressionBuilder;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.statement.BlockStatement;
+import org.openzen.zenscript.codemodel.statement.IfStatement;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.ThrowStatement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class PreconditionForMethod implements MemberAnnotation {
+	private final CodePosition position;
+	private final String enforcement;
+	private final Expression condition;
+	private final Expression message;
+	
+	public PreconditionForMethod(
+			CodePosition position,
+			String enforcement,
+			Expression condition,
+			Expression message) {
+		this.position = position;
+		this.enforcement = enforcement;
+		this.condition = condition;
+		this.message = message;
+	}
+
+	@Override
+	public void apply(IDefinitionMember member, BaseScope scope) {
+		applyOnOverridingMethod((FunctionalMember)member, scope);
+	}
+
+	@Override
+	public void applyOnOverridingMethod(FunctionalMember member, BaseScope scope) {
+		if (member.body == null)
+			return;
+		
+		ExpressionScope expressionScope = new ExpressionScope(scope, BasicTypeID.BOOL);
+		List<Statement> statements = new ArrayList<>();
+		ExpressionBuilder expressionBuilder = new ExpressionBuilder(position, expressionScope);
+		Expression inverseCondition = expressionBuilder.not(condition);
+		Statement throwStatement = new ThrowStatement(CodePosition.BUILTIN, expressionBuilder.constructNew("stdlib.IllegalArgumentException", message));
+		statements.add(new IfStatement(CodePosition.BUILTIN, inverseCondition, throwStatement, null));
+		if (member.body instanceof BlockStatement) {
+			statements.addAll(((BlockStatement)member.body).statements);
+		} else {
+			statements.add(member.body);
+		}
+		member.body = new BlockStatement(position, statements);
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/StatementAnnotation.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.annotations;
+
+import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.statement.Statement;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface StatementAnnotation {
+	public static final StatementAnnotation[] NONE = new StatementAnnotation[0];
+	
+	public Statement apply(Statement statement, StatementScope scope);
+}

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);
+	}
+	
+	@Override
+	public String evaluateStringConstant() {
+		if (member.builtin == null)
+			throw new UnsupportedOperationException("Cannot evaluate to a string constant!");
+		
+		switch (member.builtin) {
+			case STRING_ADD_STRING:
+				return target.evaluateStringConstant() + arguments.arguments[0].evaluateStringConstant();
+			default:
+				throw new UnsupportedOperationException("Cannot evaluate to a string constant!");
+		}
+	}
 }

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/ConstExpression.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.member.ConstMember;
+import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ConstExpression extends Expression {
+	public final ConstMember constant;
+	
+	public ConstExpression(CodePosition position, ConstMember constant) {
+		super(position, constant.type, null);
+		
+		this.constant = constant;
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitConst(this);
+	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
+	
+	@Override
+	public String evaluateStringConstant() {
+		return constant.value.evaluateStringConstant();
+	}
+	
+	@Override
+	public EnumConstantMember evaluateEnumConstant() {
+		return constant.value.evaluateEnumConstant();
+	}
+}

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

  * @author Hoofdgebruiker
  */
 public class ConstantByteExpression extends Expression {
-	public final byte value;
+	public final int value;
 	
-	public ConstantByteExpression(CodePosition position, byte value) {
+	public ConstantByteExpression(CodePosition position, int value) {
 		super(position, BasicTypeID.BYTE, null);
 		
 		this.value = value;
 	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;
+	}
+	
+	@Override
+	public String evaluateStringConstant() {
+		return value;
+	}
 }

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

  * @author Hoofdgebruiker
  */
 public class ConstantUShortExpression extends Expression {
-	public final short value;
+	public final int value;
 	
-	public ConstantUShortExpression(CodePosition position, short value) {
+	public ConstantUShortExpression(CodePosition position, int value) {
 		super(position, BasicTypeID.USHORT, null);
 		
 		this.value = value;
 	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;
+	}
+	
+	@Override
+	public EnumConstantMember evaluateEnumConstant() {
+		return value;
+	}
 }

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

 
 import java.util.Collections;
 import java.util.List;
+import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.StatementTransformer;
+import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.shared.CompileException;
 import org.openzen.zenscript.shared.CompileExceptionCode;
 
  * @author Hoofdgebruiker
  */
 public abstract class Expression implements IPartialExpression {
+	public static final Expression[] NONE = new Expression[0];
+	
 	public final CodePosition position;
 	public final ITypeID type;
 	public final ITypeID thrownType;
 	
 	public abstract <T> T accept(ExpressionVisitor<T> visitor);
 	
+	public abstract Expression transform(ExpressionTransformer transformer);
+	
+	public final Expression transform(StatementTransformer transformer) {
+		return transform((ExpressionTransformer)expression -> {
+			if (expression instanceof FunctionExpression) {
+				FunctionExpression function = (FunctionExpression)expression;
+				Statement body = function.body.transform(transformer);
+				if (body == function.body)
+					return function;
+				
+				return new FunctionExpression(function.position, (FunctionTypeID)function.type, function.closure, body);
+			} else {
+				return expression;
+			}
+		});
+	}
+	
 	@Override
 	public List<ITypeID> getAssignHints() {
 		return Collections.singletonList(type);
 		return scope.getTypeMembers(type)
 				.getOrCreateGroup(OperatorType.CALL)
 				.getMethodMembers().stream()
-				.filter(method -> method.member.getHeader().parameters.length == arguments && !method.member.isStatic())
-				.map(method -> method.member.getHeader())
+				.filter(method -> method.member.header.parameters.length == arguments && !method.member.isStatic())
+				.map(method -> method.member.header)
 				.collect(Collectors.toList());
 	}
 	
 	@Override
 	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<ITypeID> hints, GenericName name) {
 		TypeMembers members = scope.getTypeMembers(type);
-		return members.getMemberExpression(position, this, name, false);
+		IPartialExpression result = members.getMemberExpression(position, this, name, false);
+		if (result == null)
+			System.out.println("No such member: " + name.name);
+		return result;
 	}
 	
 	@Override
 		return null;
 	}
 	
+	public void forEachStatement(Consumer<Statement> consumer) {
+		
+	}
+	
+	public String evaluateStringConstant() {
+		throw new UnsupportedOperationException("Cannot evaluate this value to a string constant!");
+	}
+	
+	public EnumConstantMember evaluateEnumConstant() {
+		throw new UnsupportedOperationException("Cannot evaluate this value to an enum constant!");
+	}
+	
 	public static ITypeID binaryThrow(CodePosition position, ITypeID left, ITypeID right) {
 		if (left == right)
 			return left;
 			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/ExpressionBuilder.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 java.util.ArrayList;
+import java.util.List;
+import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+import org.openzen.zenscript.shared.CodePosition;
+import org.openzen.zenscript.shared.CompileException;
+import org.openzen.zenscript.shared.CompileExceptionCode;
+import org.openzen.zenscript.shared.StringUtils;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ExpressionBuilder {
+	public final CodePosition position;
+	public final ExpressionScope scope;
+	
+	public ExpressionBuilder(CodePosition position, ExpressionScope scope) {
+		this.position = position;
+		this.scope = scope;
+	}
+	
+	public Expression constructNew(String typename, Expression... arguments) {
+		List<String> nameParts = StringUtils.split(typename, '.');
+		List<GenericName> name = new ArrayList<>();
+		for (String namePart : nameParts)
+			name.add(new GenericName(namePart));
+		ITypeID type = scope.getType(position, name);
+		if (type == null)
+			throw new CompileException(position, CompileExceptionCode.NO_SUCH_TYPE, "No such type: " + typename);
+		
+		return constructNew(type, arguments);
+	}
+	
+	public Expression constructNew(ITypeID type, Expression... arguments) {
+		DefinitionMemberGroup constructors = scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CONSTRUCTOR);
+		List<ITypeID>[] predictedTypes = constructors.predictCallTypes(scope, scope.hints, arguments.length);
+		CallArguments compiledArguments = new CallArguments(arguments);
+		FunctionalMember member = constructors.selectMethod(position, scope, compiledArguments, true, true);
+		if (member == null)
+			throw new CompileException(position, CompileExceptionCode.CALL_NO_VALID_METHOD, "No matching constructor found");
+		if (!(member instanceof ConstructorMember))
+			throw new CompileException(position, CompileExceptionCode.INTERNAL_ERROR, "COMPILER BUG: constructor is not a constructor");
+		
+		return new NewExpression(
+				position,
+				type,
+				(ConstructorMember) member,
+				compiledArguments,
+				compiledArguments.getNumberOfTypeArguments() == 0 ? member.header : member.header.withGenericArguments(scope.getTypeRegistry(), compiledArguments.typeArguments),
+				scope);
+	}
+	
+	public Expression not(Expression value) {
+		TypeMembers members = scope.getTypeMembers(value.type);
+		return members.getOrCreateGroup(OperatorType.NOT)
+				.call(position, scope, value, CallArguments.EMPTY, false);
+	}
+}

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 visitConditional(ConditionalExpression expression);
 	
+	public T visitConst(ConstExpression expression);
+	
 	public T visitConstantBool(ConstantBoolExpression expression);
 	
 	public T visitConstantByte(ConstantByteExpression 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 java.util.function.Consumer;
 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);
+	}
+	
+	@Override
+	public void forEachStatement(Consumer<Statement> consumer) {
+		body.forEachStatement(consumer);
+	}
+	
+	/**
+	 * 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);
+	}
 }