- Function and method bodies are now single statements (which can, of course, be a BlockStatement), this simplifies code

- Function parameters are taggable, and Java parameter indices are now tagged on these parameters
- Improved constructor forwarding code
- Added handling for potential situations where multiple code blocks exist for the same script file (this can happen in generated code)
- Continue WIP on code formatting for definitions

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

 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.member.IDefinitionMember;
 
 /**
  *
 		FormattingUtils.formatModifiers(output, definition.modifiers);
 		output.append("class ");
 		output.append(definition.name);
-		if (definition.genericParameters.length > 0) {
-			
-		}
+		FormattingUtils.formatTypeParameters(output, definition.genericParameters, typeFormatter);
 		output.append(" ");
 		if (definition.superType != null) {
 			output.append("extends ");
 			output.append(definition.superType.accept(typeFormatter));
 			output.append(" ");
 		}
+		if (settings.classBracketOnSameLine) {
+			output.append("{\n");
+		} else {
+			output.append("\n")
+					.append(indent)
+					.append("{\n")
+					.append(indent + settings.indent);
+		}
+		
+		for (IDefinitionMember member : definition.members) {
+			member.accept(new MemberFormatter(settings, output, indent + settings.indent, typeFormatter));
+		}
+		
+		output.append("}\n");
 		return null;
 	}
 
 	@Override
 	public Void visitInterface(InterfaceDefinition definition) {
+		
 		return null;
 	}
 
 
 	@Override
 	public Void visitFunction(FunctionDefinition definition) {
+		FormattingUtils.formatModifiers(output, definition.modifiers);
+		output.append("function ");
+		output.append(definition.name);
+		FormattingUtils.formatHeader(output, settings, definition.header, typeFormatter);
+		FormattingUtils.formatBody(output, settings, indent, typeFormatter, definition.statement);
 		return null;
 	}
 

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

 	public final boolean loopBracketOnSameLine;
 	public final boolean tryCatchNewLine; // new line between } and catch or } and finally
 	public final boolean tryCatchBracketOnSameLine;
+	public final boolean classBracketOnSameLine;
+	public final boolean functionBracketOnSameLine;
+	public final boolean lambdaMethodOnSameLine;
 	
 	public final String indent;
 	
 		loopBracketOnSameLine = builder.loopBracketOnSameLine;
 		tryCatchNewLine = builder.tryCatchNewLine;
 		tryCatchBracketOnSameLine = builder.tryCatchBracketOnSameLine;
+		classBracketOnSameLine = builder.classBracketOnSameLine;
+		functionBracketOnSameLine = builder.functionBracketOnSameLine;
+		lambdaMethodOnSameLine = builder.lambdaMethodOnSameLine;
 		
 		if (useTabs) {
 			indent = "\t";
 		private boolean loopBracketOnSameLine = true;
 		private boolean tryCatchNewLine = true;
 		private boolean tryCatchBracketOnSameLine = true;
+		private boolean classBracketOnSameLine = false;
+		private boolean functionBracketOnSameLine = false;
+		private boolean lambdaMethodOnSameLine = false;
 		
 		public Builder showAnyInFunctionHeaders(boolean show) {
 			showAnyInFunctionHeaders = show;
 			return this;
 		}
 		
+		public Builder classBracketOnSameLine(boolean sameLine) {
+			classBracketOnSameLine = sameLine;
+			return this;
+		}
+		
+		public Builder functionBracketOnSameLine(boolean sameLine) {
+			functionBracketOnSameLine = sameLine;
+			return this;
+		}
+		
+		public Builder lambdaMethodOnSameLine(boolean sameLine) {
+			lambdaMethodOnSameLine = sameLine;
+			return this;
+		}
+		
 		public FormattingSettings build() {
 			return new FormattingSettings(this);
 		}

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

  */
 package org.openzen.zenscript.formatter;
 
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.Modifiers;
+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.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.ReturnStatement;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.StatementVisitor;
+import org.openzen.zenscript.codemodel.statement.ThrowStatement;
+import org.openzen.zenscript.codemodel.statement.TryCatchStatement;
+import org.openzen.zenscript.codemodel.statement.VarStatement;
+import org.openzen.zenscript.codemodel.statement.WhileStatement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
  *
 		if (Modifiers.isConstOptional(modifiers))
 			output.append("const? ");
 	}
+	
+	public static void formatHeader(StringBuilder result, FormattingSettings settings, FunctionHeader header, TypeFormatter typeFormatter) {
+		FormattingUtils.formatTypeParameters(result, header.typeParameters, typeFormatter);
+		result.append("(");
+		int parameterIndex = 0;
+		for (FunctionParameter parameter : header.parameters) {
+			if (parameterIndex > 0)
+				result.append(", ");
+			
+			result.append(parameter.name);
+			if (parameter.variadic)
+				result.append("...");
+			
+			if (!settings.showAnyInFunctionHeaders || parameter.type != BasicTypeID.ANY) {
+				result.append(" as ");
+				result.append(header.returnType.accept(typeFormatter));
+			}
+			
+			parameterIndex++;
+		}
+		result.append(")");
+		if (!settings.showAnyInFunctionHeaders || header.returnType != BasicTypeID.ANY) {
+			result.append(" as ");
+			result.append(header.returnType.accept(typeFormatter));
+		}
+	}
+	
+	public static void formatTypeParameters(StringBuilder result, TypeParameter[] parameters, TypeFormatter typeFormatter) {
+		if (parameters.length > 0) {
+			result.append("<");
+			int index = 0;
+			for (TypeParameter parameter : parameters) {
+				if (index > 0)
+					result.append(", ");
+				
+				result.append(parameter.name);
+				
+				if (parameter.bounds.size() > 0) {
+					for (GenericParameterBound bound : parameter.bounds) {
+						result.append(": ");
+						result.append(bound.accept(typeFormatter));
+					}
+				}
+				
+				index++;
+			}
+			result.append(">");
+		}
+	}
+	
+	public static void formatBody(StringBuilder output, FormattingSettings settings, String indent, TypeFormatter typeFormatter, Statement body) {
+		body.accept(new BodyFormatter(output, settings, indent, typeFormatter));
+	}
+	
+	private static class BodyFormatter implements StatementVisitor<Void> {
+		private final StringBuilder output;
+		private final FormattingSettings settings;
+		private final StatementFormatter statementFormatter;
+		private final String indent;
+		private final TypeFormatter typeFormatter;
+		
+		public BodyFormatter(StringBuilder output, FormattingSettings settings, String indent, TypeFormatter typeFormatter) {
+			this.output = output;
+			this.settings = settings;
+			this.indent = indent;
+			this.typeFormatter = typeFormatter;
+			
+			statementFormatter = new StatementFormatter(indent + settings.indent, settings, new ExpressionFormatter(settings, typeFormatter)); 
+		}
+
+		@Override
+		public Void visitBlock(BlockStatement statement) {
+			return statementFormatter.visitBlock(statement);
+		}
+
+		@Override
+		public Void visitBreak(BreakStatement statement) {
+			return statementFormatter.visitBreak(statement);
+		}
+
+		@Override
+		public Void visitContinue(ContinueStatement statement) {
+			return statementFormatter.visitContinue(statement);
+		}
+
+		@Override
+		public Void visitDoWhile(DoWhileStatement statement) {
+			return statementFormatter.visitDoWhile(statement);
+		}
+
+		@Override
+		public Void visitEmpty(EmptyStatement statement) {
+			output.append(";\n");
+			return null;
+		}
+
+		@Override
+		public Void visitExpression(ExpressionStatement statement) {
+			if (settings.lambdaMethodOnSameLine) {
+				output.append(" => ");
+			} else {
+				output.append("\n").append(indent).append(settings.indent).append("=> ");
+			}
+			
+			output.append(statement.expression.accept(new ExpressionFormatter(settings, typeFormatter)));
+			output.append(";");
+			return null;
+		}
+
+		@Override
+		public Void visitForeach(ForeachStatement statement) {
+			return statementFormatter.visitForeach(statement);
+		}
+
+		@Override
+		public Void visitIf(IfStatement statement) {
+			return statementFormatter.visitIf(statement);
+		}
+
+		@Override
+		public Void visitLock(LockStatement statement) {
+			return statementFormatter.visitLock(statement);
+		}
+
+		@Override
+		public Void visitReturn(ReturnStatement statement) {
+			if (settings.lambdaMethodOnSameLine) {
+				output.append(" => ");
+			} else {
+				output.append("\n").append(indent).append(settings.indent).append("=> ");
+			}
+			
+			output.append(statement.value.accept(new ExpressionFormatter(settings, typeFormatter)));
+			output.append(";");
+			return null;
+		}
+
+		@Override
+		public Void visitThrow(ThrowStatement statement) {
+			return statementFormatter.visitThrow(statement);
+		}
+
+		@Override
+		public Void visitTryCatch(TryCatchStatement statement) {
+			return statementFormatter.visitTryCatch(statement);
+		}
+
+		@Override
+		public Void visitVar(VarStatement statement) {
+			return statementFormatter.visitVar(statement);
+		}
+
+		@Override
+		public Void visitWhile(WhileStatement statement) {
+			return statementFormatter.visitWhile(statement);
+		}
+	}
 }

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/MemberFormatter.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 java.util.List;
+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.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
+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;
+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.statement.ReturnStatement;
+import org.openzen.zenscript.codemodel.statement.Statement;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class MemberFormatter implements MemberVisitor<Void> {
+	private final FormattingSettings settings;
+	private final StringBuilder output;
+	private final String indent;
+	private final TypeFormatter typeFormatter;
+	
+	public MemberFormatter(FormattingSettings settings, StringBuilder output, String indent, TypeFormatter typeFormatter) {
+		this.settings = settings;
+		this.output = output;
+		this.indent = indent;
+		this.typeFormatter = typeFormatter;
+	}
+
+	@Override
+	public Void visitField(FieldMember member) {
+		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		output.append(member.isFinal() ? "val " : "var ")
+				.append(member.name)
+				.append(" as ")
+				.append(member.type.accept(typeFormatter));
+		
+		if (member.initializer != null) {
+			output.append(" = ")
+					.append(member.initializer.accept(new ExpressionFormatter(settings, typeFormatter)));
+		}
+		output.append(";").append("\n").append(indent);
+		return null;
+	}
+
+	@Override
+	public Void visitConstructor(ConstructorMember member) {
+		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		output.append("this");
+		FormattingUtils.formatHeader(output, settings, member.header, typeFormatter);
+		formatBody(member.body);
+		return null;
+	}
+
+	@Override
+	public Void visitMethod(MethodMember member) {
+		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		output.append(member.name);
+		FormattingUtils.formatHeader(output, settings, member.header, typeFormatter);
+		formatBody(member.body);
+		return null;
+	}
+
+	@Override
+	public Void visitGetter(GetterMember member) {
+		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		output.append("get ");
+		output.append(member.name);
+		output.append(" as ");
+		output.append(member.type.accept(typeFormatter));
+		formatBody(member.body);
+		return null;
+	}
+
+	@Override
+	public Void visitSetter(SetterMember member) {
+		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		output.append("set ");
+		output.append(member.name);
+		output.append(" as ");
+		output.append(member.type.accept(typeFormatter));
+		formatBody(member.body);
+		return null;
+	}
+
+	@Override
+	public Void visitEnumConstant(EnumConstantMember member) {
+		return null; // TODO: handle separately
+	}
+
+	@Override
+	public Void visitOperator(OperatorMember member) {
+		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		switch (member.operator) {
+			case ADD: output.append("+"); break;
+			case SUB: output.append("-"); break;
+			case MUL: output.append("*"); break;
+			case DIV: output.append("/"); break;
+			case MOD: output.append("%"); break;
+			case CAT: output.append("~"); break;
+			case OR: output.append("|"); break;
+			case AND: output.append("&"); break;
+			case XOR: output.append("^"); break;
+			case NEG: output.append("-"); break;
+			case NOT: output.append("!"); break;
+			case INDEXSET: output.append("[]="); break;
+			case INDEXGET: output.append("[]"); break;
+			case CONTAINS: output.append("in"); break;
+			case MEMBERGETTER: output.append("."); break;
+			case MEMBERSETTER: output.append(".="); break;
+			case EQUALS: output.append("=="); break;
+			case ADDASSIGN: output.append("+="); break;
+			case SUBASSIGN: output.append("-="); break;
+			case MULASSIGN: output.append("*="); break;
+			case DIVASSIGN: output.append("/="); break;
+			case MODASSIGN: output.append("%="); break;
+			case CATASSIGN: output.append("~="); break;
+			case ORASSIGN: output.append("|="); break;
+			case ANDASSIGN: output.append("&="); break;
+			case XORASSIGN: output.append("^="); break;
+	
+			case POST_INCREMENT: output.append("++"); break;
+			case POST_DECREMENT: output.append("--"); break;
+			default:
+				throw new UnsupportedOperationException("Unknown operator: " + member.operator);
+		}
+		FormattingUtils.formatHeader(output, settings, member.header, typeFormatter);
+		formatBody(member.body);
+		return null;
+	}
+
+	@Override
+	public Void visitCaster(CasterMember member) {
+		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		output.append(" as ");
+		output.append(member.toType.accept(typeFormatter));
+		formatBody(member.body);
+		return null;
+	}
+
+	@Override
+	public Void visitCustomIterator(CustomIteratorMember member) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Void visitCaller(CallerMember member) {
+		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatHeader(output, settings, member.header, typeFormatter);
+		formatBody(member.body);
+		return null;
+	}
+
+	@Override
+	public Void visitImplementation(ImplementationMember implementation) {
+		FormattingUtils.formatModifiers(output, implementation.modifiers & ~Modifiers.FINAL);
+		output.append("implements ");
+		output.append(implementation.type.accept(typeFormatter));
+		if (settings.classBracketOnSameLine) {
+			output.append("{\n");
+		} else {
+			output.append("\n").append(indent).append("{\n");
+		}
+		
+		for (IDefinitionMember member : implementation.members) {
+			member.accept(new MemberFormatter(settings, output, indent + settings.indent, typeFormatter));
+		}
+		
+		output.append("}\n");
+		return null;
+	}
+
+	@Override
+	public Void visitInnerDefinition(InnerDefinitionMember member) {
+		String formatted = member.innerDefinition.accept(new DefinitionFormatter(settings, typeFormatter, indent + settings.indent)).toString();
+		output.append(formatted);
+		return null;
+	}
+	
+	private void formatBody(Statement body) {
+		FormattingUtils.formatBody(output, settings, indent, typeFormatter, body);
+	}
+}

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

 	public String visitFunction(FunctionTypeID function) {
 		StringBuilder result = new StringBuilder();
 		result.append("function");
-		
-		FunctionHeader header = function.header;
-		formatTypeParameters(result, header.typeParameters);
-		result.append("(");
-		int parameterIndex = 0;
-		for (FunctionParameter parameter : header.parameters) {
-			if (parameterIndex > 0)
-				result.append(", ");
-			
-			result.append(parameter.name);
-			if (parameter.variadic)
-				result.append("...");
-			
-			if (!settings.showAnyInFunctionHeaders || parameter.type != BasicTypeID.ANY) {
-				result.append(" as ");
-				result.append(header.returnType.accept(this));
-			}
-			
-			parameterIndex++;
-		}
-		result.append(")");
-		if (!settings.showAnyInFunctionHeaders || header.returnType != BasicTypeID.ANY) {
-			result.append(" as ");
-			result.append(header.returnType.accept(this));
-		}
+		FormattingUtils.formatHeader(result, settings, function.header, this);
 		return result.toString();
 	}
 
 	public String visitOptional(OptionalTypeID optional) {
 		return optional.baseType.accept(this) + "?";
 	}
-	
-	private void formatTypeParameters(StringBuilder result, TypeParameter[] parameters) {
-		if (parameters.length > 0) {
-			result.append("<");
-			int index = 0;
-			for (TypeParameter parameter : parameters) {
-				if (index > 0)
-					result.append(", ");
-				
-				result.append(parameter.name);
-				
-				if (parameter.bounds.size() > 0) {
-					for (GenericParameterBound bound : parameter.bounds) {
-						result.append(": ");
-						result.append(bound.accept(this));
-					}
-				}
-				
-				index++;
-			}
-			result.append(">");
-		}
-	}
 
 	@Override
 	public String visitSuper(ParameterSuperBound bound) {

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

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

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

 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.Taggable;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class FunctionParameter {
-	public int index = -1;
+public class FunctionParameter extends Taggable {
 	public final ITypeID type;
 	public final String name;
 	public final Expression defaultValue;

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

 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.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 		for (IDefinitionMember member : members)
 			if (member instanceof FieldMember)
 				fields.add((FieldMember)member);
+		
 		return fields;
 	}
 	
+	public List<EnumConstantMember> getEnumConstants() {
+		List<EnumConstantMember> enumMembers = new ArrayList<>();
+		for (IDefinitionMember member : members)
+            if (member instanceof EnumConstantMember)
+				enumMembers.add((EnumConstantMember) member);
+		
+		return enumMembers;
+	}
+	
 	public boolean isStatic() {
 		return (modifiers & Modifiers.STATIC) > 0;
 	}

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

  */
 public class FunctionDefinition extends HighLevelDefinition {
 	public FunctionHeader header;
-	public List<Statement> statements;
+	public Statement statement;
 	public OperatorMember caller;
 	public DefinitionMemberGroup callerGroup = new DefinitionMemberGroup();
 	
 		callerGroup.addMethod(caller, TypeMemberPriority.SPECIFIED);
 	}
 	
-	public void setCode(List<Statement> statements) {
-		this.statements = statements;
-		caller.setBody(statements);
+	public void setCode(Statement statement) {
+		this.statement = statement;
+		caller.setBody(statement);
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
-import java.util.List;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 public class FunctionExpression extends Expression {
 	public final FunctionHeader header;
 	public final LambdaClosure closure;
-	public final List<Statement> statements;
+	public final Statement body;
 	
 	public FunctionExpression(
 			CodePosition position,
 			FunctionTypeID type,
 			LambdaClosure closure,
-			List<Statement> statements) {
+			Statement body) {
 		super(position, type);
 		
 		this.header = type.header;
 		this.closure = closure;
-		this.statements = statements;
+		this.body = body;
 	}
 
 	@Override

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

 import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
+import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.statement.BlockStatement;
+import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	public ConstructorMember(CodePosition position, HighLevelDefinition definition, int modifiers, FunctionHeader header) {
 		super(position, definition, modifiers, "this", new FunctionHeader(header.typeParameters, BasicTypeID.VOID, header.parameters));
 	}
+	
+	public boolean isConstructorForwarded() {
+		ExpressionStatement firstExpression = null;
+		if (body instanceof ExpressionStatement) {
+			firstExpression = (ExpressionStatement) body;
+		} else if (body instanceof BlockStatement) {
+			BlockStatement blockBody = (BlockStatement) body;
+			if (blockBody.statements.size() > 0 && blockBody.statements.get(0) instanceof ExpressionStatement)
+				firstExpression = (ExpressionStatement) blockBody.statements.get(0);
+		}
+		
+		return firstExpression != null && (
+				firstExpression.expression instanceof ConstructorSuperCallExpression
+				|| firstExpression.expression instanceof ConstructorThisCallExpression);
+	}
 
 	@Override
 	public void registerTo(TypeMembers type, TypeMemberPriority priority) {

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

  */
 public class CustomIteratorMember extends DefinitionMember implements IIteratorMember {
 	private final ITypeID[] iteratorTypes;
-	private List<Statement> content;
+	private Statement content;
 	
 	public CustomIteratorMember(CodePosition position, HighLevelDefinition definition, int modifiers, ITypeID[] iteratorTypes) {
 		super(position, definition, modifiers);
 		this.iteratorTypes = iteratorTypes;
 	}
 	
-	public void setContent(List<Statement> content) {
+	public void setContent(Statement content) {
 		this.content = content;
 	}
 

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

 public abstract class FunctionalMember extends DefinitionMember implements ICallableMember {
 	public final FunctionHeader header;
 	public final String name;
-	public List<Statement> body;
+	public Statement body;
 	
 	public FunctionalMember(CodePosition position, HighLevelDefinition definition, int modifiers, String name, FunctionHeader header) {
 		super(position, definition, modifiers);
 		this.header = header;
 	}
 	
-	public void setBody(List<Statement> body) {
+	public void setBody(Statement body) {
 		this.body = body;
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/Statement.java

 	
 	public abstract <T> T accept(StatementVisitor<T> visitor);
 	
-	public static ITypeID getReturnType(TypeScope scope, List<Statement> statements) {
-		ITypeID result = null;
-		for (Statement statement : statements) {
-			ITypeID statementType = statement.getReturnType();
-			if (result == null)
-				result = statementType;
-			else
-				result = scope.getTypeMembers(result).union(statementType);
-		}
-		return result;
-	}
-	
 	public static List<Statement> withReturnType(TypeScope scope, List<Statement> statements, ITypeID returnType) {
 		return statements.stream()
 				.map(statement -> statement.withReturnType(scope, returnType))

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaClassInfo.java

  */
 public class JavaClassInfo {
 	public static JavaClassInfo get(Class<?> cls) {
-		return new JavaClassInfo(Type.getInternalName(cls));
+		return new JavaClassInfo(Type.getInternalName(cls), cls.isEnum());
 	}
 	
 	public final String internalClassName;
+	public final boolean isEnum;
 	
 	public JavaClassInfo(String internalClassName) {
+		this(internalClassName, false);
+	}
+	
+	public JavaClassInfo(String internalClassName, boolean isEnum) {
 		this.internalClassName = internalClassName;
+		this.isEnum = isEnum;
 	}
 }

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaCompiler.java

 		final SourceFile sourceFile = script.getTag(SourceFile.class);
 		final String className = getClassName(sourceFile == null ? null : sourceFile.filename);
 		JavaScriptFile scriptFile = getScriptFile(className);
+		
+		String methodName = scriptFile.scriptMethods.isEmpty() ? "run" : "run" + scriptFile.scriptMethods.size();
 
 		// convert scripts into methods (add them to a Scripts class?)
 		// (TODO: can we break very long scripts into smaller methods? for the extreme scripts)
 		final JavaClassWriter visitor = scriptFile.classWriter;
-		JavaMethodInfo method = new JavaMethodInfo(new JavaClassInfo(className), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+		JavaMethodInfo method = new JavaMethodInfo(new JavaClassInfo(className), methodName, "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 		scriptFile.scriptMethods.add(method);
 		
-		final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(new JavaWriter(visitor, method, null, null));
+		final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(new JavaWriter(visitor, method, null, null, null));
 		statementVisitor.start();
 		for (Statement statement : script.statements) {
 			statement.accept(statementVisitor);
 		finished = true;
 		
 		JavaMethodInfo runMethod = new JavaMethodInfo(new JavaClassInfo("Scripts"), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
-		final JavaWriter runWriter = new JavaWriter(scriptsClassWriter, runMethod, null, null);
+		final JavaWriter runWriter = new JavaWriter(scriptsClassWriter, runMethod, null, null, null);
 		runWriter.start();
 		for (Map.Entry<String, JavaScriptFile> entry : scriptBlocks.entrySet()) {
 			for (JavaMethodInfo method : entry.getValue().scriptMethods)

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaEnumInfo.java

-package org.openzen.zenscript.javabytecode;
-
-import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
-
-public class JavaEnumInfo {
-    public final JavaStatementVisitor clinitVisitor;
-
-    public JavaEnumInfo(JavaStatementVisitor clinitVisitor) {
-        this.clinitVisitor = clinitVisitor;
-    }
-}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaParameterInfo.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.javabytecode;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaParameterInfo {
+	public final int index;
+	
+	public JavaParameterInfo(int index) {
+		this.index = index;
+	}
+}

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

 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.javabytecode.JavaParameterInfo;
 import org.openzen.zenscript.shared.CodePosition;
 
 public class CompilerUtils {
     public static String calcClasName(CodePosition position) {
         return position.filename.substring(0, position.filename.lastIndexOf('.')).replace("/", "_");
     }
+	
+	public static void tagMethodParameters(FunctionHeader header, boolean isStatic) {
+		for (int i = 0; i < header.parameters.length; i++) {
+			header.parameters[i].setTag(JavaParameterInfo.class, new JavaParameterInfo(isStatic ? i : i + 1));
+		}
+	}
+	
+	public static void tagConstructorParameters(FunctionHeader header, boolean isEnum) {
+		for (int i = 0; i < header.parameters.length; i++) {
+			header.parameters[i].setTag(JavaParameterInfo.class, new JavaParameterInfo(isEnum ? i + 3 : i + 1));
+		}
+	}
+	
+	public static void writeDefaultFieldInitializers(JavaWriter constructorWriter, HighLevelDefinition definition) {
+		JavaExpressionVisitor expressionVisitor = new JavaExpressionVisitor(constructorWriter);
+		for (final IDefinitionMember definitionMember : definition.members) {
+			if (definitionMember instanceof FieldMember && ((FieldMember) definitionMember).initializer != null) {
+				final FieldMember field = (FieldMember) definitionMember;
+				constructorWriter.loadObject(0);
+				field.initializer.accept(expressionVisitor);
+				constructorWriter.putField(definition.name, field.name, Type.getDescriptor(field.type.accept(JavaTypeClassVisitor.INSTANCE)));
+			}
+		}
+	}
 }

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

     @Override
     public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
         Type type = expression.objectType.accept(JavaTypeVisitor.INSTANCE);
-        //javaWriter.loadObject(0);
+		
+		if (javaWriter.method.javaClass.isEnum) {
+			javaWriter.loadObject(0);
+			javaWriter.loadObject(1);
+			javaWriter.loadInt(2);
+		} else {
+			javaWriter.loadObject(0);
+		}
+		
         for (Expression argument : expression.arguments.arguments) {
             argument.accept(this);
         }
-        javaWriter.invokeSpecial(type.getInternalName(), "<init>", CompilerUtils.calcDesc(expression.constructor.header, expression.constructor.hasTag(JavaEnumInfo.class)));
+        javaWriter.invokeSpecial(type.getInternalName(), "<init>", CompilerUtils.calcDesc(expression.constructor.header, javaWriter.method.javaClass.isEnum));
         return null;
     }
 
         }
         //No super calls in enums possible, and that's already handled in the enum constructor itself.
         javaWriter.invokeSpecial(expression.objectType.accept(JavaTypeClassVisitor.INSTANCE), "<init>", CompilerUtils.calcDesc(expression.constructor.header, false));
+		
+		CompilerUtils.writeDefaultFieldInitializers(javaWriter, javaWriter.forDefinition);
         return null;
     }
 
 
     @Override
     public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
-        //TODO is Static?
-        final boolean isStatic = false;
-        javaWriter.load(Type.getType(expression.parameter.type.accept(JavaTypeClassVisitor.INSTANCE)), isStatic ? expression.parameter.index : expression.parameter.index + 1);
+		JavaParameterInfo parameter = expression.parameter.getTag(JavaParameterInfo.class);
+        javaWriter.load(Type.getType(expression.parameter.type.accept(JavaTypeClassVisitor.INSTANCE)), parameter.index);
         return null;
     }
 
     @Override
     public Void visitSetFunctionParameter(SetFunctionParameterExpression expression) {
         expression.value.accept(this);
-        javaWriter.store(expression.type.accept(JavaTypeVisitor.INSTANCE), javaWriter.method.isStatic() ? expression.parameter.index : expression.parameter.index + 1);
+		JavaParameterInfo parameter = expression.parameter.getTag(JavaParameterInfo.class);
+        javaWriter.store(expression.type.accept(JavaTypeVisitor.INSTANCE), parameter.index);
         return null;
     }
 

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

 import org.openzen.zenscript.codemodel.statement.*;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 
-public class JavaStatementVisitor implements StatementVisitor<Void> {
+public class JavaStatementVisitor implements StatementVisitor<Boolean> {
     private final JavaWriter javaWriter;
     public final JavaExpressionVisitor expressionVisitor;
 	
     }
 
     @Override
-    public Void visitBlock(BlockStatement statement) {
+    public Boolean visitBlock(BlockStatement statement) {
+		Boolean returns = false;
         for (Statement statement1 : statement.statements) {
-            statement1.accept(this);
+            returns = statement1.accept(this);
         }
-        return null;
+        return returns;
     }
 
     @Override
-    public Void visitBreak(BreakStatement statement) {
+    public Boolean visitBreak(BreakStatement statement) {
         javaWriter.goTo(javaWriter.getNamedLabel(statement.target.label + "_end"));
-        return null;
+        return false;
     }
 
     @Override
-    public Void visitContinue(ContinueStatement statement) {
+    public Boolean visitContinue(ContinueStatement statement) {
         javaWriter.goTo(javaWriter.getNamedLabel(statement.target.label + "_start"));
-        return null;
+        return false;
     }
 
     @Override
-    public Void visitDoWhile(DoWhileStatement statement) {
+    public Boolean visitDoWhile(DoWhileStatement statement) {
         Label start = new Label();
         Label end = new Label();
         if (statement.label == null)
 
         //Only needed for break statements, should be nop if not used
         javaWriter.label(end);
-        return null;
+        return false;
     }
 
     @Override
-    public Void visitEmpty(EmptyStatement statement) {
+    public Boolean visitEmpty(EmptyStatement statement) {
         //No-Op
-        return null;
+        return false;
     }
 
     @Override
-    public Void visitExpression(ExpressionStatement statement) {
+    public Boolean visitExpression(ExpressionStatement statement) {
         statement.expression.accept(expressionVisitor);
-        return null;
+        return false;
     }
 
     @Override
-    public Void visitForeach(ForeachStatement statement) {
+    public Boolean visitForeach(ForeachStatement statement) {
         //Create Labels
         Label start = new Label();
         Label end = new Label();
         statement.iterator.acceptForIterator(new JavaForeachVisitor(this, statement.loopVariables, statement.content, start, end));
         javaWriter.goTo(start);
         javaWriter.label(end);
-        return null;
+        return false;
     }
 
     @Override
-    public Void visitIf(IfStatement statement) {
+    public Boolean visitIf(IfStatement statement) {
         statement.condition.accept(expressionVisitor);
         Label onElse = null;
         Label end = new Label();
             statement.onElse.accept(this);
         }
         javaWriter.label(end);
-        return null;
+        return false;
     }
 
     @Override
-    public Void visitLock(LockStatement statement) {
-        return null;
+    public Boolean visitLock(LockStatement statement) {
+        return false;
     }
 
     @Override
-    public Void visitReturn(ReturnStatement statement) {
+    public Boolean visitReturn(ReturnStatement statement) {
         statement.value.accept(expressionVisitor);
         javaWriter.returnType(Type.getType(statement.value.type.accept(JavaTypeClassVisitor.INSTANCE)));
-        return null;
+        return true;
     }
 
     @Override
-    public Void visitThrow(ThrowStatement statement) {
+    public Boolean visitThrow(ThrowStatement statement) {
         statement.value.accept(expressionVisitor);
         javaWriter.aThrow();
-        return null;
+        return false;
     }
 
     @Override
-    public Void visitTryCatch(TryCatchStatement statement) {
+    public Boolean visitTryCatch(TryCatchStatement statement) {
         final Label tryCatchStart = new Label();
         final Label tryFinish = new Label();
         final Label tryCatchFinish = new Label();
         }
         javaWriter.label(tryCatchFinish);
 
-        return null;
+        return false;
     }
 
     @Override
-    public Void visitVar(VarStatement statement) {
+    public Boolean visitVar(VarStatement statement) {
         Type type = statement.type.accept(JavaTypeVisitor.INSTANCE);
         int local = javaWriter.local(type);
         if (statement.initializer != null) {
         final JavaLocalVariableInfo info = new JavaLocalVariableInfo(type, local, variableStart, statement.name);
         statement.setTag(JavaLocalVariableInfo.class, info);
         javaWriter.addVariableInfo(info);
-        return null;
+        return false;
     }
 
     @Override
-    public Void visitWhile(WhileStatement statement) {
+    public Boolean visitWhile(WhileStatement statement) {
         Label start = new Label();
         Label end = new Label();
 
         statement.content.accept(this);
         javaWriter.goTo(start);
         javaWriter.label(end);
-        return null;
+        return false;
     }
 
     public void start() {

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

 import java.util.Map;
 
 import static org.objectweb.asm.Opcodes.*;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 
 			Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 	
 	public final JavaMethodInfo method;
+	public final HighLevelDefinition forDefinition;
 	
     private final LocalVariablesSorter visitor;
     private final List<JavaLocalVariableInfo> localVariableInfos = new ArrayList<>();
     private int labelIndex = 1;
     private Map<Label, String> labelNames = new HashMap<>();
 
-    public JavaWriter(ClassVisitor visitor, boolean nameVariables, JavaMethodInfo method, String signature, String[] exceptions, String... annotations) {
+    public JavaWriter(
+			ClassVisitor visitor,
+			boolean nameVariables,
+			JavaMethodInfo method,
+			HighLevelDefinition forDefinition,
+			String signature,
+			String[] exceptions,
+			String... annotations)
+	{
 		this.method = method;
+		this.forDefinition = forDefinition;
 		
         final MethodVisitor methodVisitor = visitor.visitMethod(method.modifiers, method.name, method.descriptor, signature, exceptions);
 
         this.nameVariables = nameVariables;
     }
 
-    public JavaWriter(ClassVisitor visitor, JavaMethodInfo method, String signature, String[] exceptions, String... annotations) {
-        this(visitor, true, method, signature, exceptions, annotations);
+    public JavaWriter(ClassVisitor visitor, JavaMethodInfo method, HighLevelDefinition forDefinition, String signature, String[] exceptions, String... annotations) {
+        this(visitor, true, method, forDefinition, signature, exceptions, annotations);
     }
 
     private static String signature(Class aClass) {

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaDefinitionVisitor.java

 package org.openzen.zenscript.javabytecode.compiler.definitions;
 
+import java.util.List;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
-import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.definition.*;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.ExpressionVisitor;
-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.statement.ExpressionStatement;
-import org.openzen.zenscript.codemodel.statement.ReturnStatement;
-import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.javabytecode.JavaClassInfo;
-import org.openzen.zenscript.javabytecode.JavaEnumInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 import org.openzen.zenscript.javabytecode.compiler.*;
 
-import java.util.Iterator;
 
 public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 	private static final JavaClassInfo T_CLASS = new JavaClassInfo("java/lang/Class");
 
         writer.visit(Opcodes.V1_8, definition.modifiers, definition.name, signature, superType.getInternalName(), null);
         for (IDefinitionMember member : definition.members) {
-            if (member instanceof ConstructorMember) {
-                final ConstructorMember constructorMember = (ConstructorMember) member;
-                constructorMember.body.add(0, new ExpressionStatement(constructorMember.position, new Expression(constructorMember.position, BasicTypeID.VOID) {
-                    @Override
-                    public <T> T accept(ExpressionVisitor<T> visitor) {
-                        if (visitor instanceof JavaExpressionVisitor) {
-                            JavaWriter javaWriter = ((JavaExpressionVisitor) visitor).getJavaWriter();
-                            javaWriter.loadObject(0);
-                            //TODO Super constructor?
-                            javaWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
-                            for (final IDefinitionMember definitionMember : definition.members) {
-                                if (definitionMember instanceof FieldMember && ((FieldMember) definitionMember).initializer != null) {
-                                    final FieldMember field = (FieldMember) definitionMember;
-                                    javaWriter.loadObject(0);
-                                    field.initializer.accept(visitor);
-                                    javaWriter.putField(definition.name, field.name, Type.getDescriptor(field.type.accept(JavaTypeClassVisitor.INSTANCE)));
-                                }
-                            }
-                        }
-                        return null;
-                    }
-                }));
-            }
-			
-            member.accept(new JavaMemberVisitor(writer, toClass));
+            member.accept(new JavaMemberVisitor(writer, toClass, definition));
         }
         writer.visitEnd();
         return writer.toByteArray();
         String signature = null;
         writer.visit(Opcodes.V1_8, definition.modifiers | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT, definition.name, signature, Type.getInternalName(Object.class), null);
         for (IDefinitionMember member : definition.members) {
-            member.accept(new JavaMemberVisitor(writer, toClass));
+            member.accept(new JavaMemberVisitor(writer, toClass, definition));
         }
         writer.visitEnd();
         return writer.toByteArray();
 
     @Override
     public byte[] visitEnum(EnumDefinition definition) {
+		System.out.println("Compiling enum " + definition.name + " in " + definition.position.filename);
+		
         final Type superType;
         if (definition.superType == null)
             superType = Type.getType(Object.class);
             if (member instanceof EnumConstantMember) {
                 EnumConstantMember constantMember = (EnumConstantMember) member;
                 writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_ENUM, constantMember.name, "L" + definition.name + ";", null, null).visitEnd();
-            } else if (member instanceof ConstructorMember) {
-                member.setTag(JavaEnumInfo.class, null);
             }
         }
 
-		JavaClassInfo toClass = new JavaClassInfo(definition.name);
-		JavaMethodInfo clinitInfo = new JavaMethodInfo(toClass, "<clinit>", "()V", Opcodes.ACC_STATIC);
-        final JavaWriter clinitWriter = new JavaWriter(writer, clinitInfo, null, null);
-        final JavaStatementVisitor clinitVisitor = new JavaStatementVisitor(clinitWriter);
-        clinitVisitor.start();
-        int constantCount = 0;
-        for (IDefinitionMember member : definition.members) {
-            if (member instanceof ConstructorMember) {
-                final ConstructorMember constructorMember = (ConstructorMember) member;
-
-
-                constructorMember.body.add(0, new ExpressionStatement(constructorMember.position, new Expression(constructorMember.position, BasicTypeID.VOID) {
-                    @Override
-                    public <T> T accept(ExpressionVisitor<T> visitor) {
-                        if (visitor instanceof JavaExpressionVisitor) {
-                            JavaWriter javaWriter = ((JavaExpressionVisitor) visitor).getJavaWriter();
-                            javaWriter.getVisitor().newLocal(Type.getType(String.class));
-                            javaWriter.getVisitor().newLocal(Type.getType(int.class));
-                            javaWriter.loadObject(0);
-                            javaWriter.loadObject(1);
-                            javaWriter.loadInt(2);
-                            //javaWriter.invokeSpecial(Type.getInternalName(Enum.class), "<init>", "(Ljava/lang/String;I)V");
-                        }
-                        return null;
-                    }
-                }));
-            } else if (member instanceof EnumConstantMember) {
-                ++constantCount;
-                member.setTag(JavaEnumInfo.class, new JavaEnumInfo(clinitVisitor));
-            }
-            member.accept(new JavaMemberVisitor(writer, toClass));
-        }
-
-        clinitWriter.constant(constantCount);
-        clinitWriter.newArray(Type.getType("L" + definition.name + ";"));
-
-        for (IDefinitionMember member : definition.members) {
-            if (!(member instanceof EnumConstantMember)) continue;
-            final EnumConstantMember constantMember = (EnumConstantMember) member;
-            clinitWriter.dup();
-            clinitWriter.constant(constantMember.value);
-            clinitWriter.getStaticField(definition.name, constantMember.name, "L" + definition.name + ";");
-            clinitWriter.arrayStore(Type.getType("L" + definition.name + ";"));
-        }
-        clinitWriter.putStaticField(definition.name, "$VALUES", "[L" + definition.name + ";");
-        clinitVisitor.end();
+		JavaClassInfo toClass = new JavaClassInfo(definition.name, true);
+		writeEnumStaticInitializer(definition, toClass, writer);
 
         //Enum Stuff(required!)
         writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC, "$VALUES", "[L" + definition.name + ";", null, null).visitEnd();
 		
+        for (IDefinitionMember member : definition.members) {
+            member.accept(new JavaMemberVisitor(writer, toClass, definition));
+        }
+		
 		JavaClassInfo arrayClass = new JavaClassInfo("[L" + definition.name + ";");
 		JavaMethodInfo arrayClone = new JavaMethodInfo(arrayClass, "clone", "()Ljava/lang/Object;", Opcodes.ACC_PUBLIC);
 
 		JavaMethodInfo valuesMethodInfo = new JavaMethodInfo(toClass, "values", "()[L" + definition.name + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-        JavaWriter valuesWriter = new JavaWriter(writer, true, valuesMethodInfo, null, null);
+        JavaWriter valuesWriter = new JavaWriter(writer, true, valuesMethodInfo, definition, null, null);
         valuesWriter.start();
         valuesWriter.getStaticField(definition.name, "$VALUES", "[L" + definition.name + ";");
         valuesWriter.invokeVirtual(arrayClone);
         valuesWriter.end();
 
 		JavaMethodInfo valueOfMethodInfo = new JavaMethodInfo(toClass, "valueOf", "(Ljava/lang/String;)L" + definition.name + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-        JavaWriter valueOfWriter = new JavaWriter(writer, true, valueOfMethodInfo, null, null);
+        JavaWriter valueOfWriter = new JavaWriter(writer, true, valueOfMethodInfo, definition, null, null);
         valueOfWriter.start();
         valueOfWriter.invokeStatic(CLASS_FORNAME);
         valueOfWriter.loadObject(0);
         writer.visitEnd();
         return writer.toByteArray();
     }
+	
+	private void writeEnumStaticInitializer(EnumDefinition definition, JavaClassInfo toClass, ClassWriter writer) {
+		JavaMethodInfo clinitInfo = new JavaMethodInfo(toClass, "<clinit>", "()V", Opcodes.ACC_STATIC);
+        final JavaWriter clinitWriter = new JavaWriter(writer, clinitInfo, definition, null, null);
+        final JavaStatementVisitor clinitVisitor = new JavaStatementVisitor(clinitWriter);
+        clinitVisitor.start();
+		
+		List<EnumConstantMember> enumConstants = definition.getEnumConstants();
+		for (EnumConstantMember enumConstant : enumConstants) {
+			final String internalName = enumConstant.constructor.type.accept(JavaTypeVisitor.INSTANCE).getInternalName();
+
+			clinitWriter.newObject(internalName);
+			clinitWriter.dup();
+			clinitWriter.constant(enumConstant.name);
+			clinitWriter.constant(enumConstant.value);
+			for (Expression argument : enumConstant.constructor.arguments.arguments) {
+				argument.accept(clinitVisitor.expressionVisitor);
+			}
+			clinitWriter.invokeSpecial(internalName, "<init>", CompilerUtils.calcDesc(enumConstant.constructor.constructor.header, true));
+			clinitWriter.putStaticField(internalName, enumConstant.name, "L" + internalName + ";");
+		}
+
+        clinitWriter.constant(enumConstants.size());
+        clinitWriter.newArray(Type.getType("L" + definition.name + ";"));
+
+        for (EnumConstantMember enumConstant : enumConstants) {
+            clinitWriter.dup();
+            clinitWriter.constant(enumConstant.value);
+            clinitWriter.getStaticField(definition.name, enumConstant.name, "L" + definition.name + ";");
+            clinitWriter.arrayStore(Type.getType("L" + definition.name + ";"));
+        }
+        clinitWriter.putStaticField(definition.name, "$VALUES", "[L" + definition.name + ";");
+        clinitVisitor.end();
+	}
 
     @Override
     public byte[] visitStruct(StructDefinition definition) {
 
     @Override
     public byte[] visitFunction(FunctionDefinition definition) {
+		CompilerUtils.tagMethodParameters(definition.header, true);
+		
         final String signature = CompilerUtils.calcSign(definition.header, false);
 		
 		final JavaClassInfo toClass = new JavaClassInfo(CompilerUtils.calcClasName(definition.position));
 		final JavaMethodInfo methodInfo = new JavaMethodInfo(toClass, definition.name, CompilerUtils.calcDesc(definition.header, false), CompilerUtils.calcAccess(definition.modifiers) | Opcodes.ACC_STATIC);
 
-		final JavaWriter writer = new JavaWriter(outerWriter, true, methodInfo, signature, null);
+		final JavaWriter writer = new JavaWriter(outerWriter, true, methodInfo, definition, signature, null);
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(writer);
         statementVisitor.start();
-        final Iterator<Statement> statementIterator = definition.statements.iterator();
-
-        //TODO this is dirty, fix when there is a way of knowing if a parameter is static or not
-        for (FunctionParameter parameter : definition.header.parameters) {
-            parameter.index -= 1;
-        }
-        while (statementIterator.hasNext()) {
-            final Statement statement = statementIterator.next();
-            statement.accept(statementVisitor);
-            if (!statementIterator.hasNext() && !(statement instanceof ReturnStatement)) {
-                ITypeID type = definition.header.returnType;
-                if (CompilerUtils.isPrimitive(type))
-                    writer.iConst0();
-                else if (type != BasicTypeID.VOID)
-                    writer.aConstNull();
-                writer.returnType(type.accept(JavaTypeVisitor.INSTANCE));
-            }
+		boolean returns = definition.statement.accept(statementVisitor);
+		if (!returns) {
+			ITypeID type = definition.header.returnType;
+			if (CompilerUtils.isPrimitive(type))
+				writer.iConst0();
+			else if (type != BasicTypeID.VOID)
+				writer.aConstNull();
+			writer.returnType(type.accept(JavaTypeVisitor.INSTANCE));
         }
 
         statementVisitor.end();

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaMemberVisitor.java

 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
-import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.member.*;
-import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.javabytecode.JavaClassInfo;
-import org.openzen.zenscript.javabytecode.JavaEnumInfo;
 import org.openzen.zenscript.javabytecode.JavaFieldInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
+import org.openzen.zenscript.javabytecode.JavaParameterInfo;
 import org.openzen.zenscript.javabytecode.compiler.*;
 
 public class JavaMemberVisitor implements MemberVisitor<Void> {
 
     private final ClassWriter writer;
 	private final JavaClassInfo toClass;
+	private final HighLevelDefinition definition;
 
-    public JavaMemberVisitor(ClassWriter writer, JavaClassInfo toClass) {
+    public JavaMemberVisitor(ClassWriter writer, JavaClassInfo toClass, HighLevelDefinition definition) {
         this.writer = writer;
 		this.toClass = toClass;
+		this.definition = definition;
     }
 
     @Override
 
     @Override
     public Void visitConstructor(ConstructorMember member) {
-        final boolean isEnum = member.hasTag(JavaEnumInfo.class);
+		System.out.println("Compiling constructor " + member.header.toString());
+		
+        final boolean isEnum = definition instanceof EnumDefinition;
 		String descriptor = CompilerUtils.calcDesc(member.header, isEnum);
 		final JavaMethodInfo method = new JavaMethodInfo(toClass, "<init>", descriptor, isEnum ? Opcodes.ACC_PRIVATE : CompilerUtils.calcAccess(member.modifiers));
 		
         final Label constructorStart = new Label();
         final Label constructorEnd = new Label();
-        final JavaWriter constructorWriter = new JavaWriter(writer, method, CompilerUtils.calcSign(member.header, isEnum), null);
+        final JavaWriter constructorWriter = new JavaWriter(writer, method, definition, CompilerUtils.calcSign(member.header, isEnum), null);
         constructorWriter.label(constructorStart);
+		CompilerUtils.tagConstructorParameters(member.header, isEnum);
         for (FunctionParameter parameter : member.header.parameters) {
-            if(isEnum)
-                parameter.index += 2;
-            constructorWriter.nameVariable(parameter.index + 1, parameter.name, constructorStart, constructorEnd, Type.getType(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
+            constructorWriter.nameVariable(
+					parameter.getTag(JavaParameterInfo.class).index,
+					parameter.name,
+					constructorStart,
+					constructorEnd,
+					Type.getType(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
         }
+		
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(constructorWriter);
         statementVisitor.start();
-
-        for (Statement statement : member.body) {
-            statement.accept(statementVisitor);
-        }
+		
+		if (!member.isConstructorForwarded()) {
+			if (isEnum) {
+				System.out.println("Writing enum constructor");
+				constructorWriter.getVisitor().newLocal(Type.getType(String.class));
+				constructorWriter.getVisitor().newLocal(Type.getType(int.class));
+				constructorWriter.loadObject(0);
+				constructorWriter.loadObject(1);
+				constructorWriter.loadInt(2);
+				constructorWriter.invokeSpecial(Type.getInternalName(Enum.class), "<init>", "(Ljava/lang/String;I)V");
+			} else if (definition.superType == null) {
+				System.out.println("Writing regular constructor");
+				constructorWriter.load(Type.getType(Object.class), 0);
+				constructorWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
+			}
+			
+			CompilerUtils.writeDefaultFieldInitializers(constructorWriter, definition);
+		}
+		
+        member.body.accept(statementVisitor);
         constructorWriter.label(constructorEnd);
         statementVisitor.end();
         return null;
 
     @Override
     public Void visitMethod(MethodMember member) {
-        final boolean isAbstract = member.body == null || member.body.isEmpty() || Modifiers.isAbstract(member.modifiers);
+		CompilerUtils.tagMethodParameters(member.header, member.isStatic());
+		
+        final boolean isAbstract = member.body == null || Modifiers.isAbstract(member.modifiers);
 		int modifiers = (isAbstract ? Opcodes.ACC_ABSTRACT : 0)
 				| (member.isStatic() ? Opcodes.ACC_STATIC : 0)
 				| CompilerUtils.calcAccess(member.modifiers);
 		
         final Label methodStart = new Label();
         final Label methodEnd = new Label();
-        final JavaWriter methodWriter = new JavaWriter(writer, method, CompilerUtils.calcSign(member.header, false), null);
+        final JavaWriter methodWriter = new JavaWriter(writer, method, definition, CompilerUtils.calcSign(member.header, false), null);
         methodWriter.label(methodStart);
         for (final FunctionParameter parameter : member.header.parameters) {
             methodWriter.nameParameter(0, parameter.name);
             if (!isAbstract)
-                methodWriter.nameVariable(parameter.index + (member.isStatic() ? 0 : 1), parameter.name, methodStart, methodEnd, Type.getType(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
+                methodWriter.nameVariable(parameter.getTag(JavaParameterInfo.class).index, parameter.name, methodStart, methodEnd, Type.getType(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
         }
 
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(methodWriter);
 
         if (!isAbstract) {
             statementVisitor.start();
-            for (Statement statement : member.body) {
-                statement.accept(statementVisitor);
-            }
-
+			member.body.accept(statementVisitor);
             methodWriter.label(methodEnd);
             statementVisitor.end();
         }
 
     @Override
     public Void visitEnumConstant(EnumConstantMember member) {
-        final JavaStatementVisitor clinitVisitor = member.getTag(JavaEnumInfo.class).clinitVisitor;
-        final JavaWriter clinitWriter = clinitVisitor.getJavaWriter();
-        final String internalName = member.constructor.type.accept(JavaTypeVisitor.INSTANCE).getInternalName();
-
-        clinitWriter.newObject(internalName);
-        clinitWriter.dup();
-        clinitWriter.constant(member.name);
-        clinitWriter.constant(member.value);
-        for (Expression argument : member.constructor.arguments.arguments) {
-            argument.accept(clinitVisitor.expressionVisitor);
-        }
-        clinitWriter.invokeSpecial(internalName, "<init>", CompilerUtils.calcDesc(member.constructor.constructor.header, true));
-        clinitWriter.putStaticField(internalName, member.name, "L" + internalName + ";");
-
-
         return null;
     }
 
     public Void visitInnerDefinition(InnerDefinitionMember member) {
         return null;
     }
-
 }

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionFunction.java

 package org.openzen.zenscript.parser.expression;
 
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.FunctionExpression;
 		
 		LambdaClosure closure = new LambdaClosure();
 		StatementScope innerScope = new LambdaScope(scope, closure, header);
-		List<Statement> statements = body.compile(innerScope, header);
+		Statement statements = body.compile(innerScope, header);
 		if (!scope.genericInferenceMap.isEmpty()) {
 			// perform type parameter inference
-			ITypeID returnType = Statement.getReturnType(scope, statements);
+			ITypeID returnType = statements.getReturnType();
 			Map<TypeParameter, ITypeID> inferredTypes = new HashMap<>();
 			if (!genericHeader.returnType.inferTypeParameters(returnType, inferredTypes))
 				throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE, "Could not infer generic type parameters");

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

  */
 package org.openzen.zenscript.parser.statements;
 
-import java.util.Collections;
-import java.util.List;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.statement.EmptyStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.linker.StatementScope;
 import org.openzen.zenscript.shared.CodePosition;
 	}
 	
 	@Override
-	public List<Statement> compile(StatementScope scope, FunctionHeader header) {
-		return Collections.emptyList();
+	public Statement compile(StatementScope scope, FunctionHeader header) {
+		return new EmptyStatement(position);
 	}
 }

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

  */
 package org.openzen.zenscript.parser.statements;
 
-import java.util.List;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.linker.StatementScope;
  * @author Hoofdgebruiker
  */
 public abstract class ParsedFunctionBody {
-	public abstract List<Statement> compile(StatementScope scope, FunctionHeader header);
+	public abstract Statement compile(StatementScope scope, FunctionHeader header);
 }

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

  */
 package org.openzen.zenscript.parser.statements;
 
-import java.util.ArrayList;
-import java.util.List;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 	}
 	
 	@Override
-	public List<Statement> compile(StatementScope scope, FunctionHeader header) {
-		List<Statement> statements = new ArrayList<>();
+	public Statement compile(StatementScope scope, FunctionHeader header) {
 		if (header.returnType == BasicTypeID.VOID) {
 			Expression value = this.value.compile(new ExpressionScope(scope)).eval();
-			statements.add(new ExpressionStatement(value.position, value));
-			statements.add(new ReturnStatement(value.position, null));
+			return new ExpressionStatement(value.position, value);
 		} else {
 			Expression returnValue = value
 					.compile(new ExpressionScope(scope, header.returnType))
 					.eval()
 					.castImplicit(value.position, scope, header.returnType);
-			statements.add(new ReturnStatement(value.position, returnValue));
+			return new ReturnStatement(value.position, returnValue);
 		}
-		return statements;
 	}
 }

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

 
 public abstract class ParsedStatement {
 	public static ParsedFunctionBody parseLambdaBody(ZSTokenStream tokens, boolean inExpression) {
+		ZSToken start = tokens.peek();
 		if (tokens.optional(T_AOPEN) != null) {
 			List<ParsedStatement> statements = new ArrayList<>();
 			while (tokens.optional(T_ACLOSE) == null)
 				statements.add(ParsedStatement.parse(tokens));
 			
-			return new ParsedStatementsFunctionBody(statements);
+			return new ParsedStatementsFunctionBody(new ParsedStatementBlock(start.position, null, null, statements));
 		} else {
 			ParsedFunctionBody result = new ParsedLambdaFunctionBody(ParsedExpression.parse(tokens));
 			if (!inExpression)
 	}
 	
 	public static ParsedFunctionBody parseFunctionBody(ZSTokenStream tokens) {
+		ZSToken start = tokens.peek();
 		if (tokens.optional(T_LAMBDA) != null) {
 			return parseLambdaBody(tokens, false);
 		} else if (tokens.optional(T_SEMICOLON) != null) {
 			while (tokens.optional(T_ACLOSE) == null) {
 				statements.add(ParsedStatement.parse(tokens));
 			}
-			return new ParsedStatementsFunctionBody(statements);
+			return new ParsedStatementsFunctionBody(new ParsedStatementBlock(start.position, null, null, statements));
 		}
 	}
 	

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

  */
 package org.openzen.zenscript.parser.statements;
 
-import java.util.List;
-import java.util.stream.Collectors;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.linker.StatementScope;
  * @author Hoofdgebruiker
  */
 public class ParsedStatementsFunctionBody extends ParsedFunctionBody {
-	private final List<ParsedStatement> statements;
+	private final ParsedStatement body;
 	
-	public ParsedStatementsFunctionBody(List<ParsedStatement> statements) {
-		this.statements = statements;
+	public ParsedStatementsFunctionBody(ParsedStatement body) {
+		this.body = body;
 	}
 	
 	@Override
-	public List<Statement> compile(StatementScope scope, FunctionHeader header) {
-		return statements.stream()
-				.map(s -> s.compile(scope))
-				.collect(Collectors.toList());
+	public Statement compile(StatementScope scope, FunctionHeader header) {
+		return body.compile(scope);
 	}
 }

Validator/src/main/java/org/openzen/zenscript/validator/ValidationLogEntry.java

 		VARIADIC_PARAMETER_MUST_BE_LAST,
 		CONSTRUCTOR_FORWARD_OUTSIDE_CONSTRUCTOR,
 		CONSTRUCTOR_FORWARD_NOT_FIRST_STATEMENT,
+		CONSTRUCTOR_FORWARD_MISSING,
 		DUPLICATE_CONSTRUCTOR,
 		DUPLICATE_METHOD,
 		BODY_REQUIRED,

Validator/src/main/java/org/openzen/zenscript/validator/visitors/DefinitionMemberValidator.java

 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.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.validator.ValidationLogEntry;
 			validator.logError(ValidationLogEntry.Code.BODY_REQUIRED, member.position, "Constructors must have a body");
 		} else {
 			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header));
-			for (Statement statement : member.body) {
-				isValid &= statement.accept(statementValidator);
-			}
+			isValid &= member.body.accept(statementValidator);
 			
-			if (!statementValidator.constructorForwarded) {
-				// TODO: does this type have a supertype with no-argument constructor?
+			if (member.definition.superType != null && !statementValidator.constructorForwarded) {
+				validator.logError(ValidationLogEntry.Code.CONSTRUCTOR_FORWARD_MISSING, member.position, "Constructor not forwarded to base type");
+				isValid &= false;
 			}
 		}
 		
 		
 		if (member.body != null) {
 			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header));
-			for (Statement statement : member.body) {
-				isValid &= statement.accept(statementValidator);
-			}
+			isValid &= member.body.accept(statementValidator);
 		}
 		
 		return isValid;
 		
 		if (member.body != null) {
 			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header));
-			for (Statement statement : member.body) {
-				isValid &= statement.accept(statementValidator);
-			}
+			isValid &= member.body.accept(statementValidator);
 		}
 		
 		return isValid;
 		
 		if (member.body != null) {
 			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header));
-			for (Statement statement : member.body) {
-				isValid &= statement.accept(statementValidator);
-			}
+			isValid &= member.body.accept(statementValidator);
 		}
 		
 		return isValid;
 		
 		if (member.body != null) {
 			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header));
-			for (Statement statement : member.body) {
-				isValid &= statement.accept(statementValidator);
-			}
+			isValid &= member.body.accept(statementValidator);
 		}
 		
 		return isValid;
 		
 		if (member.body != null) {
 			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header));
-			for (Statement statement : member.body) {
-				isValid &= statement.accept(statementValidator);
-			}
+			isValid &= member.body.accept(statementValidator);
 		}
 		
 		return isValid;
 		
 		if (member.body != null) {
 			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header));
-			for (Statement statement : member.body) {
-				isValid &= statement.accept(statementValidator);
-			}
+			isValid &= member.body.accept(statementValidator);
 		}
 		
 		return isValid;

Validator/src/main/java/org/openzen/zenscript/validator/visitors/DefinitionValidator.java

 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.definition.StructDefinition;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
-import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.validator.Validator;
 import org.openzen.zenscript.validator.analysis.StatementScope;
 
 				definition.name);
 				
 		StatementValidator statementValidator = new StatementValidator(validator, new FunctionStatementScope(definition.header));
-		for (Statement statement : definition.statements) {
-			isValid &= statement.accept(statementValidator);
-		}
+		isValid &= definition.statement.accept(statementValidator);
 		return isValid;
 	}