- Continued work on the code formatter

- Static calls now remember the exact type they are called for

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

  */
 package org.openzen.zenscript.formatter;
 
+import java.util.List;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
 import org.openzen.zenscript.codemodel.definition.DefinitionVisitor;
 import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.definition.StructDefinition;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 
 /**
 		} else {
 			output.append("\n")
 					.append(indent)
-					.append("{\n")
-					.append(indent + settings.indent);
+					.append("{\n");
 		}
 		
+		MemberFormatter memberFormatter = new MemberFormatter(settings, output, indent + settings.indent, typeFormatter);
 		for (IDefinitionMember member : definition.members) {
-			member.accept(new MemberFormatter(settings, output, indent + settings.indent, typeFormatter));
+			member.accept(memberFormatter);
 		}
 		
 		output.append("}\n");
 
 	@Override
 	public Void visitInterface(InterfaceDefinition definition) {
+		FormattingUtils.formatModifiers(output, definition.modifiers);
+		output.append("class ");
+		output.append(definition.name);
+		FormattingUtils.formatTypeParameters(output, definition.genericParameters, typeFormatter);
+		output.append(" ");
+		
+		if (settings.classBracketOnSameLine) {
+			output.append("{\n");
+		} else {
+			output.append("\n")
+					.append(indent)
+					.append("{\n");
+		}
 		
+		MemberFormatter memberFormatter = new MemberFormatter(settings, output, indent + settings.indent, typeFormatter);
+		for (IDefinitionMember member : definition.members) {
+			member.accept(memberFormatter);
+		}
+		
+		output.append("}\n");
 		return null;
 	}
 
 	@Override
 	public Void visitEnum(EnumDefinition definition) {
+		FormattingUtils.formatModifiers(output, definition.modifiers);
+		output.append("enum ");
+		output.append(definition.name);
+		FormattingUtils.formatTypeParameters(output, definition.genericParameters, typeFormatter);
+		output.append(" ");
+		
+		if (settings.classBracketOnSameLine) {
+			output.append("{\n");
+		} else {
+			output.append("\n")
+					.append(indent)
+					.append("{\n");
+		}
+		
+		List<EnumConstantMember> enumConstants = definition.getEnumConstants();
+		boolean first = true;
+		ExpressionFormatter expressionFormatter = new ExpressionFormatter(settings, typeFormatter);
+		for (EnumConstantMember enumConstant : enumConstants) {
+			if (first)
+				first = false;
+			else
+				output.append(",\n");
+			
+			output.append(indent).append(settings.indent).append(enumConstant.name);
+			if (enumConstant.constructor != null) {
+				FormattingUtils.formatCall(output, typeFormatter, expressionFormatter, enumConstant.constructor.arguments);
+			}
+		}
+		
+		if (definition.members.size() > enumConstants.size()) {
+			output.append(";\n").append(indent).append(settings.indent).append("\n");
+
+			MemberFormatter memberFormatter = new MemberFormatter(settings, output, indent + settings.indent, typeFormatter);
+			for (IDefinitionMember member : definition.members) {
+				member.accept(memberFormatter);
+			}
+		}
+		
+		output.append("}\n");
 		return null;
 	}
 
 		return null;
 	}
 	
+	@Override
 	public String toString() {
 		return output.toString();
 	}

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

  */
 package org.openzen.zenscript.formatter;
 
+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.CallArguments;
 import org.openzen.zenscript.codemodel.expression.CallExpression;
 import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
 import org.openzen.zenscript.codemodel.expression.CapturedClosureExpression;
 				case CALL: {
 					StringBuilder result = new StringBuilder();
 					result.append(".");
-					format(result, expression.arguments);
+					FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
 					return new ExpressionString(result.toString(), OperatorPriority.CALL);
 				}
 				case CAST: {
 			result.append(expression.target.accept(this).value);
 			result.append(".");
 			result.append(expression.member.name);
-			format(result, expression.arguments);
+			FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
 			return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
 		}
 	}
 	@Override
 	public ExpressionString visitCallStatic(CallStaticExpression expression) {
 		StringBuilder result = new StringBuilder();
-		result.append(expression.type.accept(typeFormatter));
-		result.append(".");
-		result.append(expression.member.name);
-		format(result, expression.arguments);
-		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
-	}
-	
-	private void format(StringBuilder result, CallArguments arguments) {
-		if (arguments == null || arguments.typeArguments == null)
-			throw new IllegalArgumentException("Arguments cannot be null!");
-		
-		if (arguments.typeArguments.length > 0) {
-			result.append("<");
-			
-			int index = 0;
-			for (ITypeID typeArgument : arguments.typeArguments) {
-				if (index > 0)
-					result.append(", ");
-				result.append(typeArgument.accept(typeFormatter));
-				index++;
+		result.append(expression.target.accept(typeFormatter));
+		if (expression.member instanceof OperatorMember) {
+			OperatorMember operator = (OperatorMember) expression.member;
+			if (operator.operator == OperatorType.CALL) {
+				// nothing
+			} else {
+				result.append(".");
+				result.append(expression.member.name);
 			}
-			result.append(">");
-		}
-		result.append("(");
-		int index = 0;
-		for (Expression argument : arguments.arguments) {
-			if (index > 0)
-				result.append(", ");
-			result.append(argument.accept(this).value);
-			index++;
+		} else {
+			result.append(".");
+			result.append(expression.member.name);
 		}
-		result.append(")");
+		FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
+		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
 	}
 
 	@Override
 	public ExpressionString visitConstructorThisCall(ConstructorThisCallExpression expression) {
 		StringBuilder result = new StringBuilder();
 		result.append("this");
-		format(result, expression.arguments);
+		FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
 		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
 	}
 
 	public ExpressionString visitConstructorSuperCall(ConstructorSuperCallExpression expression) {
 		StringBuilder result = new StringBuilder();
 		result.append("super");
-		format(result, expression.arguments);
+		FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
 		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
 	}
 
 	public ExpressionString visitGlobalCall(GlobalCallExpression expression) {
 		StringBuilder result = new StringBuilder();
 		result.append(expression.name);
-		format(result, expression.arguments);
+		FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
 		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
 	}
 
 		StringBuilder result = new StringBuilder();
 		result.append("new ");
 		result.append(expression.type.accept(typeFormatter));
-		format(result, expression.arguments);
+		FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
 		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
 	}
 

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

 			definitionFormatters.add(definitionFormatter);
 		}
 		
-		StatementFormatter scriptFormatter = new StatementFormatter("", settings, expressionFormatter);
+		StringBuilder scriptOutput = new StringBuilder();
+		StatementFormatter scriptFormatter = new StatementFormatter(scriptOutput, "", settings, expressionFormatter);
 		for (Statement statement : script.statements) {
 			statement.accept(scriptFormatter);
 		}
 		StringBuilder output = new StringBuilder();
 		importer.write(output);
 		
+		boolean first = true;
 		for (DefinitionFormatter definition : definitionFormatters) {
+			if (first)
+				first = false;
+			else
+				output.append("\n");
+			
 			output.append(definition.toString());
 		}
 		
-		output.append(scriptFormatter.toString().trim());
-		
-		WhitespacePostComment postComment = script.getTag(WhitespacePostComment.class);
-		if (postComment != null) {
-			for (String comment : CommentFormatter.format(postComment.comments)) {
-				output.append("\n").append(comment);
+		if (script.statements.size() > 0) {
+			if (definitionFormatters.size() > 0)
+				output.append("\n");
+			
+			output.append(scriptOutput.toString().trim());
+
+			WhitespacePostComment postComment = script.getTag(WhitespacePostComment.class);
+			if (postComment != null) {
+				for (String comment : CommentFormatter.format(postComment.comments)) {
+					output.append("\n").append(comment);
+				}
 			}
 		}
 		

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.statement.BlockStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.statement.WhileStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
  *
 	
 	public static void formatBody(StringBuilder output, FormattingSettings settings, String indent, TypeFormatter typeFormatter, Statement body) {
 		body.accept(new BodyFormatter(output, settings, indent, typeFormatter));
+		output.append("\n");
+	}
+	
+	public static void formatCall(StringBuilder result, TypeFormatter typeFormatter, ExpressionFormatter expressionFormatter, CallArguments arguments) {
+		if (arguments == null || arguments.typeArguments == null)
+			throw new IllegalArgumentException("Arguments cannot be null!");
+		
+		if (arguments.typeArguments.length > 0) {
+			result.append("<");
+			
+			int index = 0;
+			for (ITypeID typeArgument : arguments.typeArguments) {
+				if (index > 0)
+					result.append(", ");
+				result.append(typeArgument.accept(typeFormatter));
+				index++;
+			}
+			result.append(">");
+		}
+		result.append("(");
+		int index = 0;
+		for (Expression argument : arguments.arguments) {
+			if (index > 0)
+				result.append(", ");
+			result.append(argument.accept(expressionFormatter).value);
+			index++;
+		}
+		result.append(")");
 	}
 	
 	private static class BodyFormatter implements StatementVisitor<Void> {
 			this.indent = indent;
 			this.typeFormatter = typeFormatter;
 			
-			statementFormatter = new StatementFormatter(indent + settings.indent, settings, new ExpressionFormatter(settings, typeFormatter)); 
+			statementFormatter = new StatementFormatter(output, indent, settings, new ExpressionFormatter(settings, typeFormatter)); 
 		}
 
 		@Override
 
 		@Override
 		public Void visitEmpty(EmptyStatement statement) {
-			output.append(";\n");
+			output.append(";");
 			return null;
 		}
 

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

 	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) {
 		this.settings = settings;
 		this.indent = indent;
 		this.typeFormatter = typeFormatter;
 	}
+	
+	private void visit(boolean field) {
+		output.append(indent);
+		
+		if (isFirst) {
+			isFirst = false;
+		} else if (!field || (wasField != field)) {
+			output.append("\n").append(indent);
+		}
+		
+		wasField = field;
+	}
 
 	@Override
 	public Void visitField(FieldMember member) {
+		visit(true);
 		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
 		output.append(member.isFinal() ? "val " : "var ")
 				.append(member.name)
 			output.append(" = ")
 					.append(member.initializer.accept(new ExpressionFormatter(settings, typeFormatter)));
 		}
-		output.append(";").append("\n").append(indent);
+		output.append(";").append("\n");
 		return null;
 	}
 
 	@Override
 	public Void visitConstructor(ConstructorMember member) {
+		visit(false);
 		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
 		output.append("this");
 		FormattingUtils.formatHeader(output, settings, member.header, typeFormatter);
 
 	@Override
 	public Void visitMethod(MethodMember member) {
+		visit(false);
 		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
 		output.append(member.name);
 		FormattingUtils.formatHeader(output, settings, member.header, typeFormatter);
 
 	@Override
 	public Void visitGetter(GetterMember member) {
+		visit(false);
 		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
 		output.append("get ");
 		output.append(member.name);
 
 	@Override
 	public Void visitSetter(SetterMember member) {
+		visit(false);
 		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
 		output.append("set ");
 		output.append(member.name);
 
 	@Override
 	public Void visitOperator(OperatorMember member) {
+		visit(false);
 		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
 		switch (member.operator) {
 			case ADD: output.append("+"); break;
 
 	@Override
 	public Void visitCaster(CasterMember member) {
+		visit(false);
 		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
 		output.append(" as ");
 		output.append(member.toType.accept(typeFormatter));
 
 	@Override
 	public Void visitCustomIterator(CustomIteratorMember member) {
+		visit(false);
 		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
 	}
 
 	@Override
 	public Void visitCaller(CallerMember member) {
+		visit(false);
 		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
 		FormattingUtils.formatHeader(output, settings, member.header, typeFormatter);
 		formatBody(member.body);
 
 	@Override
 	public Void visitImplementation(ImplementationMember implementation) {
+		visit(false);
 		FormattingUtils.formatModifiers(output, implementation.modifiers & ~Modifiers.FINAL);
 		output.append("implements ");
 		output.append(implementation.type.accept(typeFormatter));
 
 	@Override
 	public Void visitInnerDefinition(InnerDefinitionMember member) {
+		visit(false);
 		String formatted = member.innerDefinition.accept(new DefinitionFormatter(settings, typeFormatter, indent + settings.indent)).toString();
 		output.append(formatted);
 		return null;

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

  */
 public class StatementFormatter implements StatementVisitor<Void> {
 	private final FormattingSettings settings;
-	private final StringBuilder result;
+	private final StringBuilder output;
 	private final ExpressionFormatter expressionFormatter;
 	
 	private String indent;
 	private ParentStatementType position = ParentStatementType.NONE;
 	
-	public StatementFormatter(String indent, FormattingSettings settings, ExpressionFormatter expressionFormatter) {
+	public StatementFormatter(StringBuilder output, String indent, FormattingSettings settings, ExpressionFormatter expressionFormatter) {
+		this.output = output;
 		this.indent = indent;
 		this.settings = settings;
-		result = new StringBuilder();
 		this.expressionFormatter = expressionFormatter;
 	}
 	
 	@Override
 	public String toString() {
-		return result.toString();
+		return output.toString();
 	}
 
 	@Override
 	public Void visitBreak(BreakStatement statement) {
 		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
 		beginSingleLine(whitespace);
-		result.append("break");
+		output.append("break");
 		if (statement.target.label != null)
-			result.append(' ').append(statement.target.label);
-		result.append(";");
+			output.append(' ').append(statement.target.label);
+		output.append(";");
 		endSingleLine(whitespace);
 		return null;
 	}
 	public Void visitContinue(ContinueStatement statement) {
 		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
 		beginSingleLine(whitespace);
-		result.append("continue");
+		output.append("continue");
 		if (statement.target.label != null)
-			result.append(' ').append(statement.target.label);
-		result.append(";");
+			output.append(' ').append(statement.target.label);
+		output.append(";");
 		endSingleLine(whitespace);
 		return null;
 	}
 	public Void visitDoWhile(DoWhileStatement statement) {
 		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
 		beginSingleLine(whitespace);
-		result.append("do");
+		output.append("do");
 		if (statement.label != null) {
 			if (settings.spaceBeforeLabelColon)
-				result.append(' ');
-			result.append(':');
+				output.append(' ');
+			output.append(':');
 			if (settings.spaceAfterLabelColon)
-				result.append(' ');
-			result.append(statement.label);
+				output.append(' ');
+			output.append(statement.label);
 		}
 		format(ParentStatementType.LOOP, statement.content);
-		result.append(" while ");
+		output.append(" while ");
 		appendCondition(statement.condition);
-		result.append(";");
+		output.append(";");
 		endSingleLine(whitespace);
 		return null;
 	}
 	public Void visitEmpty(EmptyStatement statement) {
 		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
 		beginSingleLine(whitespace);
-		result.append(";\n");
+		output.append(";\n");
 		endSingleLine(whitespace);
 		return null;
 	}
 	public Void visitExpression(ExpressionStatement statement) {
 		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
 		beginSingleLine(whitespace);
-		result.append(statement.expression.accept(expressionFormatter).value)
+		output.append(statement.expression.accept(expressionFormatter).value)
 			  .append(";");
 		endSingleLine(whitespace);
 		return null;
 	public Void visitForeach(ForeachStatement statement) {
 		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
 		beginSingleLine(whitespace);
-		result.append("for ");
+		output.append("for ");
 		for (int i = 0; i < statement.loopVariables.length; i++) {
 			if (i > 0)
-				result.append(", ");
+				output.append(", ");
 			
-			result.append(statement.loopVariables[i].name);
+			output.append(statement.loopVariables[i].name);
 		}
-		result.append(" in ");
-		result.append(statement.list.accept(expressionFormatter).value);
+		output.append(" in ");
+		output.append(statement.list.accept(expressionFormatter).value);
 		format(ParentStatementType.LOOP, statement.content);
 		endSingleLine(whitespace);
 		return null;
 		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
 		ParentStatementType position = this.position;
 		beginSingleLine(whitespace);
-		result.append("if ");
+		output.append("if ");
 		appendCondition(statement.condition);
 		format(statement.onElse == null ? ParentStatementType.IF : ParentStatementType.IF_WITH_ELSE, statement.onThen);
 		if (statement.onElse != null) {
-			result.append("else");
+			output.append("else");
 			format(ParentStatementType.ELSE, statement.onElse);
 		}
 		endSingleLine(whitespace);
 	public Void visitLock(LockStatement statement) {
 		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
 		beginSingleLine(whitespace);
-		result.append("lock ");
-		result.append(statement.object.accept(expressionFormatter).value);
+		output.append("lock ");
+		output.append(statement.object.accept(expressionFormatter).value);
 		statement.content.accept(this);
 		endSingleLine(whitespace);
 		return null;
 	public Void visitReturn(ReturnStatement statement) {
 		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
 		beginSingleLine(whitespace);
-		result.append("return");
+		output.append("return");
 		if (statement.value != null) {
-			result.append(' ');
-			result.append(statement.value.accept(expressionFormatter).value);
+			output.append(' ');
+			output.append(statement.value.accept(expressionFormatter).value);
 		}
-		result.append(";");
+		output.append(";");
 		endSingleLine(whitespace);
 		return null;
 	}
 	public Void visitThrow(ThrowStatement statement) {
 		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
 		beginSingleLine(whitespace);
-		result.append("throw ").append(statement.value.accept(expressionFormatter));
+		output.append("throw ").append(statement.value.accept(expressionFormatter));
 		endSingleLine(whitespace);
 		return null;
 	}
 	public Void visitTryCatch(TryCatchStatement statement) {
 		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
 		beginSingleLine(whitespace);
-		result.append("try");
+		output.append("try");
 		if (statement.resource != null) {
-			result.append(' ').append(statement.resource.name);
-			result.append(" = ");
-			result.append(statement.resource.initializer.accept(expressionFormatter).value);
+			output.append(' ').append(statement.resource.name);
+			output.append(" = ");
+			output.append(statement.resource.initializer.accept(expressionFormatter).value);
 		}
 		
 		format(ParentStatementType.TRY, statement.content);
 		
 		for (CatchClause catchClause : statement.catchClauses) {
-			result.append(indent).append("catch ");
+			output.append(indent).append("catch ");
 			if (catchClause.exceptionName != null)
-				result.append(catchClause.exceptionName);
+				output.append(catchClause.exceptionName);
 			if (catchClause.exceptionType != BasicTypeID.ANY) {
-				result.append(" as ");
+				output.append(" as ");
 				catchClause.exceptionType.accept(expressionFormatter.typeFormatter);
 			}
 			
 			format(ParentStatementType.CATCH, catchClause.content);
 		}
 		if (statement.finallyClause != null) {
-			result.append(indent).append("finally ");
+			output.append(indent).append("finally ");
 			
 			format(ParentStatementType.FINALLY, statement.finallyClause);
 		}
 	public Void visitVar(VarStatement statement) {
 		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
 		beginSingleLine(whitespace);
-		result.append(statement.isFinal ? "val " : "var ");
-		result.append(statement.name);
+		output.append(statement.isFinal ? "val " : "var ");
+		output.append(statement.name);
 		
 		if (statement.initializer == null || statement.initializer.type != statement.type) {
-			result.append(" as ");
-			result.append(statement.type.accept(expressionFormatter.typeFormatter));
+			output.append(" as ");
+			output.append(statement.type.accept(expressionFormatter.typeFormatter));
 		}
 		if (statement.initializer != null) {
-			result.append(" = ");
-			result.append(statement.initializer.accept(expressionFormatter).value);
+			output.append(" = ");
+			output.append(statement.initializer.accept(expressionFormatter).value);
 		}
-		result.append(";");
+		output.append(";");
 		endSingleLine(whitespace);
 		return null;
 	}
 	public Void visitWhile(WhileStatement statement) {
 		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
 		beginSingleLine(whitespace);
-		result.append("while");
+		output.append("while");
 		if (statement.label != null) {
 			if (settings.spaceBeforeLabelColon)
-				result.append(' ');
-			result.append(':');
+				output.append(' ');
+			output.append(':');
 			if (settings.spaceAfterLabelColon)
-				result.append(' ');
-			result.append(statement.label);
+				output.append(' ');
+			output.append(statement.label);
 		}
-		result.append(' ');
+		output.append(' ');
 		appendCondition(statement.condition);
 		
 		format(ParentStatementType.LOOP, statement.content);
 	
 	private void appendCondition(Expression condition) {
 		if (settings.bracketsAroundConditions)
-			result.append('(');
-		result.append(condition.accept(expressionFormatter).value);
+			output.append('(');
+		output.append(condition.accept(expressionFormatter).value);
 		if (settings.bracketsAroundConditions)
-			result.append(')');
+			output.append(')');
 	}
 	
 	private void beginBlock(WhitespaceInfo whitespace) {
-		result.append(settings.getBlockSeparator(indent, position));
+		if (whitespace != null && whitespace.emptyLine) {
+			output.append("\n").append(indent);
+		}
 		
-		if (whitespace != null) {
-			if (whitespace.emptyLine) {
-				result.append("\n").append(indent);
-			}
+		String separator = settings.getBlockSeparator(indent, position);
+		output.append(separator);
+		
+		if (whitespace != null)
 			writeComments(whitespace.commentsBefore);
-		}
 	}
 	
 	private void endBlock(WhitespaceInfo whitespace) {
 		if (whitespace != null && !whitespace.commentsAfter.isEmpty())
-			result.append(' ').append(whitespace.commentsAfter);
+			output.append(' ').append(whitespace.commentsAfter);
 		
-		result.append("\n").append(indent).append("}");
+		output.append("\n").append(indent).append("}");
 		if (position == ParentStatementType.IF_WITH_ELSE) {
 			if (settings.elseBracketOnSameLine)
-				result.append(" ");
+				output.append(" ");
 			else
-				result.append("\n").append(indent);
+				output.append("\n").append(indent);
 		}
 	}
 	
 	private void beginSingleLine(WhitespaceInfo whitespace) {
-		result.append(settings.getSingleLineSeparator(indent, position));
+		String separator = settings.getSingleLineSeparator(indent, position);
+		output.append(separator);
 		
 		if (whitespace != null) {
 			if (whitespace.emptyLine) {
-				result.append("\n").append(indent);
+				output.append("\n").append(indent);
 			}
 			writeComments(whitespace.commentsBefore);
 		}
 	
 	private void endSingleLine(WhitespaceInfo whitespace) {
 		if (whitespace != null && !whitespace.commentsAfter.isEmpty())
-			result.append(' ').append(whitespace.commentsAfter);
+			output.append(' ').append(whitespace.commentsAfter);
 		
 		if (position == ParentStatementType.IF_WITH_ELSE)
-			result.append("\n").append(indent);
+			output.append("\n").append(indent);
 	}
 	
 	private void writeComments(String[] comments) {
 		for (String comment : CommentFormatter.format(comments)) {
-			result.append(comment).append("\n").append(indent);
+			output.append(comment).append("\n").append(indent);
 		}
 	}
 	
 	private void writePostComments(String[] comments) {
 		for (String comment : CommentFormatter.format(comments)) {
-			result.append("\n").append(indent).append(comment);
+			output.append("\n").append(indent).append(comment);
 		}
 	}
 }

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

  * @author Hoofdgebruiker
  */
 public class WhitespaceInfo {
-	public static WhitespaceInfo from(String whitespaceBefore, String lineAfter) {
+	public static WhitespaceInfo from(String whitespaceBefore, String lineAfter, boolean skipLineBefore) {
 		int numNewLines = 0;
 		for (char c : whitespaceBefore.toCharArray())
 			if (c == '\n')
 			commentsBefore.add(trimmed);
 		}
 		
-		boolean emptyLine = numNewLines - commentsBefore.size() > 0;
+		boolean emptyLine = !skipLineBefore && numNewLines - commentsBefore.size() > 0;
 		return new WhitespaceInfo(
 				emptyLine,
 				commentsBefore.toArray(new String[commentsBefore.size()]),

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
  */
 public class CallStaticExpression extends Expression {
 	public final FunctionalMember member;
+	public final ITypeID target;
 	public final CallArguments arguments;
 	
-	public CallStaticExpression(CodePosition position, FunctionalMember member, CallArguments arguments) {
+	public CallStaticExpression(CodePosition position, ITypeID target, FunctionalMember member, CallArguments arguments) {
 		super(position, member.header.returnType);
 		
 		this.member = member;
+		this.target = target;
 		this.arguments = arguments;
 	}
 

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

 	}
 
 	@Override
-	public Expression callStatic(CodePosition position, FunctionHeader instancedHeader, CallArguments arguments) {
+	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments) {
 		throw new UnsupportedOperationException("Cannot be called statically");
 	}
 
 	@Override
-	public Expression callStaticWithComparator(CodePosition position, CompareType operator, FunctionHeader instancedHeader, CallArguments arguments) {
+	public Expression callStaticWithComparator(CodePosition position, ITypeID target, CompareType operator, FunctionHeader instancedHeader, CallArguments arguments) {
 		throw new UnsupportedOperationException("Cannot be called statically");
 	}
 

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

  */
 package org.openzen.zenscript.codemodel.member;
 
-import java.util.List;
 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GenericCompareExpression;
 import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
 	}
 	
 	@Override
-	public Expression callStatic(CodePosition position, FunctionHeader instancedHeader, CallArguments arguments) {
-		return new CallStaticExpression(position, this, arguments);
+	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments) {
+		return new CallStaticExpression(position, target, this, arguments);
 	}
 	
 	@Override
-	public Expression callStaticWithComparator(CodePosition position, CompareType operator, FunctionHeader instancedHeader, CallArguments arguments) {
-		return new GenericCompareExpression(position, callStatic(position, instancedHeader, arguments), operator);
+	public Expression callStaticWithComparator(CodePosition position, ITypeID target, CompareType operator, FunctionHeader instancedHeader, CallArguments arguments) {
+		return new GenericCompareExpression(position, callStatic(position, target, instancedHeader, arguments), operator);
 	}
 }

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
 	
 	public Expression callWithComparator(CodePosition position, CompareType operator, Expression target, FunctionHeader instancedHeader, CallArguments arguments);
 	
-	public Expression callStatic(CodePosition position, FunctionHeader instancedHeader, CallArguments arguments);
+	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments);
 	
-	public Expression callStaticWithComparator(CodePosition position, CompareType operator, FunctionHeader instancedHeader, CallArguments arguments);
+	public Expression callStaticWithComparator(CodePosition position, ITypeID target, CompareType operator, FunctionHeader instancedHeader, CallArguments arguments);
 }

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

 	}
 
 	@Override
-	public Expression callStatic(CodePosition position, FunctionHeader instancedHeader, CallArguments arguments) {
+	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments) {
 		throw new UnsupportedOperationException("Can't call a comparator");
 	}
 
 	@Override
-	public Expression callStaticWithComparator(CodePosition position, CompareType operator, FunctionHeader instancedHeader, CallArguments arguments) {
+	public Expression callStaticWithComparator(CodePosition position, ITypeID target, CompareType operator, FunctionHeader instancedHeader, CallArguments arguments) {
 		throw new UnsupportedOperationException("Can't call a comparator statically");
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialStaticMemberGroupExpression.java

  * @author Hoofdgebruiker
  */
 public class PartialStaticMemberGroupExpression implements IPartialExpression {
-	public static PartialStaticMemberGroupExpression forMethod(CodePosition position, ICallableMember method) {
+	public static PartialStaticMemberGroupExpression forMethod(CodePosition position, ITypeID target, ICallableMember method) {
 		DefinitionMemberGroup group = new DefinitionMemberGroup();
 		group.addMethod(method, TypeMemberPriority.SPECIFIED);
-		return new PartialStaticMemberGroupExpression(position, group);
+		return new PartialStaticMemberGroupExpression(position, target, group);
 	}
 	
 	private final CodePosition position;
+	private final ITypeID target;
 	private final DefinitionMemberGroup group;
 	
-	public PartialStaticMemberGroupExpression(CodePosition position, DefinitionMemberGroup group) {
+	public PartialStaticMemberGroupExpression(CodePosition position, ITypeID target, DefinitionMemberGroup group) {
 		this.position = position;
 		this.group = group;
+		this.target = target;
 	}
 	
 	@Override
 
 	@Override
 	public Expression call(CodePosition position, TypeScope scope, List<ITypeID> hints, CallArguments arguments) {
-		return group.callStatic(position, scope, arguments);
+		return group.callStatic(position, target, scope, arguments);
 	}
 	
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialTypeExpression.java

 
 	@Override
 	public Expression call(CodePosition position, TypeScope scope, List<ITypeID> hints, CallArguments arguments) {
-		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).callStatic(position, scope, arguments);
+		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).callStatic(position, type, scope, arguments);
 	}
 }

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

 		return method.callWithComparator(position, compareType, target, instancedHeader, arguments);
 	}
 	
-	public Expression callStatic(CodePosition position, TypeScope scope, CallArguments arguments) {
+	public Expression callStatic(CodePosition position, ITypeID target, TypeScope scope, CallArguments arguments) {
 		ICallableMember method = selectMethod(position, scope, arguments, false, true);
 		FunctionHeader instancedHeader = method.getHeader().withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
-		return method.callStatic(position, instancedHeader, arguments);
+		return method.callStatic(position, target, instancedHeader, arguments);
 	}
 	
 	public Expression callStaticWithComparator(
 			CodePosition position,
+			ITypeID target, 
 			TypeScope scope,
 			CallArguments arguments,
 			CompareType compareType) {
 		ICallableMember method = selectMethod(position, scope, arguments, false, true);
 		FunctionHeader instancedHeader = method.getHeader().withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
-		return method.callStaticWithComparator(position, compareType, instancedHeader, arguments);
+		return method.callStaticWithComparator(position, target, compareType, instancedHeader, arguments);
 	}
 	
 	public ICallableMember selectMethod(CodePosition position, TypeScope scope, CallArguments arguments, boolean allowNonStatic, boolean allowStatic) {

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

 	
 	public IPartialExpression getStaticMemberExpression(CodePosition position, GenericName name) {
 		if (members.containsKey(name.name))
-			return new PartialStaticMemberGroupExpression(position, members.get(name.name));
+			return new PartialStaticMemberGroupExpression(position, type, members.get(name.name));
 		if (innerTypes.containsKey(name.name))
 			return new PartialTypeExpression(position, innerTypes.get(name.name).instance(cache.getRegistry(), name.arguments));
 		

Parser/src/main/java/org/openzen/zenscript/lexer/ZSTokenStream.java

 	}
 	
 	public WhitespaceInfo collectWhitespaceInfoForBlock(String whitespace) {
-		return WhitespaceInfo.from(whitespace, "");
+		return WhitespaceInfo.from(whitespace, "", false);
 	}
 	
-	public WhitespaceInfo collectWhitespaceInfo(String whitespace) {
-		return WhitespaceInfo.from(whitespace, grabWhitespaceLine());
+	public WhitespaceInfo collectWhitespaceInfo(String whitespace, boolean skipLineBefore) {
+		return WhitespaceInfo.from(whitespace, grabWhitespaceLine(), skipLineBefore);
 	}
 	
 	@Override

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedStatement.java

 	}
 	
 	public static ParsedFunctionBody parseFunctionBody(ZSTokenStream tokens) {
-		ZSToken start = tokens.peek();
-		if (tokens.optional(T_LAMBDA) != null) {
+		if (tokens.optional(T_LAMBDA) != null)
 			return parseLambdaBody(tokens, false);
-		} else if (tokens.optional(T_SEMICOLON) != null) {
+		else if (tokens.optional(T_SEMICOLON) != null)
 			return new ParsedEmptyFunctionBody(tokens.getPosition());
-		} else {
-			tokens.required(T_AOPEN, "{ expected");
-			List<ParsedStatement> statements = new ArrayList<>();
-			while (tokens.optional(T_ACLOSE) == null) {
-				statements.add(ParsedStatement.parse(tokens));
-			}
-			return new ParsedStatementsFunctionBody(new ParsedStatementBlock(start.position, null, null, statements));
+		else
+			return new ParsedStatementsFunctionBody(parseBlock(tokens, true));
+	}
+	
+	public static ParsedStatementBlock parseBlock(ZSTokenStream parser, boolean isFirst) {
+		String ws = parser.grabWhitespace();
+		ZSToken t = parser.required(T_AOPEN, "{ expected");
+
+		parser.reloadWhitespace();
+		parser.skipWhitespaceNewline();
+
+		ArrayList<ParsedStatement> statements = new ArrayList<>();
+		ZSToken last;
+		boolean firstContent = true;
+		while ((last = parser.optional(T_ACLOSE)) == null) {
+			statements.add(parse(parser, firstContent));
+			firstContent = false;
 		}
+
+		WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws, isFirst);
+		WhitespacePostComment postComment = WhitespacePostComment.fromWhitespace(last.whitespaceBefore);
+		return new ParsedStatementBlock(t.getPosition(), whitespace, postComment, statements);
 	}
 	
 	public static ParsedStatement parse(ZSTokenStream parser) {
+		return parse(parser, false);
+	}
+	
+	public static ParsedStatement parse(ZSTokenStream parser, boolean isFirst) {
 		String ws = parser.grabWhitespace();
 		ZSToken next = parser.peek();
 		switch (next.getType()) {
-			case T_AOPEN: {
-				ZSToken t = parser.next();
-				
-				parser.reloadWhitespace();
-				parser.skipWhitespaceNewline();
-				
-				ArrayList<ParsedStatement> statements = new ArrayList<>();
-				ZSToken last;
-				while ((last = parser.optional(T_ACLOSE)) == null) {
-					statements.add(parse(parser));
-				}
-				
-				parser.reloadWhitespace();
-				WhitespaceInfo whitespace = parser.collectWhitespaceInfoForBlock(ws);
-				WhitespacePostComment postComment = WhitespacePostComment.fromWhitespace(last.whitespaceBefore);
-				return new ParsedStatementBlock(t.getPosition(), whitespace, postComment, statements);
-			}
+			case T_AOPEN:
+				return parseBlock(parser, isFirst);
+			
 			case K_RETURN: {
 				parser.next();
 				ParsedExpression expression = null;
 				}
 				parser.required(T_SEMICOLON, "; expected");
 				
-				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws, isFirst);
 				return new ParsedStatementReturn(next.getPosition(), whitespace, expression);
 			}
 			case K_VAR:
 				}
 				parser.required(T_SEMICOLON, "; expected");
 				
-				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws, isFirst);
 				return new ParsedStatementVar(start.getPosition(), whitespace, name, type, initializer, start.getType() == K_VAL);
 			}
 			case K_IF: {
 					onElse = parse(parser);
 				}
 				
-				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws, isFirst);
 				return new ParsedStatementIf(t.getPosition(), whitespace, expression, onIf, onElse);
 			}
 			case K_FOR: {
 				ParsedExpression source = ParsedExpression.parse(parser);
 				ParsedStatement content = parse(parser);
 				
-				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws, isFirst);
 				return new ParsedStatementForeach(
 						t.getPosition(),
 						whitespace,
 				ParsedExpression condition = ParsedExpression.parse(parser);
 				parser.required(T_SEMICOLON, "; expected");
 				
-				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws, isFirst);
 				return new ParsedStatementDoWhile(t.position, whitespace, label, content, condition);
 			}
 			case K_WHILE: {
 				ParsedExpression condition = ParsedExpression.parse(parser);
 				ParsedStatement content = parse(parser);
 				
-				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws, isFirst);
 				return new ParsedStatementWhile(t.position, whitespace, label, condition, content);
 			}
 			case K_LOCK: {
 				ParsedExpression object = ParsedExpression.parse(parser);
 				ParsedStatement content = parse(parser);
 				
-				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws, isFirst);
 				return new ParsedStatementLock(t.position, whitespace, object, content);
 			}
 			case K_THROW: {
 				ParsedExpression value = ParsedExpression.parse(parser);
 				parser.required(T_SEMICOLON, "; expected");
 				
-				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws, isFirst);
 				return new ParsedStatementThrow(t.position, whitespace, value);
 			}
 			case K_TRY: {
 				if (parser.optional(K_FINALLY) != null)
 					finallyClause = ParsedStatement.parse(parser);
 				
-				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws, isFirst);
 				return new ParsedStatementTryCatch(t.position, whitespace, name, initializer, content, catchClauses, finallyClause);
 			}
 			case K_CONTINUE: {
 				
 				parser.required(T_SEMICOLON, "; expected");
 				
-				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws, isFirst);
 				return new ParsedStatementContinue(t.position, whitespace, name);
 			}
 			case K_BREAK: {
 				
 				parser.required(T_SEMICOLON, "; expected");
 				
-				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws, isFirst);
 				return new ParsedStatementBreak(t.position, whitespace, name);
 			}
 		}
 		CodePosition position = parser.peek().getPosition();
 		ParsedExpression expression = ParsedExpression.parse(parser);
 		parser.required(T_SEMICOLON, "; expected");
-		WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+		WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws, isFirst);
 		
 		ParsedStatementExpression result = new ParsedStatementExpression(position, whitespace, expression);
 		return result;