- Statements can now also store comments before and after them

- Added comment & partial whitespace preservation to the file formatter

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/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.formatter;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class CommentFormatter {
+	private CommentFormatter() {}
+	
+	public static String[] format(String[] comments) {
+		if (comments.length == 0)
+			return comments;
+		
+		boolean isInMultilineComment = false;
+		String[] result = new String[comments.length];
+		for (int i = 0; i < comments.length; i++) {
+			String comment = comments[i];
+			if (isInMultilineComment) {
+				if (!comment.startsWith("*"))
+					comment = "* " + comment;
+				comment = " " + comment;
+			}
+			
+			result[i] = comment;
+			
+			int index = 0;
+			while (true) {
+				if (!isInMultilineComment && comment.indexOf("//", index) > 0)
+					break;
+				
+				int newIndexOpen = comment.indexOf("/*", index);
+				if (newIndexOpen >= 0) {
+					isInMultilineComment = true;
+					index = newIndexOpen;
+				} else {
+					break;
+				}
+				
+				int newIndexClose = comment.indexOf("*/", newIndexOpen);
+				if (newIndexClose >= 0) {
+					isInMultilineComment = false;
+					index = newIndexClose;
+				} else {
+					break;
+				}
+			}
+		}
+		
+		return result;
+	}
+}

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

 import java.util.Map;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.WhitespacePostComment;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.statement.Statement;
 
 		StringBuilder output = new StringBuilder();
 		importer.write(output);
 		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);
+			}
+		}
+		
 		return output.toString();
 	}
 	

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

  */
 package org.openzen.zenscript.formatter;
 
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
+import org.openzen.zenscript.codemodel.WhitespacePostComment;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.statement.BlockStatement;
 import org.openzen.zenscript.codemodel.statement.BreakStatement;
 
 	@Override
 	public Void visitBlock(BlockStatement statement) {
-		beginBlock();
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginBlock(whitespace);
 		
 		String oldIndent = indent;
 		indent = oldIndent + settings.indent;
 		for (Statement subStatement : statement.statements) {
 			format(ParentStatementType.NONE, subStatement);
 		}
+		
+		WhitespacePostComment postComment = statement.getTag(WhitespacePostComment.class);
+		if (postComment != null) {
+			writePostComments(postComment.comments);
+		}
+		
 		indent = oldIndent;
-		endBlock();
+		
+		endBlock(whitespace);
 		return null;
 	}
 
 	@Override
 	public Void visitBreak(BreakStatement statement) {
-		beginSingleLine();
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
 		result.append("break");
-		if (statement.target != null)
+		if (statement.target.label != null)
 			result.append(' ').append(statement.target.label);
 		result.append(";");
-		endSingleLine();
+		endSingleLine(whitespace);
 		return null;
 	}
 
 	@Override
 	public Void visitContinue(ContinueStatement statement) {
-		beginSingleLine();
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
 		result.append("continue");
-		if (statement.target != null)
+		if (statement.target.label != null)
 			result.append(' ').append(statement.target.label);
 		result.append(";");
-		endSingleLine();
+		endSingleLine(whitespace);
 		return null;
 	}
 
 	@Override
 	public Void visitDoWhile(DoWhileStatement statement) {
-		beginSingleLine();
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
 		result.append("do");
 		if (statement.label != null) {
 			if (settings.spaceBeforeLabelColon)
 		result.append(" while ");
 		appendCondition(statement.condition);
 		result.append(";");
-		endSingleLine();
+		endSingleLine(whitespace);
 		return null;
 	}
 
 	@Override
 	public Void visitEmpty(EmptyStatement statement) {
-		beginSingleLine();
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
 		result.append(";\n");
-		endSingleLine();
+		endSingleLine(whitespace);
 		return null;
 	}
 
 	@Override
 	public Void visitExpression(ExpressionStatement statement) {
-		beginSingleLine();
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
 		result.append(statement.expression.accept(expressionFormatter).value)
 			  .append(";");
-		endSingleLine();
+		endSingleLine(whitespace);
 		return null;
 	}
 
 	@Override
 	public Void visitForeach(ForeachStatement statement) {
-		beginSingleLine();
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
 		result.append("for ");
 		for (int i = 0; i < statement.loopVariables.length; i++) {
 			if (i > 0)
 		result.append(" in ");
 		result.append(statement.list.accept(expressionFormatter).value);
 		format(ParentStatementType.LOOP, statement.content);
-		endSingleLine();
+		endSingleLine(whitespace);
 		return null;
 	}
 
 	@Override
 	public Void visitIf(IfStatement statement) {
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
 		ParentStatementType position = this.position;
-		beginSingleLine();
+		beginSingleLine(whitespace);
 		result.append("if ");
 		appendCondition(statement.condition);
 		format(statement.onElse == null ? ParentStatementType.IF : ParentStatementType.IF_WITH_ELSE, statement.onThen);
 			result.append("else");
 			format(ParentStatementType.ELSE, statement.onElse);
 		}
-		endSingleLine();
+		endSingleLine(whitespace);
 		return null;
 	}
 
 	@Override
 	public Void visitLock(LockStatement statement) {
-		beginSingleLine();
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
 		result.append("lock ");
 		result.append(statement.object.accept(expressionFormatter).value);
 		statement.content.accept(this);
-		endSingleLine();
+		endSingleLine(whitespace);
 		return null;
 	}
 
 	@Override
 	public Void visitReturn(ReturnStatement statement) {
-		beginSingleLine();
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
 		result.append("return");
 		if (statement.value != null) {
 			result.append(' ');
 			result.append(statement.value.accept(expressionFormatter).value);
 		}
 		result.append(";");
-		endSingleLine();
+		endSingleLine(whitespace);
 		return null;
 	}
 
 	@Override
 	public Void visitThrow(ThrowStatement statement) {
-		beginSingleLine();
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
 		result.append("throw ").append(statement.value.accept(expressionFormatter));
-		endSingleLine();
+		endSingleLine(whitespace);
 		return null;
 	}
 
 	@Override
 	public Void visitTryCatch(TryCatchStatement statement) {
-		beginSingleLine();
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
 		result.append("try");
 		if (statement.resource != null) {
 			result.append(' ').append(statement.resource.name);
 			
 			format(ParentStatementType.FINALLY, statement.finallyClause);
 		}
-		endSingleLine();
+		endSingleLine(whitespace);
 		return null;
 	}
 
 	@Override
 	public Void visitVar(VarStatement statement) {
-		beginSingleLine();
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
 		result.append(statement.isFinal ? "val " : "var ");
 		result.append(statement.name);
 		
 			result.append(statement.initializer.accept(expressionFormatter).value);
 		}
 		result.append(";");
-		endSingleLine();
+		endSingleLine(whitespace);
 		return null;
 	}
 
 	@Override
 	public Void visitWhile(WhileStatement statement) {
-		beginSingleLine();
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
 		result.append("while");
 		if (statement.label != null) {
 			if (settings.spaceBeforeLabelColon)
 		appendCondition(statement.condition);
 		
 		format(ParentStatementType.LOOP, statement.content);
-		endSingleLine();
+		endSingleLine(whitespace);
 		return null;
 	}
 	
 			result.append(')');
 	}
 	
-	private void beginBlock() {
+	private void beginBlock(WhitespaceInfo whitespace) {
 		result.append(settings.getBlockSeparator(indent, position));
+		
+		if (whitespace != null) {
+			if (whitespace.emptyLine) {
+				result.append("\n").append(indent);
+			}
+			writeComments(whitespace.commentsBefore);
+		}
 	}
 	
-	private void endBlock() {
+	private void endBlock(WhitespaceInfo whitespace) {
+		if (whitespace != null && !whitespace.commentsAfter.isEmpty())
+			result.append(' ').append(whitespace.commentsAfter);
+		
 		result.append("\n").append(indent).append("}");
 		if (position == ParentStatementType.IF_WITH_ELSE) {
 			if (settings.elseBracketOnSameLine)
 		}
 	}
 	
-	private void beginSingleLine() {
+	private void beginSingleLine(WhitespaceInfo whitespace) {
 		result.append(settings.getSingleLineSeparator(indent, position));
+		
+		if (whitespace != null) {
+			if (whitespace.emptyLine) {
+				result.append("\n").append(indent);
+			}
+			writeComments(whitespace.commentsBefore);
+		}
 	}
 	
-	private void endSingleLine() {
+	private void endSingleLine(WhitespaceInfo whitespace) {
+		if (whitespace != null && !whitespace.commentsAfter.isEmpty())
+			result.append(' ').append(whitespace.commentsAfter);
+		
 		if (position == ParentStatementType.IF_WITH_ELSE)
 			result.append("\n").append(indent);
 	}
+	
+	private void writeComments(String[] comments) {
+		for (String comment : CommentFormatter.format(comments)) {
+			result.append(comment).append("\n").append(indent);
+		}
+	}
+	
+	private void writePostComments(String[] comments) {
+		for (String comment : CommentFormatter.format(comments)) {
+			result.append("\n").append(indent).append(comment);
+		}
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/WhitespaceInfo.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;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.zenscript.shared.StringUtils;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class WhitespaceInfo {
+	public static WhitespaceInfo from(String whitespaceBefore, String lineAfter) {
+		int numNewLines = 0;
+		for (char c : whitespaceBefore.toCharArray())
+			if (c == '\n')
+				numNewLines++;
+		
+		List<String> split = StringUtils.split(whitespaceBefore, '\n');
+		List<String> commentsBefore = new ArrayList<>();
+		for (String splitLine : split) {
+			String trimmed = splitLine.trim();
+			if (trimmed.isEmpty())
+				continue;
+			
+			commentsBefore.add(trimmed);
+		}
+		
+		boolean emptyLine = numNewLines - commentsBefore.size() > 0;
+		return new WhitespaceInfo(
+				emptyLine,
+				commentsBefore.toArray(new String[commentsBefore.size()]),
+				lineAfter.trim());
+	}
+	
+	public boolean emptyLine;
+	public String[] commentsBefore;
+	public String commentsAfter;
+	
+	public WhitespaceInfo(boolean emptyLine, String[] commentsBefore, String commentsAfter) {
+		this.emptyLine = emptyLine;
+		this.commentsBefore = commentsBefore;
+		this.commentsAfter = commentsAfter;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/WhitespacePostComment.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;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.zenscript.shared.StringUtils;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class WhitespacePostComment {
+	public static WhitespacePostComment fromWhitespace(String whitespace) {
+		List<String> comments = new ArrayList<>();
+		for (String line : StringUtils.split(whitespace, '\n')) {
+			line = line.trim();
+			if (line.isEmpty())
+				continue;
+			
+			comments.add(line);
+		}
+		
+		if (comments.isEmpty())
+			return null;
+		
+		return new WhitespacePostComment(comments.toArray(new String[comments.size()]));
+	}
+	
+	public final String[] comments;
+	
+	public WhitespacePostComment(String[] comments) {
+		this.comments = comments;
+	}
+}

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

 					line,
 					lineOffset);
 			
-            next = createToken(position, "", "", eof);
+            next = createToken(position, whitespace, "", eof);
             return;
         }
 		

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

 import java.io.Reader;
 import java.util.HashMap;
 import java.util.Map;
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.shared.CompileException;
 import org.openzen.zenscript.shared.CompileExceptionCode;
 import static org.openzen.zenscript.lexer.ZSTokenType.*;
 		KEYWORDS.put("new", K_NEW);
 	}
 	
+	private String whitespaceBuffer = null;
+	
 	public ZSTokenStream(String filename, Reader reader) {
 		super(filename, reader, DFA, ZSTokenType.EOF);
 	}
 	
+	public String loadWhitespace() {
+		if (whitespaceBuffer == null)
+			whitespaceBuffer = peek().whitespaceBefore;
+		
+		return whitespaceBuffer;
+	}
+	
+	public void reloadWhitespace() {
+		whitespaceBuffer = peek().whitespaceBefore;
+	}
+	
+	public String grabWhitespace() {
+		String result = loadWhitespace();
+		whitespaceBuffer = null;
+		return result;
+	}
+	
+	public String grabWhitespaceLine() {
+		String whitespace = loadWhitespace();
+		if (whitespace.contains("\n")) {
+			int index = whitespace.indexOf('\n');
+			whitespaceBuffer = whitespace.substring(index + 1);
+			return whitespace.substring(0, index);
+		} else {
+			whitespaceBuffer = "";
+			return whitespace;
+		}
+	}
+	
+	public void skipWhitespaceNewline() {
+		loadWhitespace();
+		int index = whitespaceBuffer.indexOf('\n');
+		if (index >= 0)
+			whitespaceBuffer = whitespaceBuffer.substring(index + 1);
+	}
+	
+	public WhitespaceInfo collectWhitespaceInfoForBlock(String whitespace) {
+		return WhitespaceInfo.from(whitespace, "");
+	}
+	
+	public WhitespaceInfo collectWhitespaceInfo(String whitespace) {
+		return WhitespaceInfo.from(whitespace, grabWhitespaceLine());
+	}
+	
 	@Override
 	protected ZSToken createToken(CodePosition position, String whitespaceBefore, String value, ZSTokenType tokenType) {
 		if (tokenType == T_IDENTIFIER && KEYWORDS.containsKey(value))

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

 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.PackageDefinitions;
 import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.WhitespacePostComment;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.lexer.ZSToken;
 import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.shared.CompileException;
 import org.openzen.zenscript.shared.CompileExceptionCode;
 		ParsedFile result = new ParsedFile(filename);
 		
 		ZSTokenStream tokens = new ZSTokenStream(filename, reader);
+		ZSToken eof = null;
 
 		while (true) {
 			CodePosition position = tokens.peek().position;
 
 			if (tokens.optional(K_IMPORT) != null) {
 				result.imports.add(ParsedImport.parse(position, tokens));
-			} else if (tokens.optional(EOF) != null) {
+			} else if ((eof = tokens.optional(EOF)) != null) {
 				break;
 			} else {
 				ParsedDefinition definition = ParsedDefinition.parse(pkg, position, modifiers, tokens, null);
 			}
 		}
 		
+		result.postComment = WhitespacePostComment.fromWhitespace(eof.whitespaceBefore);
 		return result;
 	}
 	
 	private final List<ParsedDefinition> definitions = new ArrayList<>();
 	private final List<ParsedStatement> statements = new ArrayList<>();
 	private final AccessScope access = new AccessScope();
+	private WhitespacePostComment postComment = null;
 	
 	public ParsedFile(String filename) {
 		this.filename = filename;
 			definition.compileCode(scope);
 		}
 		
-		if (!statements.isEmpty()) {
+		if (!statements.isEmpty() || postComment != null) {
 			StatementScope statementScope = new GlobalScriptScope(scope);
 			List<Statement> statements = new ArrayList<>();
 			for (ParsedStatement statement : this.statements) {
 			
 			ScriptBlock block = new ScriptBlock(statements);
 			block.setTag(SourceFile.class, new SourceFile(filename));
+			block.setTag(WhitespacePostComment.class, postComment);
 			scripts.add(block);
 		}
 	}

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

 
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
+import org.openzen.zenscript.codemodel.WhitespacePostComment;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.lexer.ZSToken;
 import org.openzen.zenscript.lexer.ZSTokenStream;
 	}
 	
 	public static ParsedStatement parse(ZSTokenStream parser) {
+		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<>();
-				while (parser.optional(T_ACLOSE) == null) {
+				ZSToken last;
+				while ((last = parser.optional(T_ACLOSE)) == null) {
 					statements.add(parse(parser));
 				}
-				return new ParsedStatementBlock(t.getPosition(), statements);
+				
+				parser.reloadWhitespace();
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfoForBlock(ws);
+				WhitespacePostComment postComment = WhitespacePostComment.fromWhitespace(last.whitespaceBefore);
+				return new ParsedStatementBlock(t.getPosition(), whitespace, postComment, statements);
 			}
 			case K_RETURN: {
 				parser.next();
 					expression = ParsedExpression.parse(parser);
 				}
 				parser.required(T_SEMICOLON, "; expected");
-				return new ParsedStatementReturn(next.getPosition(), expression);
+				
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				return new ParsedStatementReturn(next.getPosition(), whitespace, expression);
 			}
 			case K_VAR:
 			case K_VAL: {
 					initializer = ParsedExpression.parse(parser);
 				}
 				parser.required(T_SEMICOLON, "; expected");
-				return new ParsedStatementVar(start.getPosition(), name, type, initializer, start.getType() == K_VAL);
+				
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				return new ParsedStatementVar(start.getPosition(), whitespace, name, type, initializer, start.getType() == K_VAL);
 			}
 			case K_IF: {
 				ZSToken t = parser.next();
 				ParsedExpression expression = ParsedExpression.parse(parser);
+				parser.skipWhitespaceNewline();
 				ParsedStatement onIf = parse(parser);
 				ParsedStatement onElse = null;
 				if (parser.optional(K_ELSE) != null) {
+					parser.reloadWhitespace();
+					parser.skipWhitespaceNewline();
 					onElse = parse(parser);
 				}
-				return new ParsedStatementIf(t.getPosition(), expression, onIf, onElse);
+				
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				return new ParsedStatementIf(t.getPosition(), whitespace, expression, onIf, onElse);
 			}
 			case K_FOR: {
 				ZSToken t = parser.next();
 				parser.required(K_IN, "in expected");
 				ParsedExpression source = ParsedExpression.parse(parser);
 				ParsedStatement content = parse(parser);
+				
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
 				return new ParsedStatementForeach(
 						t.getPosition(),
+						whitespace,
 						names.toArray(new String[names.size()]),
 						source,
 						content);
 				parser.required(K_WHILE, "while expected");
 				ParsedExpression condition = ParsedExpression.parse(parser);
 				parser.required(T_SEMICOLON, "; expected");
-				return new ParsedStatementDoWhile(t.position, label, content, condition);
+				
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				return new ParsedStatementDoWhile(t.position, whitespace, label, content, condition);
 			}
 			case K_WHILE: {
 				ZSToken t = parser.next();
 				
 				ParsedExpression condition = ParsedExpression.parse(parser);
 				ParsedStatement content = parse(parser);
-				return new ParsedStatementWhile(t.position, label, condition, content);
+				
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				return new ParsedStatementWhile(t.position, whitespace, label, condition, content);
 			}
 			case K_LOCK: {
 				ZSToken t = parser.next();
 				ParsedExpression object = ParsedExpression.parse(parser);
 				ParsedStatement content = parse(parser);
-				return new ParsedStatementLock(t.position, object, content);
+				
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				return new ParsedStatementLock(t.position, whitespace, object, content);
 			}
 			case K_THROW: {
 				ZSToken t = parser.next();
 				ParsedExpression value = ParsedExpression.parse(parser);
 				parser.required(T_SEMICOLON, "; expected");
-				return new ParsedStatementThrow(t.position, value);
+				
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				return new ParsedStatementThrow(t.position, whitespace, value);
 			}
 			case K_TRY: {
 				ZSToken t = parser.next();
 				if (parser.optional(K_FINALLY) != null)
 					finallyClause = ParsedStatement.parse(parser);
 				
-				return new ParsedStatementTryCatch(t.position, name, initializer, content, catchClauses, finallyClause);
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				return new ParsedStatementTryCatch(t.position, whitespace, name, initializer, content, catchClauses, finallyClause);
 			}
 			case K_CONTINUE: {
 				ZSToken t = parser.next();
 					name = parser.next().content;
 				
 				parser.required(T_SEMICOLON, "; expected");
-				return new ParsedStatementContinue(t.position, name);
+				
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				return new ParsedStatementContinue(t.position, whitespace, name);
 			}
 			case K_BREAK: {
 				ZSToken t = parser.next();
 					name = parser.next().content;
 				
 				parser.required(T_SEMICOLON, "; expected");
-				return new ParsedStatementBreak(t.position, name);
+				
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+				return new ParsedStatementBreak(t.position, whitespace, name);
 			}
 		}
 
 		CodePosition position = parser.peek().getPosition();
-		ParsedStatementExpression result = new ParsedStatementExpression(position, ParsedExpression.parse(parser));
+		ParsedExpression expression = ParsedExpression.parse(parser);
 		parser.required(T_SEMICOLON, "; expected");
+		WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws);
+		
+		ParsedStatementExpression result = new ParsedStatementExpression(position, whitespace, expression);
 		return result;
 	}
 	
 	}
 
 	public final CodePosition position;
+	public final WhitespaceInfo whitespace;
 
-	public ParsedStatement(CodePosition position) {
+	public ParsedStatement(CodePosition position, WhitespaceInfo whitespace) {
 		this.position = position;
+		this.whitespace = whitespace;
 	}
 
 	public abstract Statement compile(StatementScope scope);
+	
+	protected Statement result(Statement statement) {
+		statement.setTag(WhitespaceInfo.class, whitespace);
+		return statement;
+	}
 }

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

 
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
+import org.openzen.zenscript.codemodel.WhitespacePostComment;
 import org.openzen.zenscript.codemodel.statement.BlockStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.linker.BlockScope;
 
 public class ParsedStatementBlock extends ParsedStatement {
 	private final List<ParsedStatement> statements;
-
-	public ParsedStatementBlock(CodePosition position, List<ParsedStatement> statements) {
-		super(position);
+	private final WhitespacePostComment postComment;
+	
+	public ParsedStatementBlock(CodePosition position, WhitespaceInfo whitespace, WhitespacePostComment postComment, List<ParsedStatement> statements) {
+		super(position, whitespace);
 
 		this.statements = statements;
+		this.postComment = postComment;
 	}
 
 	@Override
 		for (ParsedStatement statement : statements) {
 			compiled.add(statement.compile(blockScope));
 		}
-		return new BlockStatement(position, compiled);
+		BlockStatement block = new BlockStatement(position, compiled);
+		result(block);
+		block.setTag(WhitespacePostComment.class, postComment);
+		return block;
 	}
 }

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

  */
 package org.openzen.zenscript.parser.statements;
 
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.statement.BreakStatement;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 public class ParsedStatementBreak extends ParsedStatement {
 	public final String name;
 	
-	public ParsedStatementBreak(CodePosition position, String name) {
-		super(position);
+	public ParsedStatementBreak(CodePosition position, WhitespaceInfo whitespace, String name) {
+		super(position, whitespace);
 		
 		this.name = name;
 	}
 		LoopStatement target = scope.getLoop(name);
 		if (target == null)
 			throw new CompileException(position, CompileExceptionCode.BREAK_OUTSIDE_LOOP, name == null ? "Not in a loop" : "No such loop: " + name);
-		return new BreakStatement(position, target);
+		return result(new BreakStatement(position, target));
 	}
 }

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

  */
 package org.openzen.zenscript.parser.statements;
 
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.statement.ContinueStatement;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 public class ParsedStatementContinue extends ParsedStatement {
 	public final String name;
 	
-	public ParsedStatementContinue(CodePosition position, String name) {
-		super(position);
+	public ParsedStatementContinue(CodePosition position, WhitespaceInfo whitespace, String name) {
+		super(position, whitespace);
 		
 		this.name = name;
 	}
 		LoopStatement target = scope.getLoop(name);
 		if (target == null)
 			throw new CompileException(position, CompileExceptionCode.CONTINUE_OUTSIDE_LOOP, name == null ? "Not in a loop" : "No such loop: " + name);
-		return new ContinueStatement(position, target);
+		return result(new ContinueStatement(position, target));
 	}
 }

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

  */
 package org.openzen.zenscript.parser.statements;
 
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.statement.DoWhileStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 	public final ParsedStatement content;
 	public final ParsedExpression condition;
 	
-	public ParsedStatementDoWhile(CodePosition position, String label, ParsedStatement content, ParsedExpression condition) {
-		super(position);
+	public ParsedStatementDoWhile(CodePosition position, WhitespaceInfo whitespace, String label, ParsedStatement content, ParsedExpression condition) {
+		super(position, whitespace);
 		
 		this.label = label;
 		this.content = content;
 		DoWhileStatement result = new DoWhileStatement(position, label, condition);
 		LoopScope innerScope = new LoopScope(result, scope);
 		result.content = this.content.compile(innerScope);
-		return result;
+		return result(result);
 	}
 }

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

 package org.openzen.zenscript.parser.statements;
 
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.linker.ExpressionScope;
 public class ParsedStatementExpression extends ParsedStatement {
 	private final ParsedExpression expression;
 
-	public ParsedStatementExpression(CodePosition position, ParsedExpression expression) {
-		super(position);
+	public ParsedStatementExpression(CodePosition position, WhitespaceInfo whitespace, ParsedExpression expression) {
+		super(position, whitespace);
 
 		this.expression = expression;
 	}
 
 	@Override
 	public Statement compile(StatementScope scope) {
-		return new ExpressionStatement(position, this.expression.compile(new ExpressionScope(scope)).eval());
+		return result(new ExpressionStatement(position, this.expression.compile(new ExpressionScope(scope)).eval()));
 	}
 }

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

 package org.openzen.zenscript.parser.statements;
 
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.IIteratorMember;
 import org.openzen.zenscript.codemodel.statement.ForeachStatement;
 	private final ParsedExpression list;
 	private final ParsedStatement body;
 
-	public ParsedStatementForeach(CodePosition position, String[] varnames, ParsedExpression list, ParsedStatement body) {
-		super(position);
+	public ParsedStatementForeach(CodePosition position, WhitespaceInfo whitespace, String[] varnames, ParsedExpression list, ParsedStatement body) {
+		super(position, whitespace);
 
 		this.varnames = varnames;
 		this.list = list;
 		ForeachStatement statement = new ForeachStatement(position, variables, iterator, list);
 		ForeachScope innerScope = new ForeachScope(statement, scope);
 		statement.content = this.body.compile(innerScope);
-		return statement;
+		return result(statement);
 	}
 }

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

 package org.openzen.zenscript.parser.statements;
 
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.statement.IfStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 	private final ParsedStatement onThen;
 	private final ParsedStatement onElse;
 
-	public ParsedStatementIf(CodePosition position, ParsedExpression condition, ParsedStatement onThen, ParsedStatement onElse) {
-		super(position);
+	public ParsedStatementIf(CodePosition position, WhitespaceInfo whitespace, ParsedExpression condition, ParsedStatement onThen, ParsedStatement onElse) {
+		super(position, whitespace);
 
 		this.condition = condition;
 		this.onThen = onThen;
 		Expression condition = this.condition.compile(new ExpressionScope(scope, BasicTypeID.HINT_BOOL)).eval();
 		Statement onThen = this.onThen.compile(scope);
 		Statement onElse = this.onElse == null ? null : this.onElse.compile(scope);
-		return new IfStatement(position, condition, onThen, onElse);
+		return result(new IfStatement(position, condition, onThen, onElse));
 	}
 }

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

  */
 package org.openzen.zenscript.parser.statements;
 
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.statement.LockStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 	public final ParsedExpression object;
 	public final ParsedStatement content;
 	
-	public ParsedStatementLock(CodePosition position, ParsedExpression object, ParsedStatement content) {
-		super(position);
+	public ParsedStatementLock(CodePosition position, WhitespaceInfo whitespace, ParsedExpression object, ParsedStatement content) {
+		super(position, whitespace);
 		
 		this.object = object;
 		this.content = content;
 	public Statement compile(StatementScope scope) {
 		Expression object = this.object.compile(new ExpressionScope(scope)).eval();
 		Statement content = this.content.compile(scope);
-		return new LockStatement(position, object, content);
+		return result(new LockStatement(position, object, content));
 	}
 }

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

 
 package org.openzen.zenscript.parser.statements;
 
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.statement.EmptyStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.linker.StatementScope;
-import org.openzen.zenscript.parser.statements.ParsedStatement;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
  * @author Stanneke
  */
 public class ParsedStatementNull extends ParsedStatement {
-	public ParsedStatementNull(CodePosition position) {
-		super(position);
+	public ParsedStatementNull(CodePosition position, WhitespaceInfo whitespace) {
+		super(position, whitespace);
 	}
 
 	@Override
 	public Statement compile(StatementScope scope) {
-		return new EmptyStatement(position);
+		return result(new EmptyStatement(position));
 	}
 }

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

 package org.openzen.zenscript.parser.statements;
 
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 public class ParsedStatementReturn extends ParsedStatement {
 	private final ParsedExpression expression;
 
-	public ParsedStatementReturn(CodePosition position, ParsedExpression expression) {
-		super(position);
+	public ParsedStatementReturn(CodePosition position, WhitespaceInfo whitespace, ParsedExpression expression) {
+		super(position, whitespace);
 		
 		this.expression = expression;
 	}
 					.compile(new ExpressionScope(scope, scope.getFunctionHeader().returnType))
 					.eval()
 					.castImplicit(position, scope, scope.getFunctionHeader().returnType);
-			return new ReturnStatement(position, value);
+			return result(new ReturnStatement(position, value));
 		}
 	}
 }

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

  */
 package org.openzen.zenscript.parser.statements;
 
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.ThrowStatement;
 import org.openzen.zenscript.linker.ExpressionScope;
 public class ParsedStatementThrow extends ParsedStatement {
 	private final ParsedExpression expression;
 	
-	public ParsedStatementThrow(CodePosition position, ParsedExpression expression) {
-		super(position);
+	public ParsedStatementThrow(CodePosition position, WhitespaceInfo whitespace, ParsedExpression expression) {
+		super(position, whitespace);
 		
 		this.expression = expression;
 	}
 
 	@Override
 	public Statement compile(StatementScope scope) {
-		return new ThrowStatement(position, expression.compile(new ExpressionScope(scope)).eval());
+		return result(new ThrowStatement(position, expression.compile(new ExpressionScope(scope)).eval()));
 	}
 }

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

 
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.statement.CatchClause;
 import org.openzen.zenscript.codemodel.statement.Statement;
 	
 	public ParsedStatementTryCatch(
 			CodePosition position,
+			WhitespaceInfo whitespace,
 			String resourceName,
 			ParsedExpression resourceInitializer,
 			ParsedStatement statement,
 			List<ParsedCatchClause> catchClauses,
 			ParsedStatement finallyClause) {
-		super(position);
+		super(position, whitespace);
 		
 		this.resourceName = resourceName;
 		this.resourceInitializer = resourceInitializer;
 		if (resourceName != null) {
 			resource = new VarStatement(position, resourceName, resourceInitializer.type, resourceInitializer, true);
 		}
-		return new TryCatchStatement(position, resource, statement, catches, finallyClause);
+		return result(new TryCatchStatement(position, resource, statement, catches, finallyClause));
 	}
 }

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

 
 package org.openzen.zenscript.parser.statements;
 
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 	private final ParsedExpression initializer;
 	private final boolean isFinal;
 
-	public ParsedStatementVar(CodePosition position, String name, IParsedType type, ParsedExpression initializer, boolean isFinal) {
-		super(position);
+	public ParsedStatementVar(CodePosition position, WhitespaceInfo whitespace, String name, IParsedType type, ParsedExpression initializer, boolean isFinal) {
+		super(position, whitespace);
 
 		this.name = name;
 		this.type = type;
 		}
 		VarStatement result = new VarStatement(position, name, type, initializer, isFinal);
 		scope.defineVariable(result);
-		return result;
+		return result(result);
 	}
 }

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

  */
 package org.openzen.zenscript.parser.statements;
 
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.WhileStatement;
 	public final ParsedStatement content;
 	public final String label;
 	
-	public ParsedStatementWhile(CodePosition position, String label, ParsedExpression condition, ParsedStatement content) {
-		super(position);
+	public ParsedStatementWhile(CodePosition position, WhitespaceInfo whitespace, String label, ParsedExpression condition, ParsedStatement content) {
+		super(position, whitespace);
 		
 		this.condition = condition;
 		this.content = content;
 		WhileStatement result = new WhileStatement(position, label, condition);
 		LoopScope innerScope = new LoopScope(result, scope);
 		result.content = this.content.compile(innerScope);
-		return result;
+		return result(result);
 	}
 }

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

 
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 import java.util.logging.Level;
 			NAMED_CHARACTER_ENTITIES.put(entity.stringValue, entity);
 		}
 	}
+
+	/**
+	 * Splits a string in parts, given a specified delimiter.
+	 *
+	 * @param value string to be split
+	 * @param delimiter delimiter
+	 * @return split string
+	 */
+	public static List<String> split(String value, char delimiter)
+	{
+		if (value == null)
+			return null;
+
+		List<String> result = new ArrayList<>();
+		int start = 0;
+		for (int i = 0; i < value.length(); i++) {
+			if (value.charAt(i) == delimiter) {
+				result.add(value.substring(start, i));
+				start = i + 1;
+			}
+		}
+		result.add(value.substring(start));
+		return result;
+	}
 	
 	/**
 	 * Left pads (prefixes) a string with characters until it reaches the given string

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

     private Map<Class<?>, Object> tags = Collections.EMPTY_MAP;
 
     public <T> void put(Class<T> cls, T tag) {
+		if (tag == null)
+			return;
+		
         if (tags == Collections.EMPTY_MAP) {
             tags = Collections.singletonMap(cls, tag);
         } else if (tags.size() == 1) {