- Added static initializers

- Added switch statements
- Started work on increment and decrement operators
- Starting work on Constructor, the build tool

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

 import org.openzen.zenscript.codemodel.expression.NewExpression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.expression.OrOrExpression;
+import org.openzen.zenscript.codemodel.expression.PostCallExpression;
 import org.openzen.zenscript.codemodel.expression.RangeExpression;
 import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
 import org.openzen.zenscript.codemodel.expression.SetFunctionParameterExpression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
 import org.openzen.zenscript.codemodel.member.OperatorMember;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.StringUtils;
 
 /**
 					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " &= ");
 				case XORASSIGN:
 					return binary(expression.target, expression.getFirstArgument(), OperatorPriority.XORASSIGN, " ^= ");
-				case POST_INCREMENT:
-					return unaryPostfix(expression.target, OperatorPriority.DECREMENT, "++");
-				case POST_DECREMENT:
-					return unaryPostfix(expression.target, OperatorPriority.DECREMENT, "--");
-				case PRE_INCREMENT:
+				case INCREMENT:
 					return unaryPrefix(expression.target, OperatorPriority.DECREMENT, "++");
-				case PRE_DECREMENT:
+				case DECREMENT:
 					return unaryPrefix(expression.target, OperatorPriority.DECREMENT, "--");
 				case CALL: {
 					StringBuilder result = new StringBuilder();
 	public ExpressionString visitOrOr(OrOrExpression expression) {
 		return binary(expression.left, expression.right, OperatorPriority.OROR, " || ");
 	}
+	
+	@Override
+	public ExpressionString visitPostCall(PostCallExpression expression) {
+		return unaryPostfix(expression.target, OperatorPriority.INCREMENT, expression.member.operator == OperatorType.INCREMENT ? "++" : "--");
+	}
 
 	@Override
 	public ExpressionString visitRange(RangeExpression expression) {

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

 import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.StatementVisitor;
+import org.openzen.zenscript.codemodel.statement.SwitchStatement;
 import org.openzen.zenscript.codemodel.statement.ThrowStatement;
 import org.openzen.zenscript.codemodel.statement.TryCatchStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 			return null;
 		}
 
+		@Override
+		public Void visitSwitch(SwitchStatement statement) {
+			return statementFormatter.visitSwitch(statement);
+		}
+
 		@Override
 		public Void visitThrow(ThrowStatement statement) {
 			return statementFormatter.visitThrow(statement);

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

  */
 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.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.member.StaticInitializerMember;
 import org.openzen.zenscript.codemodel.statement.Statement;
 
 /**
 			case ANDASSIGN: output.append("&="); break;
 			case XORASSIGN: output.append("^="); break;
 	
-			case POST_INCREMENT: output.append("++"); break;
-			case POST_DECREMENT: output.append("--"); break;
+			case INCREMENT: output.append("++"); break;
+			case DECREMENT: output.append("--"); break;
 			default:
 				throw new UnsupportedOperationException("Unknown operator: " + member.operator);
 		}
 	private void formatBody(Statement body) {
 		FormattingUtils.formatBody(output, settings, indent, typeFormatter, body);
 	}
+
+	@Override
+	public Void visitStaticInitializer(StaticInitializerMember member) {
+		visit(false);
+		output.append("static ");
+		formatBody(member.body);
+		return null;
+	}
 }

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

 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.SwitchCase;
+import org.openzen.zenscript.codemodel.statement.SwitchStatement;
 import org.openzen.zenscript.codemodel.statement.ThrowStatement;
 import org.openzen.zenscript.codemodel.statement.TryCatchStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 		return null;
 	}
 
+	@Override
+	public Void visitSwitch(SwitchStatement statement) {
+		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);
+		beginSingleLine(whitespace);
+		output.append("switch ");
+		if (statement.label != null)
+			output.append(':').append(statement.label);
+		
+		output.append(settings.getBlockSeparator(indent, position));
+		
+		StatementFormatter innerFormatter = new StatementFormatter(output, indent + settings.indent + settings.indent, settings, expressionFormatter);
+		for (SwitchCase switchCase : statement.cases) {
+			if (switchCase.value == null) {
+				output.append(indent).append(settings.indent).append("default:\n");
+			} else {
+				output.append(indent)
+						.append(settings.indent)
+						.append("case ")
+						.append(switchCase.value.accept(expressionFormatter))
+						.append(":\n");
+			}
+			for (Statement s : switchCase.statements)
+				s.accept(innerFormatter);
+		}
+		
+		output.append("\n").append(indent).append("}");
+		endSingleLine(whitespace);
+		return null;
+	}
+
 	@Override
 	public Void visitThrow(ThrowStatement statement) {
 		WhitespaceInfo whitespace = statement.getTag(WhitespaceInfo.class);

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

 import org.openzen.zenscript.codemodel.type.ConstTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
+import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.ITypeVisitor;
 	public String visitType(ParameterTypeBound bound) {
 		return bound.type.accept(this);
 	}
+
+	@Override
+	public String visitGenericMap(GenericMapTypeID map) {
+		StringBuilder result = new StringBuilder();
+		result.append(map.value.accept(this));
+		result.append("[");
+		FormattingUtils.formatTypeParameters(result, map.keys, this);
+		result.append("]");
+		return result.toString();
+	}
 }

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

 		this.parameters = parameters;
 	}
 	
-	public FunctionHeader(TypeParameter[] genericParameters, ITypeID returnType, FunctionParameter[] parameters) {
+	public FunctionHeader(TypeParameter[] genericParameters, ITypeID returnType, FunctionParameter... parameters) {
 		this.typeParameters = genericParameters;
 		this.returnType = returnType;
 		this.parameters = parameters;

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

 	MEMBERGETTER(".", "getMember"),
 	MEMBERSETTER(".=", "setMember"),
 	EQUALS("==", "equals"),
+	SHL("<<", "shl"),
+	SHR(">>", "shr"),
+	USHR(">>>", "ushr"),
 	
 	ADDASSIGN("+=", "addAssign", ADD),
 	SUBASSIGN("-=", "subAssign", SUB),
 	ORASSIGN("|=", "orAssign", OR),
 	ANDASSIGN("&=", "andAssign", AND),
 	XORASSIGN("^=", "xorAssign", XOR),
+	SHLASSIGN("<<=", "shlAssign", SHL),
+	SHRASSIGN(">>=", "shrAssign", SHR),
+	USHRASSIGN(">>>=", "ushrAssign", USHR),
 	
-	POST_INCREMENT("x++", "postIncrement"),
-	POST_DECREMENT("x--", "postDecrement"),
-	PRE_INCREMENT("++x", "preIncrement"),
-	PRE_DECREMENT("--x", "preDecrement"),
+	INCREMENT("++", "increment"),
+	DECREMENT("--", "decrement"),
+	
+	RANGE("..", "rangeTo"),
 	
 	CONSTRUCTOR("this", "construct"),
 	CALL("()", "call"),

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

 	public FunctionHeader header;
 	public Statement statement;
 	public OperatorMember caller;
-	public DefinitionMemberGroup callerGroup = new DefinitionMemberGroup();
+	public DefinitionMemberGroup callerGroup = new DefinitionMemberGroup(true);
 	
 	public FunctionDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
 		super(position, pkg, name, modifiers, outerDefinition);

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

 	private final Map<String, ZSPackage> subPackages = new HashMap<>();
 	private final Map<String, HighLevelDefinition> types = new HashMap<>();
 	
+	public void add(String name, ZSPackage subPackage) {
+		if (subPackages.containsKey(name))
+			throw new RuntimeException("Such package already exists: " + name);
+		
+		subPackages.put(name, this);
+	}
+	
 	public IPartialExpression getMember(CodePosition position, GlobalTypeRegistry registry, GenericName name) {
 		if (subPackages.containsKey(name.name) && name.arguments.isEmpty())
 			return new PartialPackageExpression(position, subPackages.get(name.name));

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

 	
 	public T visitOrOr(OrOrExpression expression);
 	
+	public T visitPostCall(PostCallExpression expression);
+	
 	public T visitRange(RangeExpression expression);
 	
 	public T visitSetField(SetFieldExpression expression);

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.expression;
+
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.member.OperatorMember;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ * Used for post-increment and post-decrement.
+ * 
+ * @author Hoofdgebruiker
+ */
+public class PostCallExpression extends Expression {
+	public final Expression target;
+	public final OperatorMember member;
+	
+	public PostCallExpression(CodePosition position, Expression target, OperatorMember member, FunctionHeader instancedHeader) {
+		super(position, instancedHeader.returnType);
+		
+		if (member.operator != OperatorType.DECREMENT && member.operator != OperatorType.INCREMENT)
+			throw new IllegalArgumentException("Operator must be increment or decrement");
+		
+		this.target = target;
+		this.member = member;
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitPostCall(this);
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/TypeParameter.java

 	}
 	
 	public String toString() {
-		return name + "[" + position.toShortString() + "]";
+		return name + "@" + position.toShortString();
 	}
 }

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

 	public T visitImplementation(ImplementationMember member);
 	
 	public T visitInnerDefinition(InnerDefinitionMember member);
+	
+	public T visitStaticInitializer(StaticInitializerMember member);
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/StaticInitializerMember.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.member;
+
+import java.util.Map;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+import org.openzen.zenscript.shared.CodePosition;
+import org.openzen.zenscript.shared.Taggable;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class StaticInitializerMember extends Taggable implements IDefinitionMember {
+	private final CodePosition position;
+	public Statement body;
+	
+	public StaticInitializerMember(CodePosition position) {
+		this.position = position;
+	}
+	
+	@Override
+	public CodePosition getPosition() {
+		return position;
+	}
+
+	@Override
+	public String describe() {
+		return "static initializer";
+	}
+
+	@Override
+	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
+		
+	}
+
+	@Override
+	public IDefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
+		return this;
+	}
+
+	@Override
+	public <T> T accept(MemberVisitor<T> visitor) {
+		return visitor.visitStaticInitializer(this);
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/StringCharIterator.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.member.builtin;
+
+import java.util.Map;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.IIteratorMember;
+import org.openzen.zenscript.codemodel.member.MemberVisitor;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+import org.openzen.zenscript.shared.CodePosition;
+import org.openzen.zenscript.shared.Taggable;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class StringCharIterator extends Taggable implements IIteratorMember {
+	private static final ITypeID[] TYPES = new ITypeID[] { BasicTypeID.CHAR };
+
+	@Override
+	public int getLoopVariableCount() {
+		return 1;
+	}
+
+	@Override
+	public ITypeID[] getLoopVariableTypes() {
+		return TYPES;
+	}
+
+	@Override
+	public <T> T acceptForIterator(ForeachIteratorVisitor<T> visitor) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public CodePosition getPosition() {
+		return CodePosition.BUILTIN;
+	}
+
+	@Override
+	public String describe() {
+		return "string character iterator";
+	}
+
+	@Override
+	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
+		type.addIterator(this, priority);
+	}
+
+	@Override
+	public IDefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
+		return this;
+	}
+
+	@Override
+	public <T> T accept(MemberVisitor<T> visitor) {
+		throw new UnsupportedOperationException("Not a compilable member");
+	}
+}

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

  */
 public class PartialStaticMemberGroupExpression implements IPartialExpression {
 	public static PartialStaticMemberGroupExpression forMethod(CodePosition position, ITypeID target, ICallableMember method) {
-		DefinitionMemberGroup group = new DefinitionMemberGroup();
+		DefinitionMemberGroup group = new DefinitionMemberGroup(true);
 		group.addMethod(method, TypeMemberPriority.SPECIFIED);
 		return new PartialStaticMemberGroupExpression(position, target, group);
 	}

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

 	
 	public T visitReturn(ReturnStatement statement);
 	
+	public T visitSwitch(SwitchStatement statement);
+	
 	public T visitThrow(ThrowStatement statement);
 	
 	public T visitTryCatch(TryCatchStatement statement);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/SwitchCase.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.statement;
+
+import java.util.List;
+import org.openzen.zenscript.codemodel.expression.Expression;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SwitchCase {
+	public final Expression value;
+	public final List<Statement> statements;
+	
+	public SwitchCase(Expression value, List<Statement> statements) {
+		this.value = value;
+		this.statements = statements;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/SwitchStatement.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.statement;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SwitchStatement extends LoopStatement {
+	public final Expression value;
+	public final List<SwitchCase> cases = new ArrayList<>();
+	
+	public SwitchStatement(CodePosition position, String label, Expression value) {
+		super(position, label);
+		
+		this.value = value;
+	}
+
+	@Override
+	public <T> T accept(StatementVisitor<T> visitor) {
+		return visitor.visitSwitch(this);
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/ArrayTypeID.java

  * @author Hoofdgebruiker
  */
 public class ArrayTypeID implements ITypeID {
+	public static final ArrayTypeID INT = new ArrayTypeID(BasicTypeID.INT, 1);
+	public static final ArrayTypeID CHAR = new ArrayTypeID(BasicTypeID.CHAR, 1);
+	
 	public final ITypeID elementType;
 	public final int dimension;
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/GenericMapTypeID.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.type;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.Objects;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class GenericMapTypeID implements ITypeID {
+	public final ITypeID value;
+	public final TypeParameter[] keys;
+	
+	public GenericMapTypeID(ITypeID value, TypeParameter[] keys) {
+		this.value = value;
+		this.keys = keys;
+	}
+
+	@Override
+	public ITypeID getUnmodified() {
+		return this;
+	}
+
+	@Override
+	public <T> T accept(ITypeVisitor<T> visitor) {
+		return visitor.visitGenericMap(this);
+	}
+
+	@Override
+	public boolean isOptional() {
+		return false;
+	}
+
+	@Override
+	public boolean isConst() {
+		return false;
+	}
+
+	@Override
+	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
+		return registry.getGenericMap(value.withGenericArguments(registry, arguments), keys);
+	}
+
+	@Override
+	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
+		return value.hasInferenceBlockingTypeParameters(parameters);
+	}
+	
+	@Override
+	public String toString() {
+		StringBuilder result = new StringBuilder();
+		result.append(value.toString());
+		result.append("[<");
+		for (int i = 0; i < keys.length; i++) {
+			if (i > 0)
+				result.append(", ");
+			result.append(keys[i].toString());
+		}
+		result.append(">]");
+		return result.toString();
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = 5;
+		hash = 97 * hash + Objects.hashCode(this.value);
+		hash = 97 * hash + Arrays.deepHashCode(this.keys);
+		return hash;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj) {
+			return true;
+		}
+		if (obj == null) {
+			return false;
+		}
+		if (getClass() != obj.getClass()) {
+			return false;
+		}
+		final GenericMapTypeID other = (GenericMapTypeID) obj;
+		if (!Objects.equals(this.value, other.value)) {
+			return false;
+		}
+		if (!Arrays.deepEquals(this.keys, other.keys)) {
+			return false;
+		}
+		return true;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/GlobalTypeRegistry.java

 public class GlobalTypeRegistry {
 	private final Map<ArrayTypeID, ArrayTypeID> arrayTypes = new HashMap<>();
 	private final Map<AssocTypeID, AssocTypeID> assocTypes = new HashMap<>();
+	private final Map<GenericMapTypeID, GenericMapTypeID> genericMapTypes = new HashMap<>();
 	private final Map<IteratorTypeID, IteratorTypeID> iteratorTypes = new HashMap<>();
 	private final Map<FunctionTypeID, FunctionTypeID> functionTypes = new HashMap<>();
 	private final Map<RangeTypeID, RangeTypeID> rangeTypes = new HashMap<>();
 	private final Map<ITypeID, ConstTypeID> constTypes = new HashMap<>();
 	private final Map<ITypeID, OptionalTypeID> optionalTypes = new HashMap<>();
 	
+	public GlobalTypeRegistry() {
+		arrayTypes.put(ArrayTypeID.INT, ArrayTypeID.INT);
+		arrayTypes.put(ArrayTypeID.CHAR, ArrayTypeID.CHAR);
+		
+		rangeTypes.put(RangeTypeID.INT, RangeTypeID.INT);
+	}
+	
 	public ArrayTypeID getArray(ITypeID baseType, int dimension) {
 		ArrayTypeID id = new ArrayTypeID(baseType, dimension);
 		if (arrayTypes.containsKey(id)) {
 		}
 	}
 	
+	public GenericMapTypeID getGenericMap(ITypeID valueType, TypeParameter[] keys) {
+		GenericMapTypeID id = new GenericMapTypeID(valueType, keys);
+		if (genericMapTypes.containsKey(id)) {
+			return genericMapTypes.get(id);
+		} else {
+			genericMapTypes.put(id, id);
+			return id;
+		}
+	}
+	
 	public IteratorTypeID getIterator(ITypeID[] loopTypes) {
 		IteratorTypeID id = new IteratorTypeID(loopTypes);
 		if (iteratorTypes.containsKey(id)) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/ITypeID.java

 			
 			return pattern.accept(new MatchingTypeVisitor(type, mapping));
 		}
+
+		@Override
+		public Boolean visitGenericMap(GenericMapTypeID map) {
+			return map == type; // TODO: improve this
+		}
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/ITypeVisitor.java

 	
 	public T visitAssoc(AssocTypeID assoc);
 	
+	public T visitGenericMap(GenericMapTypeID map);
+	
 	public T visitIterator(IteratorTypeID iterator);
 	
 	public T visitFunction(FunctionTypeID function);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/RangeTypeID.java

  * @author Hoofdgebruiker
  */
 public class RangeTypeID implements ITypeID {
+	public static final RangeTypeID INT = new RangeTypeID(BasicTypeID.INT, BasicTypeID.INT);
+	
 	public final ITypeID from;
 	public final ITypeID to;
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/TypeExpansionRegistry.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.type;
-
-import java.util.ArrayList;
-import java.util.List;
-import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class TypeExpansionRegistry {
-	private final List<ExpansionDefinition> expansions = new ArrayList<>();
-	
-	public void register(ExpansionDefinition expansion) {
-		expansions.add(expansion);
-	}
-}

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

 import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantLongExpression;
 import org.openzen.zenscript.codemodel.member.CasterMember;
+import org.openzen.zenscript.codemodel.member.ConstructorMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.MethodMember;
 import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.codemodel.member.builtin.ConstantGetterMember;
+import org.openzen.zenscript.codemodel.type.ArrayTypeID;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import static org.openzen.zenscript.codemodel.type.BasicTypeID.*;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.shared.CodePosition;
 import static org.openzen.zenscript.shared.CodePosition.BUILTIN;
 
 	public static final OperatorMember FLOAT_NEG = neg(T_FLOAT, FLOAT);
 	public static final OperatorMember DOUBLE_NEG = neg(T_DOUBLE, DOUBLE);
 	
+	public static final OperatorMember BYTE_INC = inc(T_BYTE, BYTE);
+	public static final OperatorMember SBYTE_INC = inc(T_SBYTE, SBYTE);
+	public static final OperatorMember SHORT_INC = inc(T_SHORT, SHORT);
+	public static final OperatorMember USHORT_INC = inc(T_USHORT, USHORT);
+	public static final OperatorMember INT_INC = inc(T_INT, INT);
+	public static final OperatorMember UINT_INC = inc(T_UINT, UINT);
+	public static final OperatorMember LONG_INC = inc(T_LONG, LONG);
+	public static final OperatorMember ULONG_INC = inc(T_ULONG, ULONG);
+	
+	public static final OperatorMember BYTE_DEC = dec(T_BYTE, BYTE);
+	public static final OperatorMember SBYTE_DEC = dec(T_SBYTE, SBYTE);
+	public static final OperatorMember SHORT_DEC = dec(T_SHORT, SHORT);
+	public static final OperatorMember USHORT_DEC = dec(T_USHORT, USHORT);
+	public static final OperatorMember INT_DEC = dec(T_INT, INT);
+	public static final OperatorMember UINT_DEC = dec(T_UINT, UINT);
+	public static final OperatorMember LONG_DEC = dec(T_LONG, LONG);
+	public static final OperatorMember ULONG_DEC = dec(T_ULONG, ULONG);
+	
 	public static final OperatorMember BYTE_ADD_BYTE = add(T_BYTE, BYTE, BYTE);
 	public static final OperatorMember SBYTE_ADD_SBYTE = add(T_SBYTE, SBYTE, SBYTE);
 	public static final OperatorMember SHORT_ADD_SHORT = add(T_SHORT, SHORT, SHORT);
 	public static final OperatorMember LONG_MOD_LONG = mod(T_LONG, LONG, LONG);
 	public static final OperatorMember ULONG_MOD_ULONG = mod(T_ULONG, ULONG, ULONG);
 	
+	public static final OperatorMember BYTE_OR_BYTE = or(T_BYTE, BYTE, BYTE);
+	public static final OperatorMember SBYTE_OR_SBYTE = or(T_SBYTE, SBYTE, SBYTE);
+	public static final OperatorMember SHORT_OR_SHORT = or(T_SHORT, SHORT, SHORT);
+	public static final OperatorMember USHORT_OR_USHORT = or(T_USHORT, USHORT, USHORT);
+	public static final OperatorMember INT_OR_INT = or(T_INT, INT, INT);
+	public static final OperatorMember UINT_OR_UINT = or(T_UINT, UINT, UINT);
+	public static final OperatorMember LONG_OR_LONG = or(T_LONG, LONG, LONG);
+	public static final OperatorMember ULONG_OR_ULONG = or(T_ULONG, ULONG, ULONG);
+	
+	public static final OperatorMember BYTE_AND_BYTE = and(T_BYTE, BYTE, BYTE);
+	public static final OperatorMember SBYTE_AND_SBYTE = and(T_SBYTE, SBYTE, SBYTE);
+	public static final OperatorMember SHORT_AND_SHORT = and(T_SHORT, SHORT, SHORT);
+	public static final OperatorMember USHORT_AND_USHORT = and(T_USHORT, USHORT, USHORT);
+	public static final OperatorMember INT_AND_INT = and(T_INT, INT, INT);
+	public static final OperatorMember UINT_AND_UINT = and(T_UINT, UINT, UINT);
+	public static final OperatorMember LONG_AND_LONG = and(T_LONG, LONG, LONG);
+	public static final OperatorMember ULONG_AND_ULONG = and(T_ULONG, ULONG, ULONG);
+	
+	public static final OperatorMember BYTE_XOR_BYTE = xor(T_BYTE, BYTE, BYTE);
+	public static final OperatorMember SBYTE_XOR_SBYTE = xor(T_SBYTE, SBYTE, SBYTE);
+	public static final OperatorMember SHORT_XOR_SHORT = xor(T_SHORT, SHORT, SHORT);
+	public static final OperatorMember USHORT_XOR_USHORT = xor(T_USHORT, USHORT, USHORT);
+	public static final OperatorMember INT_XOR_INT = xor(T_INT, INT, INT);
+	public static final OperatorMember UINT_XOR_UINT = xor(T_UINT, UINT, UINT);
+	public static final OperatorMember LONG_XOR_LONG = xor(T_LONG, LONG, LONG);
+	public static final OperatorMember ULONG_XOR_ULONG = xor(T_ULONG, ULONG, ULONG);
+	
+	public static final OperatorMember INT_SHL = shl(T_INT, UINT, INT);
+	public static final OperatorMember INT_SHR = shr(T_INT, UINT, INT);
+	public static final OperatorMember INT_USHR = ushr(T_INT, UINT, INT);
+	
+	public static final OperatorMember UINT_SHL = shl(T_UINT, UINT, UINT);
+	public static final OperatorMember UINT_SHR = shr(T_UINT, UINT, UINT);
+	
+	public static final OperatorMember LONG_SHL = shl(T_LONG, UINT, LONG);
+	public static final OperatorMember LONG_SHR = shr(T_LONG, UINT, LONG);
+	public static final OperatorMember LONG_USHR = ushr(T_LONG, UINT, LONG);
+	
+	public static final OperatorMember ULONG_SHL = shl(T_ULONG, UINT, ULONG);
+	public static final OperatorMember ULONG_SHR = shr(T_ULONG, UINT, ULONG);
+	
 	public static final CasterMember INT_TO_BYTE = castExplicit(T_BYTE, BYTE);
 	public static final CasterMember INT_TO_SBYTE = castExplicit(T_SBYTE, SBYTE);
 	public static final CasterMember INT_TO_SHORT = castExplicit(T_SHORT, SHORT);
 	public static final MethodMember FLOAT_FROMBITS = new MethodMember(BUILTIN, T_FLOAT, Modifiers.STATIC, "fromBits", new FunctionHeader(FLOAT, new FunctionParameter(UINT)));
 	public static final MethodMember DOUBLE_FROMBITS = new MethodMember(BUILTIN, T_FLOAT, Modifiers.STATIC, "fromBits", new FunctionHeader(DOUBLE, new FunctionParameter(ULONG)));
 	
+	public static final ConstructorMember STRING_CONSTRUCTOR_CHARACTERS
+			= new ConstructorMember(BUILTIN, T_STRING, Modifiers.EXPORT | Modifiers.EXTERN, new FunctionHeader(VOID, new FunctionParameter(ArrayTypeID.CHAR)));
+	public static final ConstructorMember STRING_CONSTRUCTOR_CHARACTER_RANGE
+			= new ConstructorMember(BUILTIN, T_STRING, Modifiers.EXPORT | Modifiers.EXTERN, new FunctionHeader(
+					VOID,
+					new FunctionParameter(ArrayTypeID.CHAR),
+					new FunctionParameter(BasicTypeID.INT),
+					new FunctionParameter(BasicTypeID.INT)));
+	public static final OperatorMember STRING_INDEXGET = new OperatorMember(BUILTIN, T_STRING, Modifiers.EXPORT | Modifiers.EXTERN, OperatorType.INDEXGET, new FunctionHeader(CHAR, new FunctionParameter(INT)));
+	public static final OperatorMember STRING_RANGEGET = new OperatorMember(BUILTIN, T_STRING, Modifiers.EXPORT | Modifiers.EXTERN, OperatorType.INDEXGET, new FunctionHeader(STRING, new FunctionParameter(RangeTypeID.INT)));
+	public static final GetterMember STRING_LENGTH = new GetterMember(BUILTIN, T_STRING, Modifiers.EXPORT | Modifiers.EXTERN, "length", INT);
+	
 	private static OperatorMember not(ClassDefinition cls, ITypeID result) {
 		return new OperatorMember(BUILTIN, cls, 0, OperatorType.NOT, new FunctionHeader(result));
 	}
 		return new OperatorMember(BUILTIN, cls, 0, OperatorType.NEG, new FunctionHeader(result));
 	}
 	
+	private static OperatorMember inc(ClassDefinition cls, ITypeID result) {
+		return new OperatorMember(BUILTIN, cls, 0, OperatorType.INCREMENT, new FunctionHeader(result));
+	}
+	
+	private static OperatorMember dec(ClassDefinition cls, ITypeID result) {
+		return new OperatorMember(BUILTIN, cls, 0, OperatorType.DECREMENT, new FunctionHeader(result));
+	}
+	
 	private static OperatorMember add(ClassDefinition cls, ITypeID operand, ITypeID result) {
 		return new OperatorMember(BUILTIN, cls, 0, OperatorType.ADD, new FunctionHeader(result, new FunctionParameter(operand)));
 	}
 		return new OperatorMember(BUILTIN, cls, 0, OperatorType.MOD, new FunctionHeader(result, new FunctionParameter(operand)));
 	}
 	
+	private static OperatorMember shl(ClassDefinition cls, ITypeID operand, ITypeID result) {
+		return new OperatorMember(BUILTIN, cls, 0, OperatorType.SHL, new FunctionHeader(result, new FunctionParameter(operand)));
+	}
+	
+	private static OperatorMember shr(ClassDefinition cls, ITypeID operand, ITypeID result) {
+		return new OperatorMember(BUILTIN, cls, 0, OperatorType.SHR, new FunctionHeader(result, new FunctionParameter(operand)));
+	}
+	
+	private static OperatorMember ushr(ClassDefinition cls, ITypeID operand, ITypeID result) {
+		return new OperatorMember(BUILTIN, cls, 0, OperatorType.USHR, new FunctionHeader(result, new FunctionParameter(operand)));
+	}
+	
+	private static OperatorMember or(ClassDefinition cls, ITypeID operand, ITypeID result) {
+		return new OperatorMember(BUILTIN, cls, 0, OperatorType.OR, new FunctionHeader(result, new FunctionParameter(operand)));
+	}
+	
+	private static OperatorMember and(ClassDefinition cls, ITypeID operand, ITypeID result) {
+		return new OperatorMember(BUILTIN, cls, 0, OperatorType.AND, new FunctionHeader(result, new FunctionParameter(operand)));
+	}
+	
+	private static OperatorMember xor(ClassDefinition cls, ITypeID operand, ITypeID result) {
+		return new OperatorMember(BUILTIN, cls, 0, OperatorType.XOR, new FunctionHeader(result, new FunctionParameter(operand)));
+	}
+	
 	private static CasterMember castExplicit(ClassDefinition cls, ITypeID result) {
 		return new CasterMember(CodePosition.BUILTIN, cls, 0, result);
 	}

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.expression.PostCallExpression;
+import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.shared.CompileException;
 import org.openzen.zenscript.shared.CompileExceptionCode;
  */
 public class DefinitionMemberGroup {
 	public static DefinitionMemberGroup forMethod(ICallableMember member) {
-		DefinitionMemberGroup instance = new DefinitionMemberGroup();
+		DefinitionMemberGroup instance = new DefinitionMemberGroup(member.isStatic());
 		instance.addMethod(member, TypeMemberPriority.SPECIFIED);
 		return instance;
 	}
 	private TypeMember<IGettableMember> getter;
 	private TypeMember<SetterMember> setter;
 	private final List<TypeMember<ICallableMember>> methods = new ArrayList<>();
+	public final boolean isStatic;
+	
+	public DefinitionMemberGroup(boolean isStatic) {
+		this.isStatic = isStatic;
+	}
 	
 	public void merge(CodePosition position, DefinitionMemberGroup other, TypeMemberPriority priority) {
 		if (other.field != null)
 		return this.setter == null ? null : this.setter.member;
 	}
 	
+	public boolean hasMethods() {
+		return !methods.isEmpty();
+	}
+	
 	public List<TypeMember<ICallableMember>> getMethodMembers() {
 		return this.methods;
 	}
 		return method.call(position, target, instancedHeader, arguments);
 	}
 	
+	public Expression callPostfix(CodePosition position, TypeScope scope, Expression target) {
+		if (methods.isEmpty())
+			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "There is no such operator");
+		
+		ICallableMember method = methods.get(0).member;
+		if (!(method instanceof OperatorMember)) {
+			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Member is not an operator");
+		}
+		OperatorMember operator = (OperatorMember) method;
+		return new PostCallExpression(position, target, operator, operator.header);
+	}
+	
 	public Expression callWithComparator(
 			CodePosition position,
 			TypeScope scope,

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

 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CompileException;
+import org.openzen.zenscript.shared.CompileExceptionCode;
 
 /**
  *
 		members.type.accept(new TypeMemberBuilder(members, this));
 		
 		for (ExpansionDefinition expansion : expansions) {
+			if (expansion.target == null)
+				throw new CompileException(expansion.position, CompileExceptionCode.INTERNAL_ERROR, "Missing expansion target");
+			
 			Map<TypeParameter, ITypeID> mapping = matchType(members.type, expansion.target);
 			if (mapping != null) {
 				if (mapping.isEmpty()) {

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

 import org.openzen.zenscript.codemodel.member.builtin.ComparatorMember;
 import org.openzen.zenscript.codemodel.member.builtin.ConstantGetterMember;
 import org.openzen.zenscript.codemodel.member.builtin.RangeIterator;
+import org.openzen.zenscript.codemodel.member.builtin.StringCharIterator;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ConstTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
+import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.ITypeVisitor;
 
 		FunctionParameter[] indexGetParameters = new FunctionParameter[dimension];
 		for (int i = 0; i < dimension; i++)
-			indexGetParameters[i] = new FunctionParameter(INT, null);
+			indexGetParameters[i] = new FunctionParameter(INT);
 
 		FunctionHeader indexGetHeader = new FunctionHeader(baseType, indexGetParameters);
 		members.addOperator(new OperatorMember(BUILTIN, definition, 0, OperatorType.INDEXGET, indexGetHeader), TypeMemberPriority.SPECIFIED);
 		FunctionHeader sizedConstructorHeader = new FunctionHeader(VOID, indexGetParameters);
 		members.addConstructor(new ConstructorMember(BUILTIN, definition, 0, sizedConstructorHeader), TypeMemberPriority.SPECIFIED);
 
+		FunctionParameter[] initialValueConstructorParameters = new FunctionParameter[dimension + 1];
+		for (int i = 0; i < dimension; i++)
+			initialValueConstructorParameters[i] = new FunctionParameter(INT);
+		initialValueConstructorParameters[dimension] = new FunctionParameter(baseType);
+		FunctionHeader initialValueConstructorHeader = new FunctionHeader(VOID, initialValueConstructorParameters);
+		members.addConstructor(new ConstructorMember(BUILTIN, definition, 0, initialValueConstructorHeader));
+		
 		FunctionParameter[] lambdaConstructorParameters = new FunctionParameter[dimension + 1];
 		for (int i = 0; i < dimension; i++)
 			lambdaConstructorParameters[i] = new FunctionParameter(INT, null);
 		
 		ClassDefinition definition = new ClassDefinition(BUILTIN, null, "", Modifiers.EXPORT);
 		
-		members.addConstructor(new ConstructorMember(BUILTIN, definition, 0, new FunctionHeader(VOID)), TypeMemberPriority.SPECIFIED);
+		members.addConstructor(new ConstructorMember(BUILTIN, definition, 0, new FunctionHeader(VOID)));
 
 		FunctionHeader indexGetHeader = new FunctionHeader(valueType, new FunctionParameter(keyType, "key"));
-		members.addOperator(new OperatorMember(BUILTIN, definition, 0, OperatorType.INDEXGET, indexGetHeader), TypeMemberPriority.SPECIFIED);
+		members.addOperator(new OperatorMember(BUILTIN, definition, 0, OperatorType.INDEXGET, indexGetHeader));
 
 		FunctionHeader indexSetHeader = new FunctionHeader(VOID, new FunctionParameter(keyType, "key"), new FunctionParameter(valueType, "value"));
-		members.addOperator(new OperatorMember(BUILTIN, definition, 0, OperatorType.INDEXSET, indexSetHeader), TypeMemberPriority.SPECIFIED);
+		members.addOperator(new OperatorMember(BUILTIN, definition, 0, OperatorType.INDEXSET, indexSetHeader));
 		
 		FunctionHeader getOrDefaultHeader = new FunctionHeader(valueType, new FunctionParameter(keyType, "key"), new FunctionParameter(valueType, "defaultValue"));
-		members.addMethod(new MethodMember(BUILTIN, definition, 0, "getOrDefault", getOrDefaultHeader), TypeMemberPriority.SPECIFIED);
+		members.addMethod(new MethodMember(BUILTIN, definition, 0, "getOrDefault", getOrDefaultHeader));
 		
-		members.addOperator(new OperatorMember(BUILTIN, definition, 0, OperatorType.CONTAINS, new FunctionHeader(BOOL, new FunctionParameter(keyType, "key"))), TypeMemberPriority.SPECIFIED);
+		members.addOperator(new OperatorMember(BUILTIN, definition, 0, OperatorType.CONTAINS, new FunctionHeader(BOOL, new FunctionParameter(keyType, "key"))));
 
-		members.addField(new FieldMember(BUILTIN, definition, Modifiers.FINAL, "length", INT), TypeMemberPriority.SPECIFIED);
-		members.addGetter(new GetterMember(BUILTIN, definition, 0, "empty", BOOL), TypeMemberPriority.SPECIFIED);
-		members.addGetter(new GetterMember(BUILTIN, definition, 0, "keys", cache.getRegistry().getArray(keyType, 1)), TypeMemberPriority.SPECIFIED);
+		members.addField(new FieldMember(BUILTIN, definition, Modifiers.FINAL, "size", INT));
+		members.addGetter(new GetterMember(BUILTIN, definition, 0, "empty", BOOL));
+		members.addGetter(new GetterMember(BUILTIN, definition, 0, "keys", cache.getRegistry().getArray(keyType, 1)));
+		return null;
+	}
+	
+	@Override
+	public Void visitGenericMap(GenericMapTypeID map) {
+		ITypeID valueType = map.value;
+		
+		ClassDefinition definition = new ClassDefinition(BUILTIN, null, "", Modifiers.EXPORT);
+		members.addConstructor(new ConstructorMember(BUILTIN, definition, 0, new FunctionHeader(VOID)));
+		members.addMethod(new MethodMember(BUILTIN, definition, 0, "getOptional", new FunctionHeader(map.keys, valueType, new FunctionParameter[0])));
+		members.addMethod(new MethodMember(BUILTIN, definition, 0, "put", new FunctionHeader(map.keys, BasicTypeID.VOID, new FunctionParameter(valueType))));
+		members.addMethod(new MethodMember(BUILTIN, definition, 0, "contains", new FunctionHeader(map.keys, BasicTypeID.BOOL, new FunctionParameter[0])));
 		return null;
 	}
 	
 		if (definition instanceof EnumDefinition) {
 			members.addGetter(new GetterMember(BUILTIN, definition, 0, "name", BasicTypeID.STRING), TypeMemberPriority.SPECIFIED);
 			members.addGetter(new GetterMember(BUILTIN, definition, 0, "ordinal", BasicTypeID.INT), TypeMemberPriority.SPECIFIED);
+			
+			if (!members.canCast(BasicTypeID.STRING)) {
+				members.addCaster(new CasterMember(BUILTIN, definition, Modifiers.PUBLIC | Modifiers.EXTERN | Modifiers.IMPLICIT, BasicTypeID.STRING));
+			}
 		}
 		
 		return null;
 		members.addOperator(INT_NEG);
 		members.addOperator(INT_NOT);
 		
-		/*members.addOperator(new OperatorMember(BUILTIN, 0, OperatorType.PRE_INCREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);
-		members.addOperator(new OperatorMember(BUILTIN, 0, OperatorType.PRE_DECREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);
-		members.addOperator(new OperatorMember(BUILTIN, 0, OperatorType.POST_INCREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);
-		members.addOperator(new OperatorMember(BUILTIN, 0, OperatorType.POST_DECREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);*/
+		members.addOperator(INT_INC);
+		members.addOperator(INT_DEC);
 
 		members.addOperator(OperatorType.COMPARE, new ComparatorMember(members.type), TypeMemberPriority.SPECIFIED);
 		
 		members.addOperator(INT_MOD_INT);
 		members.addOperator(mod(T_INT, LONG, LONG, castedTargetCall(LONG_MOD_LONG, INT_TO_LONG)));
 		
+		members.addOperator(INT_OR_INT);
+		members.addOperator(INT_AND_INT);
+		members.addOperator(INT_XOR_INT);
+		
+		members.addOperator(INT_SHL);
+		members.addOperator(INT_SHR);
+		members.addOperator(INT_USHR);
+		
 		members.addGetter(INT_GET_MIN_VALUE);
 		members.addGetter(INT_GET_MAX_VALUE);
 		
 	}
 
 	private void visitUInt() {
-		registerUnaryOperations(T_UINT);
+		members.addOperator(UINT_NOT);
+		
+		members.addOperator(UINT_INC);
+		members.addOperator(UINT_DEC);
+		
 		registerArithmeticOperations(T_UINT, UINT, UINT);
 		registerArithmeticOperations(T_UINT, ULONG, ULONG);
 		registerArithmeticOperations(T_UINT, FLOAT, FLOAT);
 	}
 
 	private void visitString() {
-		FunctionHeader getIndexHeader = new FunctionHeader(CHAR, new FunctionParameter(INT));
-		members.addOperator(new OperatorMember(BUILTIN, T_STRING, 0, OperatorType.INDEXGET, getIndexHeader), TypeMemberPriority.SPECIFIED);
+		members.addOperator(STRING_INDEXGET);
+		members.addOperator(STRING_RANGEGET);
+		members.addGetter(STRING_LENGTH);
 
-		members.addGetter(new GetterMember(BUILTIN, T_STRING, 0, "length", INT), TypeMemberPriority.SPECIFIED);
-
-		//FunctionHeader substringHeader = new FunctionHeader(STRING, new FunctionParameter(cache.getRegistry().getRange(INT, INT)));
-		//members.addOperator(OperatorType.INDEXGET, new SubstringMember(substringHeader), TypeMemberPriority.SPECIFIED);
-		
-		members.addConstructor(new ConstructorMember(BUILTIN, T_STRING, 0, new FunctionHeader(VOID, new FunctionParameter(cache.getRegistry().getArray(CHAR, 1), "characters"))), TypeMemberPriority.SPECIFIED);
+		members.addConstructor(STRING_CONSTRUCTOR_CHARACTERS);
+		members.addConstructor(STRING_CONSTRUCTOR_CHARACTER_RANGE);
 		
 		members.addOperator(STRING_ADD_STRING);
-
-		/*registerStringConcat(NULL);
-		registerStringConcat(BOOL);
-		registerStringConcat(SBYTE);
-		registerStringConcat(BYTE);
-		registerStringConcat(SHORT);
-		registerStringConcat(USHORT);
-		registerStringConcat(INT);
-		registerStringConcat(UINT);
-		registerStringConcat(LONG);
-		registerStringConcat(ULONG);
-		registerStringConcat(FLOAT);
-		registerStringConcat(DOUBLE);
-		registerStringConcat(CHAR);
-		registerStringConcat(STRING);*/
-	}
-
-	private void registerStringConcat(ITypeID withType) {
-		members.addOperator(STRING_ADD_STRING);
+		
+		members.addIterator(new StringCharIterator(), TypeMemberPriority.SPECIFIED);
 	}
 
 	private void registerUnaryOperations(ClassDefinition definition) {
 		FunctionHeader unaryHeader = new FunctionHeader(members.type);
 		members.addOperator(new OperatorMember(BUILTIN, definition, 0, OperatorType.NEG, unaryHeader), TypeMemberPriority.SPECIFIED);
-		members.addOperator(new OperatorMember(BUILTIN, definition, 0, OperatorType.PRE_INCREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);
-		members.addOperator(new OperatorMember(BUILTIN, definition, 0, OperatorType.PRE_DECREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);
-		members.addOperator(new OperatorMember(BUILTIN, definition, 0, OperatorType.POST_INCREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);
-		members.addOperator(new OperatorMember(BUILTIN, definition, 0, OperatorType.POST_DECREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);
+		members.addOperator(new OperatorMember(BUILTIN, definition, 0, OperatorType.INCREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);
+		members.addOperator(new OperatorMember(BUILTIN, definition, 0, OperatorType.DECREMENT, unaryHeader), TypeMemberPriority.SPECIFIED);
 
 		members.addOperator(OperatorType.COMPARE, new ComparatorMember(members.type), TypeMemberPriority.SPECIFIED);
 	}

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

 		for (Map.Entry<String, EnumConstantMember> entry : enumMembers.entrySet())
 			other.addEnumMember(entry.getValue(), priority);
 		for (Map.Entry<String, DefinitionMemberGroup> entry : members.entrySet())
-			other.getOrCreateGroup(entry.getKey()).merge(position, entry.getValue(), priority);
+			other.getOrCreateGroup(entry.getKey(), entry.getValue().isStatic).merge(position, entry.getValue(), priority);
 		for (Map.Entry<String, InnerDefinition> entry : innerTypes.entrySet())
 			other.innerTypes.put(entry.getKey(), entry.getValue());
 		for (Map.Entry<OperatorType, DefinitionMemberGroup> entry : operators.entrySet())
 		getOrCreateGroup(OperatorType.CONSTRUCTOR).addMethod(constructor, priority);
 	}
 	
+	public void addConstructor(ConstructorMember constructor) {
+		getOrCreateGroup(OperatorType.CONSTRUCTOR).addMethod(constructor, TypeMemberPriority.SPECIFIED);
+	}
+	
 	public void addCaller(CallerMember caller, TypeMemberPriority priority) {
 		getOrCreateGroup(OperatorType.CALL).addMethod(caller, priority);
 	}
 	}
 	
 	public void addField(FieldMember member, TypeMemberPriority priority) {
-		DefinitionMemberGroup group = getOrCreateGroup(member.name);
+		DefinitionMemberGroup group = getOrCreateGroup(member.name, member.isStatic());
 		group.setField(member, priority);
 	}
 	
 	}
 	
 	public void addGetter(IGettableMember member, TypeMemberPriority priority) {
-		DefinitionMemberGroup group = getOrCreateGroup(member.getName());
+		DefinitionMemberGroup group = getOrCreateGroup(member.getName(), member.isStatic());
 		group.setGetter(member, priority);
 	}
 	
 	}
 	
 	public void addSetter(SetterMember member, TypeMemberPriority priority) {
-		DefinitionMemberGroup group = getOrCreateGroup(member.name);
+		DefinitionMemberGroup group = getOrCreateGroup(member.name, member.isStatic());
 		group.setSetter(member, priority);
 	}
 	
 	}
 	
 	public void addMethod(MethodMember member, TypeMemberPriority priority) {
-		DefinitionMemberGroup group = getOrCreateGroup(member.name);
+		DefinitionMemberGroup group = getOrCreateGroup(member.name, member.isStatic());
 		group.addMethod(member, priority);
 	}
 	
 		innerTypes.put(name, type);
 	}
 	
-	public DefinitionMemberGroup getOrCreateGroup(String name) {
+	public DefinitionMemberGroup getOrCreateGroup(String name, boolean isStatic) {
 		if (!members.containsKey(name))
-			members.put(name, new DefinitionMemberGroup());
+			members.put(name, new DefinitionMemberGroup(isStatic));
 		
 		return members.get(name);
 	}
 	
 	public DefinitionMemberGroup getOrCreateGroup(OperatorType operator) {
 		if (!operators.containsKey(operator))
-			operators.put(operator, new DefinitionMemberGroup());
+			operators.put(operator, new DefinitionMemberGroup(false));
 		
 		return operators.get(operator);
 	}
 		return false;
 	}
 	
+	public boolean canCast(ITypeID toType) {
+		if (canCastImplicit(toType))
+			return true;
+		
+		for (TypeMember<ICasterMember> caster : casters) {
+			if (toType == caster.member.getTargetType())
+				return true;
+		}
+		
+		return false;
+	}
+	
 	public Expression castImplicit(CodePosition position, Expression value, ITypeID toType, boolean implicit) {
 		if (toType == type || toType == BasicTypeID.UNDETERMINED)
 			return value;
 	}
 	
 	public IPartialExpression getMemberExpression(CodePosition position, Expression target, GenericName name, boolean allowStatic) {
-		if (members.containsKey(name.name) && name.arguments.isEmpty())
-			return new PartialMemberGroupExpression(position, target, members.get(name.name), allowStatic);
+		if (members.containsKey(name.name)) {
+			DefinitionMemberGroup group = members.get(name.name);
+			
+			if (!name.arguments.isEmpty()) {
+				/* ... */
+			}
+			
+			if (group.isStatic)
+				return new PartialStaticMemberGroupExpression(position, type, group);
+			else
+				return new PartialMemberGroupExpression(position, target, group, allowStatic);
+		}
 		
 		return null;
 	}

Constructor/build.gradle

+// Note: "common.gradle" in the root project contains additional initialization
+//   for this project. This initialization is applied in the "build.gradle"
+//   of the root project.
+
+// NetBeans will automatically add "run" and "debug" tasks relying on the
+// "mainClass" property. You may however define the property prior executing
+// tasks by passing a "-PmainClass=<QUALIFIED_CLASS_NAME>" argument.
+//
+// Note however, that you may define your own "run" and "debug" task if you
+// prefer. In this case NetBeans will not add these tasks but you may rely on
+// your own implementation.
+if (!hasProperty('mainClass')) {
+    ext.mainClass = 'org.openzen.zenscript.constructor.Main'
+}
+
+dependencies {
+	compile 'org.json:json:20180130'
+	compile project(':CodeModel')
+	compile project(':Parser')
+	compile project(':Validator')
+	compile project(':JavaBytecodeCompiler')
+}

Constructor/libraries/stdlib/module.json

+{
+	"package": "stdlib",
+	"host": "universal",
+	"globals": {
+		"Exception": {"type": "Definition", "definition": "Exception"},
+		"IllegalArgumentException": {"type": "Definition", "definition": "IllegalArgumentException"},
+		"StringBuilder": {"type": "Definition", "definition": "StringBuilder"}
+	}
+}

Constructor/libraries/stdlib/src/Chars.zs

+export expand char {
+	public times(number as int) as string {
+		return new string(new char[](number, this));
+	}
+}

Constructor/libraries/stdlib/src/Exception.zs

+export virtual class Exception {
+	public this(message as string) {
+	}
+}

Constructor/libraries/stdlib/src/IllegalArgumentException.zs

+export class IllegalArgumentException : Exception {
+	public this(message as string) {
+		super(message);
+	}
+}

Constructor/libraries/stdlib/src/Integers.zs

+expand int {
+	public extern toHexString() as string;
+	public static extern parse(value as string) as int;
+	public static extern parse(value as string, radix as int) as int;
+}

Constructor/libraries/stdlib/src/StringBuilder.zs

+export class StringBuilder {
+	public extern this();
+	public extern this(capacity as int);
+	public extern this(value as string);
+	
+	public extern +=(value as string);
+	public extern +=(value as char);
+	
+	public extern implicit as string;
+}

Constructor/libraries/stdlib/src/Strings.zs

+export expand string {
+	public get isEmpty as bool => length == 0;
+	
+	public const indexOf(c as char) as int {
+		for i in 0 .. length {
+			if this[i] == c
+				return i;
+		}
+		
+		return -1;
+	}
+	
+	public const indexOf(c as char, from as int) as int {
+		for i in from .. length {
+			if this[i] == c
+				return i;
+		}
+		
+		return -1;
+	}
+	
+	public const lastIndexOf(c as char) as int {
+		var i = length;
+		while i > 0 {
+			i--;
+			if this[i] == c
+				return i;
+		}
+		
+		return -1;
+	}
+	
+	public const lastIndexOf(c as char, until as int) as int {
+		var i = until;
+		while i > 0 {
+			i--;
+			if this[i] == c
+				return i;
+		}
+		
+		return -1;
+	}
+	
+	public const split(delimiter as char) as string[] {
+		val result = [] as string[];
+		var start = 0;
+		for i in 0 .. this.length {
+			if this[i] == delimiter {
+				result.add(this[start .. i]);
+				start = i + 1;
+			}
+		}
+		result.add(this[start .. $]);
+		return result;
+	}
+	
+	public const lpad(length as int, c as char) as string
+		=> this.length >= length ? this : c.times(length - this.length) + this;
+	
+	public const rpad(length as int, c as char) as string
+		=> this.length >= length ? this : this + c.times(length - this.length);
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/Arguments.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.constructor;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class Arguments {
+	public static Arguments parse(String[] args) {
+		String directory = ".";
+		boolean help = false;
+		String target = null;
+		
+		int position = 0;
+		outer: for (int i = 0; i < args.length; i++) {
+			switch (args[i]) {
+				case "-d":
+					i++;
+					directory = args[0];
+					continue outer;
+				case "-h":
+				case "--help":
+					help = true;
+					continue outer;
+				default:
+					if (position == 0) {
+						position++;
+						target = args[i];
+					}
+			}
+		}
+		
+		return new Arguments(directory, target, help);
+	}
+	
+	public final String directory;
+	public final String target;
+	public final boolean help;
+	
+	public Arguments(String directory, String target) {
+		this(directory, target, false);
+	}
+	
+	private Arguments(String directory, String target, boolean help) {
+		this.directory = directory;
+		this.target = target;
+		this.help = help;
+	}
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/ConstructorException.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.constructor;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ConstructorException extends RuntimeException {
+	public ConstructorException(String message) {
+		super(message);
+	}
+	
+	public ConstructorException(String message, Throwable cause) {
+		super(message, cause);
+	}
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/JSONUtils.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.constructor;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.json.JSONTokener;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JSONUtils {
+	private JSONUtils() {}
+	
+	public static JSONObject load(File file) throws IOException, JSONException {
+		try (BufferedInputStream input = new BufferedInputStream(new FileInputStream(file))) {
+			return new JSONObject(new JSONTokener(input));
+		}
+	}
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/Main.java

+package org.openzen.zenscript.constructor;
+
+import java.io.File;
+import java.io.IOException;
+import org.openzen.zenscript.constructor.module.DirectoryModuleLoader;
+
+public class Main {
+    /**
+     * @param args the command line arguments
+     */
+    public static void main(String[] args) throws IOException {
+		//Arguments arguments = Arguments.parse(args);
+		Arguments arguments = new Arguments("../../ZenCode", "default");
+		if (arguments.help) {
+			printHelp();
+			return;
+		}
+		
+		File currentDirectory = new File(arguments.directory);
+		File projectJson = new File(currentDirectory, "project.json");
+		if (!projectJson.exists()) {
+			System.out.println("Error: not a valid project (missing project.json)");
+			return;
+		}
+		
+		ModuleLoader moduleLoader = new ModuleLoader();
+		moduleLoader.register("stdlib", new DirectoryModuleLoader(moduleLoader, "stdlib", new File("libraries/stdlib"), true));
+		
+		Project project = new Project(projectJson);
+		for (String moduleName : project.modules) {
+			moduleLoader.register(moduleName, new DirectoryModuleLoader(moduleLoader, moduleName, new File(currentDirectory, moduleName), false));
+		}
+		
+		// TODO: compile targets
+		for (String moduleName : project.modules) {
+			moduleLoader.getModule(moduleName);
+		}
+    }
+	
+	private static void printHelp() {
+		System.out.println("Usage:");
+		System.out.println("  java -jar Constructor.jar [<target>] [-d directory] [-h|--help]");
+	}
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/Module.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.constructor;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import org.json.JSONObject;
+import org.json.JSONTokener;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.PackageDefinitions;
+import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.constructor.module.ModuleSpace;
+import org.openzen.zenscript.constructor.module.SemanticModule;
+import org.openzen.zenscript.linker.symbol.ISymbol;
+import org.openzen.zenscript.parser.ParsedFile;
+import org.openzen.zenscript.shared.CompileException;
+import org.openzen.zenscript.validator.ValidationLogEntry;
+import org.openzen.zenscript.validator.Validator;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class Module {
+	public final String name;
+	public final File sourceDirectory;
+	public final String packageName;
+	public final String host;
+	
+	public Module(String name, File directory, File moduleFile) throws IOException {
+		this.name = name;
+		this.sourceDirectory = new File(directory, "src");
+		
+		BufferedInputStream input = new BufferedInputStream(new FileInputStream(moduleFile));
+		JSONObject json = new JSONObject(new JSONTokener(input));
+		packageName = json.getString("package");
+		host = json.getString("host");
+	}
+	
+	public ParsedFile[] parse(ZSPackage pkg) throws IOException {
+		List<ParsedFile> files = new ArrayList<>();
+		parse(files, pkg, sourceDirectory);
+		return files.toArray(new ParsedFile[files.size()]);
+	}
+	
+	private void parse(List<ParsedFile> files, ZSPackage pkg, File directory) throws IOException {
+		for (File file : directory.listFiles()) {
+			if (file.getName().endsWith(".zs")) {
+				try {
+					files.add(ParsedFile.parse(pkg, file));
+				} catch (CompileException ex) {
+					System.out.println(ex.getMessage());
+				}
+			} else if (file.isDirectory()) {
+				parse(files, pkg.getOrCreatePackage(file.getName()), file);
+			}
+		}
+	}
+	
+	public static SemanticModule compileSyntaxToSemantic(ZSPackage pkg, ParsedFile[] files, ModuleSpace registry) {
+		// We are considering all these files to be in the same package, so make
+		// a single PackageDefinition instance. If these files were in multiple
+		// packages, we'd need an instance for every package.
+		PackageDefinitions definitions = new PackageDefinitions();
+		for (ParsedFile file : files) {
+			// listDefinitions will merely register all definitions (classes,
+			// interfaces, functions ...) so they can later be available to
+			// the other files as well. It doesn't yet compile anything.
+			file.listDefinitions(definitions);
+		}
+		
+		ZSPackage rootPackage = registry.collectPackages();
+		List<ExpansionDefinition> expansions = registry.collectExpansions();
+		definitions.registerExpansionsTo(expansions);
+		
+		Map<String, ISymbol> globals = registry.collectGlobals();
+		boolean failed = false;
+		
+		GlobalTypeRegistry globalRegistry = new GlobalTypeRegistry();
+		for (ParsedFile file : files) {
+			// compileMembers will register all definition members to their
+			// respective definitions, such as fields, constructors, methods...
+			// It doesn't yet compile the method contents.
+			try {
+				file.compileTypes(rootPackage, definitions, globalRegistry, expansions, globals);
+			} catch (CompileException ex) {
+				System.out.println(ex.getMessage());
+				failed = true;
+			}
+		}
+		
+		if (failed)
+			return new SemanticModule(false, pkg, definitions, Collections.emptyList());
+		
+		for (ParsedFile file : files) {
+			// compileMembers will register all definition members to their
+			// respective definitions, such as fields, constructors, methods...
+			// It doesn't yet compile the method contents.
+			try {
+				file.compileMembers(rootPackage, definitions, globalRegistry, expansions, globals);
+			} catch (CompileException ex) {
+				System.out.println(ex.getMessage());
+				failed = true;
+			}
+		}
+		
+		if (failed)
+			return new SemanticModule(false, pkg, definitions, Collections.emptyList());
+		
+		// scripts will store all the script blocks encountered in the files
+		List<ScriptBlock> scripts = new ArrayList<>();
+		for (ParsedFile file : files) {
+			// compileCode will convert the parsed statements and expressions
+			// into semantic code. This semantic code can then be compiled
+			// to various targets.
+			try {
+				file.compileCode(rootPackage, definitions, globalRegistry, expansions, scripts, globals);
+			} catch (CompileException ex) {
+				System.out.println(ex.getMessage());
+				failed = true;
+			}
+		}
+		
+		if (failed)
+			return new SemanticModule(false, pkg, definitions, Collections.emptyList());
+		
+		Validator validator = new Validator();
+		boolean isValid = true;
+		for (ScriptBlock script : scripts) {
+			isValid &= validator.validate(script);
+		}
+		for (HighLevelDefinition definition : definitions.getAll()) {
+			isValid &= validator.validate(definition);
+		}
+		
+		for (ValidationLogEntry entry : validator.getLog()) {
+			System.out.println(entry.kind + " " + entry.position.toString() + ": " + entry.message);
+		}
+		
+		return new SemanticModule(isValid, pkg, definitions, scripts);
+	}
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/ModuleLoader.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.constructor;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Stack;
+import org.openzen.zenscript.constructor.module.ModuleReference;
+import org.openzen.zenscript.constructor.module.SemanticModule;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ModuleLoader {
+	private final Map<String, SemanticModule> moduleCache = new HashMap<>();
+	private final Map<String, ModuleReference> modules = new HashMap<>();
+	
+	private final HashSet<String> compilingModulesSet = new HashSet<>();
+	private final Stack<String> compilingModulesStack = new Stack<>();
+	
+	public SemanticModule getModule(String name) {
+		if (moduleCache.containsKey(name))
+			return moduleCache.get(name);
+		
+		if (!modules.containsKey(name))
+			throw new ConstructorException("Module not found: " + name);
+		
+		if (compilingModulesSet.contains(name)) {
+			StringBuilder stack = new StringBuilder();
+			stack.append("Circular module reference loading ").append(name).append(":");
+			for (int i = compilingModulesStack.size() - 1; i >= 0; i--) {
+				stack.append("\n\t").append(compilingModulesStack.get(i));
+			}
+			throw new ConstructorException(stack.toString());
+		}
+		
+		compilingModulesSet.add(name);
+		compilingModulesStack.add(name);
+		
+		SemanticModule module = modules.get(name).load();
+		moduleCache.put(name, module);
+		
+		compilingModulesSet.remove(name);
+		compilingModulesStack.pop();
+		return module;
+	}
+	
+	public void register(String name, ModuleReference module) {
+		modules.put(name, module);
+	}
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/Project.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.constructor;
+
+import java.io.File;
+import java.io.IOException;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class Project {
+	public final String[] modules;
+	
+	public Project(File projectFile) throws IOException {
+		JSONObject json = JSONUtils.load(projectFile);
+		
+		JSONArray jsonModules = json.getJSONArray("modules");
+		modules = new String[jsonModules.length()];
+		for (int i = 0; i < jsonModules.length(); i++)
+			modules[i] = jsonModules.getString(i);
+	}
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/module/DirectoryModuleLoader.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.constructor.module;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.constructor.ConstructorException;
+import org.openzen.zenscript.constructor.JSONUtils;
+import org.openzen.zenscript.constructor.Module;
+import org.openzen.zenscript.constructor.ModuleLoader;
+import org.openzen.zenscript.linker.symbol.TypeSymbol;
+import org.openzen.zenscript.parser.ParsedFile;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DirectoryModuleLoader implements ModuleReference {
+	private final ModuleLoader loader;
+	private final String moduleName;
+	private final File directory;
+	private final boolean isStdlib;
+	
+	public DirectoryModuleLoader(ModuleLoader loader, String moduleName, File directory, boolean isStdlib) {
+		this.loader = loader;
+		this.moduleName = moduleName;
+		this.directory = directory;
+		this.isStdlib = isStdlib;
+	}
+
+	@Override
+	public SemanticModule load() {
+		if (!directory.exists())
+			throw new ConstructorException("Error: module directory not found: " + directory);
+		
+		File jsonFile = new File(directory, "module.json");
+		if (!jsonFile.exists())
+			throw new ConstructorException("Error: module.json file not found in module " + moduleName);
+		
+		try {
+			JSONObject json = JSONUtils.load(jsonFile);
+
+			List<String> dependencyNames = new ArrayList<>();
+			if (!isStdlib)
+				dependencyNames.add("stdlib");
+
+			JSONArray jsonDependencies = json.optJSONArray("dependencies");
+			if (jsonDependencies != null) {
+				for (int i = 0; i < jsonDependencies.length(); i++) {
+					dependencyNames.add(jsonDependencies.getString(i));
+				}
+			}
+
+			ModuleSpace space = new ModuleSpace();
+			for (String dependencyName : dependencyNames)
+				space.addModule(dependencyName, loader.getModule(dependencyName));
+
+			Module module = new Module(moduleName, directory, jsonFile);
+			ZSPackage pkg = new ZSPackage(module.packageName);
+
+			ParsedFile[] parsedFiles = module.parse(pkg);
+			SemanticModule result = Module.compileSyntaxToSemantic(pkg, parsedFiles, space);
+			
+			JSONObject globals = json.optJSONObject("globals");
+			if (globals != null) {
+				for (String key : globals.keySet()) {
+					JSONObject global = globals.getJSONObject(key);
+					switch (global.getString("type")) {
+						case "Definition":
+							result.globals.put(key, new TypeSymbol(result.definitions.getDefinition(global.getString("definition"))));
+							break;
+						default:
+							throw new ConstructorException("Invalid global type: " + global.getString("type"));
+					}
+				}
+			}
+			
+			return result;
+		} catch (IOException ex) {
+			throw new ConstructorException("Loading module files failed: " + ex.getMessage(), ex);
+		}
+	}
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/module/FileContents.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.constructor.module;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.ScriptBlock;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class FileContents {
+	public final String filename;
+	public ScriptBlock script;
+	public final List<HighLevelDefinition> definitions = new ArrayList<>();
+	
+	public FileContents(String filename) {
+		this.filename = filename;
+	}
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/module/ModuleReference.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.constructor.module;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface ModuleReference {
+	public SemanticModule load();
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/module/ModuleSpace.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.constructor.module;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.constructor.ConstructorException;
+import org.openzen.zenscript.linker.symbol.ISymbol;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ModuleSpace {
+	public final ZSPackage globalsPackage = new ZSPackage("");
+	private final ZSPackage rootPackage = new ZSPackage("");
+	private final List<ExpansionDefinition> expansions = new ArrayList<>();
+	private final Map<String, ISymbol> globals = new HashMap<>();
+	
+	public ModuleSpace() {
+		
+	}
+	
+	public void addModule(String name, SemanticModule dependency) {
+		rootPackage.add(name, dependency.pkg);
+		dependency.definitions.registerExpansionsTo(expansions);
+		
+		for (Map.Entry<String, ISymbol> globalEntry : dependency.globals.entrySet()) {
+			if (globals.containsKey(globalEntry.getKey()))
+				throw new ConstructorException("Duplicate global: " + globalEntry.getKey());
+			
+			globals.put(globalEntry.getKey(), globalEntry.getValue());
+		}
+	}
+	
+	public ZSPackage collectPackages() {
+		return rootPackage;
+	}
+	
+	public List<ExpansionDefinition> collectExpansions() {
+		return expansions;
+	}
+	
+	public Map<String, ISymbol> collectGlobals() {
+		return globals;
+	}
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/module/SemanticModule.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.constructor.module;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.PackageDefinitions;
+import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.javabytecode.JavaCompiler;
+import org.openzen.zenscript.javabytecode.JavaModule;
+import org.openzen.zenscript.linker.symbol.ISymbol;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SemanticModule {
+	public final boolean isValid;
+	public final ZSPackage pkg;
+	public final PackageDefinitions definitions;
+	public final List<ScriptBlock> scripts;
+	public final Map<String, ISymbol> globals = new HashMap<>();
+	
+	public SemanticModule(boolean isValid, ZSPackage pkg, PackageDefinitions definitions, List<ScriptBlock> scripts) {
+		this.isValid = isValid;
+		this.pkg = pkg;
+		this.definitions = definitions;
+		this.scripts = scripts;
+	}
+	
+	public JavaModule compileToJava() {
+		JavaCompiler compiler = new JavaCompiler(false);
+		for (HighLevelDefinition definition : definitions.getAll()) {
+			compiler.addDefinition(definition);
+		}
+		for (ScriptBlock script : scripts) {
+			compiler.addScriptBlock(script);
+		}
+		return compiler.finish();
+	}
+}

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

 		implement(FLOAT_NEG, JavaWriter::fNeg);
 		implement(DOUBLE_NEG, JavaWriter::dNeg);
 		
+		
+		
 		implement(BYTE_ADD_BYTE, JavaWriter::iAdd);
 		implement(SBYTE_ADD_SBYTE, JavaWriter::iAdd);
 		implement(SHORT_ADD_SHORT, JavaWriter::iAdd);

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

  */
 package org.openzen.zenscript.javabytecode;
 
+import org.objectweb.asm.Type;
+
 /**
  *
  * @author Hoofdgebruiker
  */
 public class JavaParameterInfo {
 	public final int index;
+	public final Type type;
 	
-	public JavaParameterInfo(int index) {
+	public JavaParameterInfo(int index, Type type) {
 		this.index = index;
+		this.type = type;
 	}
 }

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

-package org.openzen.zenscript.javabytecode;
-
-public class TestIsStaticInfo {
-    public final boolean isStatic;
-
-    public TestIsStaticInfo(boolean isStatic) {
-        this.isStatic = isStatic;
-    }
-}

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

     }
 	
 	public static void tagMethodParameters(FunctionHeader header, boolean isStatic) {
+		JavaTypeVisitor typeVisitor = new JavaTypeVisitor();
 		for (int i = 0; i < header.parameters.length; i++) {
-			header.parameters[i].setTag(JavaParameterInfo.class, new JavaParameterInfo(isStatic ? i : i + 1));
+			FunctionParameter parameter = header.parameters[i];
+			Type parameterType = parameter.type.accept(typeVisitor);
+			parameter.setTag(JavaParameterInfo.class, new JavaParameterInfo(isStatic ? i : i + 1, parameterType));
 		}
 	}
 	
 	public static void tagConstructorParameters(FunctionHeader header, boolean isEnum) {
+		JavaTypeVisitor typeVisitor = new JavaTypeVisitor();
 		for (int i = 0; i < header.parameters.length; i++) {
-			header.parameters[i].setTag(JavaParameterInfo.class, new JavaParameterInfo(isEnum ? i + 3 : i + 1));
+			FunctionParameter parameter = header.parameters[i];
+			Type parameterType = parameter.type.accept(typeVisitor);
+			parameter.setTag(JavaParameterInfo.class, new JavaParameterInfo(isEnum ? i + 3 : i + 1, parameterType));
 		}
 	}
 	
-	public static void writeDefaultFieldInitializers(JavaWriter constructorWriter, HighLevelDefinition definition) {
+	public static void writeDefaultFieldInitializers(JavaWriter constructorWriter, HighLevelDefinition definition, boolean staticFields) {
 		JavaExpressionVisitor expressionVisitor = new JavaExpressionVisitor(constructorWriter);
 		for (final IDefinitionMember definitionMember : definition.members) {
-			if (definitionMember instanceof FieldMember && ((FieldMember) definitionMember).initializer != null) {
-				final FieldMember field = (FieldMember) definitionMember;
+			if (!(definitionMember instanceof FieldMember))
+				continue;
+			
+			FieldMember field = (FieldMember) definitionMember;
+			if (field.isStatic() == staticFields && field.initializer != null) {
 				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

         //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);
+		CompilerUtils.writeDefaultFieldInitializers(javaWriter, javaWriter.forDefinition, false);
         return null;
     }
 
 
     @Override
     public Void visitGetField(GetFieldExpression expression) {
-        javaWriter.loadObject(0);
+		expression.accept(this);
         if (!checkAndGetFieldInfo(expression.field, false))
             throw new IllegalStateException("Missing field info on a field member!");
         return null;
 
         return null;
     }
+	
+	@Override
+	public Void visitPostCall(PostCallExpression expression) {
+		expression.target.accept(this);
+		javaWriter.dup(expression.type.accept(new JavaTypeVisitor()));
+        if (!checkAndExecuteByteCodeImplementation(expression.member) && !checkAndExecuteMethodInfo(expression.member))
+            throw new IllegalStateException("Call target has no method info!");
+		
+		return null;
+	}
 
     @Override
     public Void visitRange(RangeExpression expression) {
 
     @Override
     public Void visitSetField(SetFieldExpression expression) {
-        javaWriter.loadObject(0);
+        expression.target.accept(this);
         expression.value.accept(this);
         if (!checkAndPutFieldInfo(expression.field, false))
             throw new IllegalStateException("Missing field info on a field member!");
 
 
     //Will return true if a JavaFieldInfo.class tag exists, and will compile that tag
-    private boolean checkAndPutFieldInfo(DefinitionMember field, boolean isStatic) {
+    public boolean checkAndPutFieldInfo(DefinitionMember field, boolean isStatic) {
         JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
         if (fieldInfo == null)
             return false;
         return true;
     }
 
-    private boolean checkAndGetFieldInfo(DefinitionMember field, boolean isStatic) {
+    public boolean checkAndGetFieldInfo(DefinitionMember field, boolean isStatic) {
         JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
         if (fieldInfo == null)
             return false;

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

 import org.openzen.zenscript.codemodel.type.ConstTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
+import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeVisitor;
 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
 	public Class visitOptional(OptionalTypeID optional) {
 		return base.visitOptional(optional);
 	}
+
+	@Override
+	public Class visitGenericMap(GenericMapTypeID map) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
 }

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaPreDecrementVisitor.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.compiler;
+
+import org.objectweb.asm.Type;
+import org.openzen.zenscript.codemodel.expression.AndAndExpression;
+import org.openzen.zenscript.codemodel.expression.ArrayExpression;
+import org.openzen.zenscript.codemodel.expression.BasicCompareExpression;
+import org.openzen.zenscript.codemodel.expression.CallExpression;
+import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedClosureExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedDirectExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedParameterExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedThisExpression;
+import org.openzen.zenscript.codemodel.expression.CastExpression;
+import org.openzen.zenscript.codemodel.expression.CheckNullExpression;
+import org.openzen.zenscript.codemodel.expression.CoalesceExpression;
+import org.openzen.zenscript.codemodel.expression.ConditionalExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantBoolExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantDoubleExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantFloatExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantLongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantSByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
+import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
+import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
+import org.openzen.zenscript.codemodel.expression.ExpressionVisitor;
+import org.openzen.zenscript.codemodel.expression.FunctionExpression;
+import org.openzen.zenscript.codemodel.expression.GenericCompareExpression;
+import org.openzen.zenscript.codemodel.expression.GetFieldExpression;
+import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
+import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
+import org.openzen.zenscript.codemodel.expression.GetterExpression;
+import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
+import org.openzen.zenscript.codemodel.expression.GlobalExpression;
+import org.openzen.zenscript.codemodel.expression.InterfaceCastExpression;
+import org.openzen.zenscript.codemodel.expression.IsExpression;
+import org.openzen.zenscript.codemodel.expression.MakeConstExpression;
+import org.openzen.zenscript.codemodel.expression.MapExpression;
+import org.openzen.zenscript.codemodel.expression.NewExpression;
+import org.openzen.zenscript.codemodel.expression.NullExpression;
+import org.openzen.zenscript.codemodel.expression.OrOrExpression;
+import org.openzen.zenscript.codemodel.expression.PostCallExpression;
+import org.openzen.zenscript.codemodel.expression.RangeExpression;
+import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
+import org.openzen.zenscript.codemodel.expression.SetFunctionParameterExpression;
+import org.openzen.zenscript.codemodel.expression.SetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.SetStaticFieldExpression;
+import org.openzen.zenscript.codemodel.expression.SetterExpression;
+import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
+import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
+import org.openzen.zenscript.codemodel.expression.ThisExpression;
+import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
+import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
+import org.openzen.zenscript.javabytecode.JavaParameterInfo;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaPreDecrementVisitor implements ExpressionVisitor<Void> {
+	private final JavaExpressionVisitor expressionCompiler;
+	private final JavaWriter javaWriter;
+	
+	public JavaPreDecrementVisitor(JavaExpressionVisitor expressionCompiler) {
+		this.expressionCompiler = expressionCompiler;
+		javaWriter = expressionCompiler.getJavaWriter();
+	}
+
+	@Override
+	public Void visitAndAnd(AndAndExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitArray(ArrayExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCompare(BasicCompareExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCall(CallExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCallStatic(CallStaticExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCapturedClosure(CapturedClosureExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCapturedDirect(CapturedDirectExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCapturedLocalVariable(CapturedLocalVariableExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCapturedParameter(CapturedParameterExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCapturedThis(CapturedThisExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCast(CastExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCheckNull(CheckNullExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCoalesce(CoalesceExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConditional(ConditionalExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantBool(ConstantBoolExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantByte(ConstantByteExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantChar(ConstantCharExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantDouble(ConstantDoubleExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantFloat(ConstantFloatExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantInt(ConstantIntExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantLong(ConstantLongExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantSByte(ConstantSByteExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantShort(ConstantShortExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantString(ConstantStringExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantUInt(ConstantUIntExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantULong(ConstantULongExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantUShort(ConstantUShortExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstructorSuperCall(ConstructorSuperCallExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitEnumConstant(EnumConstantExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitFunction(FunctionExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitGenericCompare(GenericCompareExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitGetField(GetFieldExpression expression) {
+		Type objectType = expression.target.type.accept(new JavaTypeVisitor());
+		
+		int local = javaWriter.local(objectType);
+		expression.target.accept(expressionCompiler);
+		javaWriter.dup();
+		javaWriter.store(objectType, local);
+		
+        if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))
+            throw new IllegalStateException("Missing field info on a field member!");
+		
+		javaWriter.iConst1();
+		javaWriter.iSub();
+		
+		javaWriter.load(objectType, local);
+        if (!expressionCompiler.checkAndPutFieldInfo(expression.field, false))
+            throw new IllegalStateException("Missing field info on a field member!");
+		
+		return null;
+	}
+
+	@Override
+	public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
+		javaWriter.idec(expression.parameter.getTag(JavaParameterInfo.class).index);
+		return null;
+	}
+
+	@Override
+	public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
+		javaWriter.idec(expression.variable.getTag(JavaLocalVariableInfo.class).local);
+		return null;
+	}
+
+	@Override
+	public Void visitGetStaticField(GetStaticFieldExpression expression) {
+		if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))
+            throw new IllegalStateException("Missing field info on a field member!");
+		
+		javaWriter.iConst1();
+		javaWriter.iAdd();
+		
+		if (!expressionCompiler.checkAndPutFieldInfo(expression.field, false))
+            throw new IllegalStateException("Missing field info on a field member!");
+		
+		return null;
+	}
+
+	@Override
+	public Void visitGetter(GetterExpression expression) {
+		throw new UnsupportedOperationException("Not yet supported");
+	}
+
+	@Override
+	public Void visitGlobal(GlobalExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitGlobalCall(GlobalCallExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitInterfaceCast(InterfaceCastExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitIs(IsExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitMakeConst(MakeConstExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitMap(MapExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitNew(NewExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitNull(NullExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitOrOr(OrOrExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitPostCall(PostCallExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitRange(RangeExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitSetField(SetFieldExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitSetFunctionParameter(SetFunctionParameterExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitSetLocalVariable(SetLocalVariableExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitSetStaticField(SetStaticFieldExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitSetter(SetterExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitStaticGetter(StaticGetterExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitStaticSetter(StaticSetterExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitThis(ThisExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitWrapOptional(WrapOptionalExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaPreIncrementVisitor.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.compiler;
+
+import org.objectweb.asm.Type;
+import org.openzen.zenscript.codemodel.expression.AndAndExpression;
+import org.openzen.zenscript.codemodel.expression.ArrayExpression;
+import org.openzen.zenscript.codemodel.expression.BasicCompareExpression;
+import org.openzen.zenscript.codemodel.expression.CallExpression;
+import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedClosureExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedDirectExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedParameterExpression;
+import org.openzen.zenscript.codemodel.expression.CapturedThisExpression;
+import org.openzen.zenscript.codemodel.expression.CastExpression;
+import org.openzen.zenscript.codemodel.expression.CheckNullExpression;
+import org.openzen.zenscript.codemodel.expression.CoalesceExpression;
+import org.openzen.zenscript.codemodel.expression.ConditionalExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantBoolExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantDoubleExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantFloatExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantLongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantSByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
+import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
+import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
+import org.openzen.zenscript.codemodel.expression.ExpressionVisitor;
+import org.openzen.zenscript.codemodel.expression.FunctionExpression;
+import org.openzen.zenscript.codemodel.expression.GenericCompareExpression;
+import org.openzen.zenscript.codemodel.expression.GetFieldExpression;
+import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
+import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
+import org.openzen.zenscript.codemodel.expression.GetterExpression;
+import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
+import org.openzen.zenscript.codemodel.expression.GlobalExpression;
+import org.openzen.zenscript.codemodel.expression.InterfaceCastExpression;
+import org.openzen.zenscript.codemodel.expression.IsExpression;
+import org.openzen.zenscript.codemodel.expression.MakeConstExpression;
+import org.openzen.zenscript.codemodel.expression.MapExpression;
+import org.openzen.zenscript.codemodel.expression.NewExpression;
+import org.openzen.zenscript.codemodel.expression.NullExpression;
+import org.openzen.zenscript.codemodel.expression.OrOrExpression;
+import org.openzen.zenscript.codemodel.expression.PostCallExpression;
+import org.openzen.zenscript.codemodel.expression.RangeExpression;
+import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
+import org.openzen.zenscript.codemodel.expression.SetFunctionParameterExpression;
+import org.openzen.zenscript.codemodel.expression.SetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.SetStaticFieldExpression;
+import org.openzen.zenscript.codemodel.expression.SetterExpression;
+import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
+import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
+import org.openzen.zenscript.codemodel.expression.ThisExpression;
+import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
+import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
+import org.openzen.zenscript.javabytecode.JavaParameterInfo;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaPreIncrementVisitor implements ExpressionVisitor<Void> {
+	private final JavaExpressionVisitor expressionCompiler;
+	private final JavaWriter javaWriter;
+	
+	public JavaPreIncrementVisitor(JavaExpressionVisitor expressionCompiler) {
+		this.expressionCompiler = expressionCompiler;
+		javaWriter = expressionCompiler.getJavaWriter();
+	}
+
+	@Override
+	public Void visitAndAnd(AndAndExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitArray(ArrayExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCompare(BasicCompareExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCall(CallExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCallStatic(CallStaticExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCapturedClosure(CapturedClosureExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCapturedDirect(CapturedDirectExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCapturedLocalVariable(CapturedLocalVariableExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCapturedParameter(CapturedParameterExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCapturedThis(CapturedThisExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCast(CastExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCheckNull(CheckNullExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitCoalesce(CoalesceExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConditional(ConditionalExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantBool(ConstantBoolExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantByte(ConstantByteExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantChar(ConstantCharExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantDouble(ConstantDoubleExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantFloat(ConstantFloatExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantInt(ConstantIntExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantLong(ConstantLongExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantSByte(ConstantSByteExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantShort(ConstantShortExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantString(ConstantStringExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantUInt(ConstantUIntExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantULong(ConstantULongExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstantUShort(ConstantUShortExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitConstructorSuperCall(ConstructorSuperCallExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitEnumConstant(EnumConstantExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitFunction(FunctionExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitGenericCompare(GenericCompareExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitGetField(GetFieldExpression expression) {
+		Type objectType = expression.target.type.accept(new JavaTypeVisitor());
+		
+		int local = javaWriter.local(objectType);
+		expression.target.accept(expressionCompiler);
+		javaWriter.dup();
+		javaWriter.store(objectType, local);
+		
+        if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))
+            throw new IllegalStateException("Missing field info on a field member!");
+		
+		javaWriter.iConst1();
+		javaWriter.iAdd();
+		
+		javaWriter.load(objectType, local);
+		javaWriter.dupX1();
+        if (!expressionCompiler.checkAndPutFieldInfo(expression.field, false))
+            throw new IllegalStateException("Missing field info on a field member!");
+		
+		return null;
+	}
+
+	@Override
+	public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
+		JavaParameterInfo parameter = expression.parameter.getTag(JavaParameterInfo.class);
+		javaWriter.iinc(parameter.index);
+		javaWriter.load(parameter);
+		return null;
+	}
+
+	@Override
+	public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
+		JavaLocalVariableInfo localVariable = expression.variable.getTag(JavaLocalVariableInfo.class);
+		javaWriter.iinc(localVariable.local);
+		javaWriter.load(localVariable);
+		return null;
+	}
+
+	@Override
+	public Void visitGetStaticField(GetStaticFieldExpression expression) {
+		if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))
+            throw new IllegalStateException("Missing field info on a field member!");
+		
+		javaWriter.iConst1();
+		javaWriter.iAdd();
+		javaWriter.dup();
+		
+		if (!expressionCompiler.checkAndPutFieldInfo(expression.field, false))
+            throw new IllegalStateException("Missing field info on a field member!");
+		
+		return null;
+	}
+
+	@Override
+	public Void visitGetter(GetterExpression expression) {
+		throw new UnsupportedOperationException("Not yet supported");
+	}
+
+	@Override
+	public Void visitGlobal(GlobalExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitGlobalCall(GlobalCallExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitInterfaceCast(InterfaceCastExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitIs(IsExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitMakeConst(MakeConstExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitMap(MapExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitNew(NewExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitNull(NullExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitOrOr(OrOrExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitPostCall(PostCallExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitRange(RangeExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitSetField(SetFieldExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitSetFunctionParameter(SetFunctionParameterExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitSetLocalVariable(SetLocalVariableExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitSetStaticField(SetStaticFieldExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitSetter(SetterExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitStaticGetter(StaticGetterExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitStaticSetter(StaticSetterExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitThis(ThisExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
+	@Override
+	public Void visitWrapOptional(WrapOptionalExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+}

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

         javaWriter.returnType(Type.getType(statement.value.type.accept(JavaTypeClassVisitor.INSTANCE)));
         return true;
     }
+	
+	@Override
+	public Boolean visitSwitch(SwitchStatement statement) {
+		throw new UnsupportedOperationException("Not yet implemented!");
+	}
 
     @Override
     public Boolean visitThrow(ThrowStatement statement) {

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

     public Class visitOptional(OptionalTypeID optional) {
         return optional.baseType.accept(this.optional);
     }
+
+	@Override
+	public Class visitGenericMap(GenericMapTypeID map) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
 }

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

     public Type visitOptional(OptionalTypeID optional) {
         return Type.getType(optional.accept(JavaTypeClassVisitor.INSTANCE));
     }
+
+	@Override
+	public Type visitGenericMap(GenericMapTypeID map) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
 }

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
+import org.openzen.zenscript.javabytecode.JavaParameterInfo;
 
 public class JavaWriter {
 	private static final JavaClassInfo T_STRING = new JavaClassInfo("java/lang/String");
 
         visitor.visitInsn(DUP);
     }
+	
+	public void dup(Type type) {
+        if (debug)
+            System.out.println("dup");
+		
+		visitor.visitInsn(type.getSize() == 2 ? DUP2 : DUP);
+	}
 
     public void dup(boolean large) {
         if (debug)
 
         visitor.visitVarInsn(type.getOpcode(ILOAD), local);
     }
+	
+	public void load(JavaParameterInfo parameter) {
+        if (debug)
+            System.out.println("load " + parameter.index);
+
+        visitor.visitVarInsn(parameter.type.getOpcode(ILOAD), parameter.index);
+	}
+	
+	public void load(JavaLocalVariableInfo localVariable) {
+        if (debug)
+            System.out.println("load " + localVariable.local);
+
+        visitor.visitVarInsn(localVariable.type.getOpcode(ILOAD), localVariable.local);
+	}
+	
+	public void store(JavaParameterInfo parameter) {
+        if (debug)
+            System.out.println("store " + parameter.index);
+
+        visitor.visitVarInsn(parameter.type.getOpcode(ISTORE), parameter.index);
+	}
+	
+	public void store(JavaLocalVariableInfo localVariable) {
+        if (debug)
+            System.out.println("store " + localVariable.local);
+
+        visitor.visitVarInsn(localVariable.type.getOpcode(ISTORE), localVariable.local);
+	}
 
     public void storeInt(int local) {
         if (debug)
     public void iinc(int local) {
         iinc(local, 1);
     }
+	
+	public void idec(int local) {
+		iinc(local, -1);
+	}
 
     public void iinc(int local, int increment) {
         if (debug)

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

 
 
         writer.visit(Opcodes.V1_8, definition.modifiers, definition.name, signature, superType.getInternalName(), null);
+		JavaMemberVisitor memberVisitor = new JavaMemberVisitor(writer, toClass, definition); 
         for (IDefinitionMember member : definition.members) {
-            member.accept(new JavaMemberVisitor(writer, toClass, definition));
+            member.accept(memberVisitor);
         }
+		memberVisitor.end();
         writer.visitEnd();
         return writer.toByteArray();
     }
         //TODO: Extending Interfaces?
         String signature = null;
         writer.visit(Opcodes.V1_8, definition.modifiers | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT, definition.name, signature, Type.getInternalName(Object.class), null);
+		JavaMemberVisitor memberVisitor = new JavaMemberVisitor(writer, toClass, definition);
         for (IDefinitionMember member : definition.members) {
-            member.accept(new JavaMemberVisitor(writer, toClass, definition));
+            member.accept(memberVisitor);
         }
+		memberVisitor.end();
         writer.visitEnd();
         return writer.toByteArray();
     }

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

 package org.openzen.zenscript.javabytecode.compiler.definitions;
 
+import java.util.ArrayList;
+import java.util.List;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Label;
 import org.objectweb.asm.Opcodes;
     private final ClassWriter writer;
 	private final JavaClassInfo toClass;
 	private final HighLevelDefinition definition;
+	private final List<StaticInitializerMember> staticInitializers = new ArrayList<>();
 
     public JavaMemberVisitor(ClassWriter writer, JavaClassInfo toClass, HighLevelDefinition definition) {
         this.writer = writer;
 
     @Override
     public Void visitConstructor(ConstructorMember member) {
-		System.out.println("Compiling constructor " + member.header.toString());
-		
-        final boolean isEnum = definition instanceof EnumDefinition;
+		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));
 		
 				constructorWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
 			}
 			
-			CompilerUtils.writeDefaultFieldInitializers(constructorWriter, definition);
+			CompilerUtils.writeDefaultFieldInitializers(constructorWriter, definition, false);
 		}
 		
         member.body.accept(statementVisitor);
     public Void visitInnerDefinition(InnerDefinitionMember member) {
         return null;
     }
+
+	@Override
+	public Void visitStaticInitializer(StaticInitializerMember member) {
+		staticInitializers.add(member);
+		return null;
+	}
+	
+	public void end() {
+		final JavaMethodInfo method = new JavaMethodInfo(toClass, "<clinit>", "()V", 0);
+		
+        final Label constructorStart = new Label();
+        final Label constructorEnd = new Label();
+        final JavaWriter constructorWriter = new JavaWriter(writer, method, definition, null, null);
+        constructorWriter.label(constructorStart);
+		
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(constructorWriter);
+        statementVisitor.start();
+		
+		CompilerUtils.writeDefaultFieldInitializers(constructorWriter, definition, true);
+		
+		for (StaticInitializerMember member : staticInitializers) {
+	        member.body.accept(statementVisitor);
+		}
+		
+        constructorWriter.label(constructorEnd);
+        statementVisitor.end();
+	}
 }

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

 		KEYWORDS.put("return", K_RETURN);
 		KEYWORDS.put("break", K_BREAK);
 		KEYWORDS.put("continue", K_CONTINUE);
+		KEYWORDS.put("switch", K_SWITCH);
+		KEYWORDS.put("case", K_CASE);
+		KEYWORDS.put("default", K_DEFAULT);
 		
 		KEYWORDS.put("in", K_IN);
 		KEYWORDS.put("is", K_IS);

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

 	T_BRCLOSE("\\)"),
 	T_SEMICOLON(";"),
 	T_LESSEQ("<="),
+	T_SHLASSIGN("<<="),
 	T_SHL("<<"),
 	T_LESS("<"),
 	T_GREATEREQ(">="),
+	T_USHR(">>>"),
+	T_USHRASSIGN(">>>="),
+	T_SHRASSIGN(">>="),
+	T_SHR(">>"),
 	T_GREATER(">"),
 	T_LAMBDA("=>"),
 	T_EQUAL3("==="),
 	K_RETURN,
 	K_BREAK,
 	K_CONTINUE,
+	K_SWITCH,
+	K_CASE,
+	K_DEFAULT,
 	
 	K_IN,
 	K_IS,

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

 		} else if (tokens.optional(K_ENUM) != null) {
 			return ParsedEnum.parseEnum(pkg, position, modifiers, tokens, outerDefinition);
 		} else if (tokens.optional(K_STRUCT) != null) {
-			return ParsedStruct.parse(pkg, position, modifiers, tokens, outerDefinition);
+			return ParsedStruct.parseStruct(pkg, position, modifiers, tokens, outerDefinition);
 		} else if (tokens.optional(K_ALIAS) != null) {
 			return ParsedAlias.parseAlias(pkg, position, modifiers, tokens, outerDefinition);
 		} else if (tokens.optional(K_FUNCTION) != null) {
 	
 	public abstract void linkInnerTypes();
 	
+	public void compileTypes(BaseScope scope) {
+		
+	}
+	
 	public abstract void compileMembers(BaseScope scope);
 	
 	public abstract void compileCode(BaseScope scope);

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

 		}
 	}
 	
+	public void compileTypes(
+			ZSPackage rootPackage,
+			PackageDefinitions packageDefinitions,
+			GlobalTypeRegistry globalRegistry,
+			List<ExpansionDefinition> expansions,
+			Map<String, ISymbol> globalSymbols) {
+		FileScope scope = new FileScope(access, rootPackage, packageDefinitions, globalRegistry, expansions, globalSymbols);
+		loadImports(scope, rootPackage);
+		for (ParsedDefinition definition : this.definitions) {
+			definition.compileTypes(scope);
+		}
+	}
+	
 	public void compileMembers(
 			ZSPackage rootPackage,
 			PackageDefinitions packageDefinitions,

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedExpansion.java

 import org.openzen.zenscript.lexer.ZSTokenStream;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.linker.BaseScope;
+import org.openzen.zenscript.linker.DefinitionScope;
 import org.openzen.zenscript.linker.GenericFunctionScope;
 import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
 import org.openzen.zenscript.parser.type.IParsedType;
 	}
 
 	@Override
-	public void compileMembers(BaseScope scope) {
+	public void compileTypes(BaseScope scope) {
 		ParsedGenericParameter.compile(scope, compiled.genericParameters, this.parameters);
 		compiled.target = target.compile(new GenericFunctionScope(scope, compiled.genericParameters));
-		
-		super.compileMembers(scope);
 	}
 }

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

 			case T_XORASSIGN:
 				parser.next();
 				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser), OperatorType.XORASSIGN);
+			case T_SHLASSIGN:
+				parser.next();
+				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser), OperatorType.SHLASSIGN);
+			case T_SHRASSIGN:
+				parser.next();
+				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser), OperatorType.SHRASSIGN);
+			case T_USHRASSIGN:
+				parser.next();
+				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser), OperatorType.USHRASSIGN);
 		}
 
 		return left;
 	}
 
 	private static ParsedExpression readCompareExpression(CodePosition position, ZSTokenStream parser) {
-		ParsedExpression left = readAddExpression(position, parser);
+		ParsedExpression left = readShiftExpression(position, parser);
 
 		switch (parser.peek().getType()) {
 			case T_EQUAL2: {
 				parser.next();
-				ParsedExpression right = readAddExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
 				return new ParsedExpressionCompare(position, left, right, CompareType.EQ);
 			}
 			case T_EQUAL3: {
 				parser.next();
-				ParsedExpression right = readAddExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
 				return new ParsedExpressionCompare(position, left, right, CompareType.SAME);
 			}
 			case T_NOTEQUAL: {
 				parser.next();
-				ParsedExpression right = readAddExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
 				return new ParsedExpressionCompare(position, left, right, CompareType.NE);
 			}
 			case T_NOTEQUAL2: {
 				parser.next();
-				ParsedExpression right = readAddExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
 				return new ParsedExpressionCompare(position, left, right, CompareType.NOTSAME);
 			}
 			case T_LESS: {
 				parser.next();
-				ParsedExpression right = readAddExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
 				return new ParsedExpressionCompare(position, left, right, CompareType.LT);
 			}
 			case T_LESSEQ: {
 				parser.next();
-				ParsedExpression right = readAddExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
 				return new ParsedExpressionCompare(position, left, right, CompareType.LE);
 			}
 			case T_GREATER: {
 				parser.next();
-				ParsedExpression right = readAddExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
 				return new ParsedExpressionCompare(position, left, right, CompareType.GT);
 			}
 			case T_GREATEREQ: {
 				parser.next();
-				ParsedExpression right = readAddExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
 				return new ParsedExpressionCompare(position, left, right, CompareType.GE);
 			}
 			case K_IN: {
 				parser.next();
-				ParsedExpression right = readAddExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
 				return new ParsedExpressionBinary(position, right, left, OperatorType.CONTAINS);
 			}
 			case K_IS: {
 			case T_NOT: {
 				parser.next();
 				if (parser.optional(K_IN) != null) {
-					ParsedExpression right = readAddExpression(parser.peek().position, parser);
+					ParsedExpression right = readShiftExpression(parser.peek().position, parser);
 					return new ParsedExpressionUnary(position, new ParsedExpressionBinary(position, right, left, OperatorType.CONTAINS), OperatorType.NOT);
 				} else if (parser.optional(K_IS) != null) {
 					IParsedType type = IParsedType.parse(parser);
 
 		return left;
 	}
+	
+	private static ParsedExpression readShiftExpression(CodePosition position, ZSTokenStream parser) {
+		ParsedExpression left = readAddExpression(position, parser);
+		
+		while (true) {
+			if (parser.optional(T_SHL) != null) {
+				ParsedExpression right = readAddExpression(parser.peek().position, parser);
+				left = new ParsedExpressionBinary(position, left, right, OperatorType.SHL);
+			} else if (parser.optional(T_SHR) != null) {
+				ParsedExpression right = readAddExpression(parser.peek().position, parser);
+				left = new ParsedExpressionBinary(position, left, right, OperatorType.SHR);
+			} else if (parser.optional(T_USHR) != null) {
+				ParsedExpression right = readAddExpression(parser.peek().position, parser);
+				left = new ParsedExpressionBinary(position, left, right, OperatorType.USHR);
+			} else {
+				break;
+			}
+		}
+		
+		return left;
+	}
 
 	private static ParsedExpression readAddExpression(CodePosition position, ZSTokenStream parser) {
 		ParsedExpression left = readMulExpression(position, parser);
 				return new ParsedExpressionUnary(
 						position,
 						readUnaryExpression(parser.peek().position, parser),
-						OperatorType.PRE_INCREMENT);
+						OperatorType.INCREMENT);
 			case T_DECREMENT:
 				parser.next();
 				return new ParsedExpressionUnary(
 						position,
 						readUnaryExpression(parser.peek().position, parser),
-						OperatorType.PRE_DECREMENT);
+						OperatorType.DECREMENT);
 			default:
 				return readPostfixExpression(position, parser);
 		}
 				IParsedType type = IParsedType.parse(parser);
 				base = new ParsedExpressionCast(position, base, type, optional);
 			} else if (parser.optional(T_INCREMENT) != null) {
-				base = new ParsedExpressionUnary(position, base, OperatorType.POST_INCREMENT);
+				base = new ParsedExpressionPostCall(position, base, OperatorType.INCREMENT);
 			} else if (parser.optional(T_DECREMENT) != null) {
-				base = new ParsedExpressionUnary(position, base, OperatorType.POST_DECREMENT);
+				base = new ParsedExpressionPostCall(position, base, OperatorType.DECREMENT);
 			} else if (parser.optional(T_LAMBDA) != null) {
 				ParsedFunctionBody body = ParsedStatement.parseLambdaBody(parser, true);
 				base = new ParsedExpressionFunction(position, base.toLambdaHeader(), body);

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

 
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.MapExpression;
+import org.openzen.zenscript.codemodel.expression.NewExpression;
+import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.ICallableMember;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.linker.ExpressionScope;
 import org.openzen.zenscript.shared.CodePosition;
 					valueHints.add(assocHint.valueType);
 				
 				hasAssocHint = true;
+			} else if (hint instanceof GenericMapTypeID) {
+				ICallableMember constructor = scope
+						.getTypeMembers(hint)
+						.getOrCreateGroup(OperatorType.CONSTRUCTOR)
+						.selectMethod(position, scope, CallArguments.EMPTY, true, true);
+				return new NewExpression(position, hint, (ConstructorMember) constructor, CallArguments.EMPTY);
 			}
 		}
 		

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionPostCall.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.parser.expression;
+
+import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.CallExpression;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.partial.IPartialExpression;
+import org.openzen.zenscript.linker.ExpressionScope;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Stanneke
+ */
+public class ParsedExpressionPostCall extends ParsedExpression {
+	private final ParsedExpression value;
+	private final OperatorType operator;
+
+	public ParsedExpressionPostCall(CodePosition position, ParsedExpression value, OperatorType operator) {
+		super(position);
+
+		this.value = value;
+		this.operator = operator;
+	}
+
+	@Override
+	public IPartialExpression compile(ExpressionScope scope) {
+		Expression cValue = value.compile(scope).eval();
+		return scope.getTypeMembers(cValue.getType()).getOrCreateGroup(operator).callPostfix(position, scope, cValue);
+	}
+
+	@Override
+	public boolean hasStrongType() {
+		return value.hasStrongType();
+	}
+}

Parser/src/main/java/org/openzen/zenscript/parser/member/ParsedDefinitionMember.java

 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
 import org.openzen.zenscript.lexer.ZSToken;
 import org.openzen.zenscript.lexer.ZSTokenStream;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.linker.BaseScope;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 import org.openzen.zenscript.parser.statements.ParsedStatement;
+import org.openzen.zenscript.parser.statements.ParsedStatementBlock;
 import org.openzen.zenscript.parser.type.IParsedType;
 import org.openzen.zenscript.parser.type.ParsedTypeBasic;
 import org.openzen.zenscript.shared.CodePosition;
 	public static ParsedDefinitionMember parse(ZSTokenStream tokens, HighLevelDefinition forDefinition) {
 		CodePosition start = tokens.getPosition();
 		int modifiers = 0;
-		while (true) {
-			if (tokens.optional(ZSTokenType.K_EXPORT) != null) {
-				modifiers |= Modifiers.EXPORT;
-			} else if (tokens.optional(ZSTokenType.K_PUBLIC) != null) {
-				modifiers |= Modifiers.PUBLIC;
-			} else if (tokens.optional(ZSTokenType.K_PRIVATE) != null) {
-				modifiers |= Modifiers.PRIVATE;
-			} else if (tokens.optional(ZSTokenType.K_CONST) != null) {
-				if (tokens.optional(ZSTokenType.T_QUEST) != null) {
-					modifiers |= Modifiers.CONST_OPTIONAL;
-				} else {
-					modifiers |= Modifiers.CONST;
-				}
-			} else if (tokens.optional(ZSTokenType.K_ABSTRACT) != null) {
-				modifiers |= Modifiers.ABSTRACT;
-			} else if (tokens.optional(ZSTokenType.K_FINAL) != null) {
-				modifiers |= Modifiers.FINAL;
-			} else if (tokens.optional(ZSTokenType.K_STATIC) != null) {
-				modifiers |= Modifiers.STATIC;
-			} else if (tokens.optional(ZSTokenType.K_PROTECTED) != null) {
-				modifiers |= Modifiers.PROTECTED;
-			} else if (tokens.optional(ZSTokenType.K_IMPLICIT) != null) {
-				modifiers |= Modifiers.IMPLICIT;
-			} else {
-				break;
+		outer: while (true) {
+			switch (tokens.peek().type) {
+				case K_EXPORT:
+					tokens.next();
+					modifiers |= Modifiers.EXPORT;
+					break;
+				case K_PUBLIC:
+					tokens.next();
+					modifiers |= Modifiers.PUBLIC;
+					break;
+				case K_PRIVATE:
+					tokens.next();
+					modifiers |= Modifiers.PRIVATE;
+					break;
+				case K_CONST:
+					tokens.next();
+					if (tokens.optional(ZSTokenType.T_QUEST) != null) {
+						modifiers |= Modifiers.CONST_OPTIONAL;
+					} else {
+						modifiers |= Modifiers.CONST;
+					}
+					break;
+				case K_ABSTRACT:
+					tokens.next();
+					modifiers |= Modifiers.ABSTRACT;
+					break;
+				case K_FINAL:
+					tokens.next();
+					modifiers |= Modifiers.FINAL;
+					break;
+				case K_STATIC:
+					tokens.next();
+					modifiers |= Modifiers.STATIC;
+					break;
+				case K_PROTECTED:
+					tokens.next();
+					modifiers |= Modifiers.PROTECTED;
+					break;
+				case K_IMPLICIT:
+					tokens.next();
+					modifiers |= Modifiers.IMPLICIT;
+					break;
+				case K_EXTERN:
+					tokens.next();
+					modifiers |= Modifiers.EXTERN;
+					break;
+				default:
+					break outer;
 			}
 		}
 		
 					type = IParsedType.parse(tokens);
 				}
 				ParsedExpression initializer = null;
+				int autoGetter = 0;
+				int autoSetter = 0;
+				if (tokens.optional(ZSTokenType.T_COLON) != null) {
+					do {
+						int accessor = Modifiers.PUBLIC;
+						if (tokens.optional(ZSTokenType.K_PUBLIC) != null) {
+							accessor = Modifiers.PUBLIC;
+						} else if (tokens.optional(ZSTokenType.K_PROTECTED) != null) {
+							accessor = Modifiers.PROTECTED;
+						}
+
+						if (tokens.optional(ZSTokenType.K_GET) != null) {
+							autoGetter = accessor;
+						} else {
+							tokens.required(ZSTokenType.K_SET, "get or set expected");
+							autoSetter = accessor;
+						}
+					} while (tokens.optional(ZSTokenType.T_COMMA) != null);
+				}
 				if (tokens.optional(ZSTokenType.T_ASSIGN) != null) {
 					initializer = ParsedExpression.parse(tokens);
 				}
 				tokens.required(ZSTokenType.T_SEMICOLON, "; expected");
-				return new ParsedField(start, forDefinition, modifiers, name, type, initializer, t.type == ZSTokenType.K_VAL);
+				return new ParsedField(start, forDefinition, modifiers, name, type, initializer, t.type == ZSTokenType.K_VAL, autoGetter, autoSetter);
 			}
 			case K_THIS: {
 				tokens.next();
 			case T_ORASSIGN:
 			case T_XORASSIGN:
 			case T_INCREMENT:
-			case T_DECREMENT: {
+			case T_DECREMENT:
+			case T_DOT2: {
 				ZSToken token = tokens.next();
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
 				return new ParsedIterator(start, forDefinition, modifiers, header, body);
 			}
 			default:
+				if (modifiers == Modifiers.STATIC && tokens.peek().type == ZSTokenType.T_AOPEN) {
+					ParsedStatementBlock body = ParsedStatementBlock.parseBlock(tokens, true);
+					return new ParsedStaticInitializer(forDefinition, tokens.peek().position, body);
+				}
 				throw new CompileException(tokens.peek().position, CompileExceptionCode.UNEXPECTED_TOKEN, "Unexpected token: " + tokens.peek().content);
 		}
 	}
 			case T_ANDASSIGN: return OperatorType.ANDASSIGN;
 			case T_ORASSIGN: return OperatorType.ORASSIGN;
 			case T_XORASSIGN: return OperatorType.XORASSIGN;
-			case T_INCREMENT: return OperatorType.POST_INCREMENT;
-			case T_DECREMENT: return OperatorType.POST_DECREMENT;
+			case T_INCREMENT: return OperatorType.INCREMENT;
+			case T_DECREMENT: return OperatorType.DECREMENT;
+			case T_DOT2: return OperatorType.RANGE;
 			default:
 				throw new AssertionError("Missing switch case in getOperator");
 		}

Parser/src/main/java/org/openzen/zenscript/parser/member/ParsedField.java

 	private final ParsedExpression expression;
 	private final boolean isFinal;
 	
+	private final int autoGetter;
+	private final int autoSetter;
+	
 	private FieldMember compiled;
 	
 	public ParsedField(
 			String name,
 			IParsedType type,
 			ParsedExpression expression,
-			boolean isFinal)
+			boolean isFinal,
+			int autoGetter,
+			int autoSetter)
 	{
 		super(definition);
 		
 		this.type = type;
 		this.expression = expression;
 		this.isFinal = isFinal;
+		this.autoGetter = autoGetter;
+		this.autoSetter = autoSetter;
 	}
 	
 	@Override

Parser/src/main/java/org/openzen/zenscript/parser/member/ParsedStaticInitializer.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.parser.member;
+
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.linker.BaseScope;
+import org.openzen.zenscript.linker.FunctionScope;
+import org.openzen.zenscript.parser.statements.ParsedStatement;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ParsedStaticInitializer extends ParsedDefinitionMember {
+	private final ParsedStatement body;
+	
+	private final StaticInitializerMember compiled;
+	
+	public ParsedStaticInitializer(HighLevelDefinition definition, CodePosition position, ParsedStatement body) {
+		super(definition);
+		
+		this.body = body;
+		compiled = new StaticInitializerMember(position);
+	}
+
+	@Override
+	public void linkInnerTypes() {
+		
+	}
+
+	@Override
+	public void linkTypes(BaseScope scope) {
+		
+	}
+
+	@Override
+	public IDefinitionMember getCompiled() {
+		return compiled;
+	}
+
+	@Override
+	public void compile(BaseScope scope) {
+		compiled.body = body.compile(new FunctionScope(scope, new FunctionHeader(BasicTypeID.VOID)));
+	}
+}

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

 import org.openzen.zenscript.parser.type.IParsedType;
 import org.openzen.zenscript.parser.type.ParsedTypeBasic;
 import org.openzen.zenscript.shared.CodePosition;
+import org.openzen.zenscript.shared.CompileException;
+import org.openzen.zenscript.shared.CompileExceptionCode;
 
 public abstract class ParsedStatement {
 	public static ParsedFunctionBody parseLambdaBody(ZSTokenStream tokens, boolean inExpression) {
 				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws, isFirst);
 				return new ParsedStatementBreak(t.position, whitespace, name);
 			}
+			case K_SWITCH: {
+				ZSToken t = parser.next();
+				String name = null;
+				if (parser.optional(T_COLON) != null)
+					name = parser.next().content;
+				
+				ParsedExpression value = ParsedExpression.parse(parser);
+				ParsedSwitchCase currentCase = null;
+				List<ParsedSwitchCase> cases = new ArrayList<>();
+				
+				parser.required(T_AOPEN, "{ expected");
+				while (parser.optional(T_ACLOSE) == null) {
+					if (parser.optional(K_CASE) != null) {
+						currentCase = new ParsedSwitchCase(ParsedExpression.parse(parser));
+						cases.add(currentCase);
+						parser.required(T_COLON, ": expected");
+					} else if (parser.optional(K_DEFAULT) != null) {
+						currentCase = new ParsedSwitchCase(null);
+						cases.add(currentCase);
+						parser.required(T_COLON, ": expected");
+					} else if (currentCase == null) {
+						throw new CompileException(parser.getPosition(), CompileExceptionCode.STATEMENT_OUTSIDE_SWITCH_CASE, "Statement in switch outside case");
+					} else {
+						currentCase.statements.add(ParsedStatement.parse(parser));
+					}
+				}
+				
+				WhitespaceInfo whitespace = parser.collectWhitespaceInfo(ws, isFirst);
+				return new ParsedStatementSwitch(t.position, whitespace, name, value, cases);
+			}
 		}
 
 		CodePosition position = parser.peek().getPosition();

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedStatementSwitch.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.parser.statements;
+
+import java.util.List;
+import java.util.function.Function;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.WhitespaceInfo;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.partial.IPartialExpression;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.SwitchStatement;
+import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.linker.ExpressionScope;
+import org.openzen.zenscript.linker.StatementScope;
+import org.openzen.zenscript.parser.expression.ParsedExpression;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ParsedStatementSwitch extends ParsedStatement {
+	private final String name;
+	private final ParsedExpression value;
+	private final List<ParsedSwitchCase> cases;
+	
+	public ParsedStatementSwitch(CodePosition position, WhitespaceInfo whitespace, String name, ParsedExpression value, List<ParsedSwitchCase> cases) {
+		super(position, whitespace);
+		
+		this.name = name;
+		this.value = value;
+		this.cases = cases;
+	}
+
+	@Override
+	public Statement compile(StatementScope scope) {
+		SwitchStatement result = new SwitchStatement(position, name, value.compile(new ExpressionScope(scope)).eval());
+		SwitchScope innerScope = new SwitchScope(scope, result);
+		
+		for (ParsedSwitchCase switchCase : cases) {
+			result.cases.add(switchCase.compile(innerScope));
+		}
+		
+		return result;
+	}
+	
+	private class SwitchScope extends StatementScope {
+		private final StatementScope outer;
+		private final SwitchStatement target;
+		
+		public SwitchScope(StatementScope outer, SwitchStatement target) {
+			this.outer = outer;
+			this.target = target;
+		}
+	
+		@Override
+		public IPartialExpression get(CodePosition position, GenericName name) {
+			IPartialExpression result = super.get(position, name);
+			if (result == null) {
+				return outer.get(position, name);
+			} else {
+				return result;
+			}
+		}
+
+		@Override
+		public LocalMemberCache getMemberCache() {
+			return outer.getMemberCache();
+		}
+
+		@Override
+		public ITypeID getType(CodePosition position, List<GenericName> name) {
+			return outer.getType(position, name);
+		}
+
+		@Override
+		public LoopStatement getLoop(String name) {
+			return name == null || name.equals(target.label) ? target : outer.getLoop(name);
+		}
+
+		@Override
+		public FunctionHeader getFunctionHeader() {
+			return outer.getFunctionHeader();
+		}
+
+		@Override
+		public ITypeID getThisType() {
+			return outer.getThisType();
+		}
+
+		@Override
+		public Function<CodePosition, Expression> getDollar() {
+			return outer.getDollar();
+		}
+
+		@Override
+		public IPartialExpression getOuterInstance(CodePosition position) {
+			return outer.getOuterInstance(position);
+		}
+	}
+}

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedSwitchCase.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.parser.statements;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.SwitchCase;
+import org.openzen.zenscript.linker.ExpressionScope;
+import org.openzen.zenscript.linker.StatementScope;
+import org.openzen.zenscript.parser.expression.ParsedExpression;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ParsedSwitchCase {
+	public final ParsedExpression value; // null for default
+	public final List<ParsedStatement> statements = new ArrayList<>();
+	
+	public ParsedSwitchCase(ParsedExpression value) {
+		this.value = value;
+	}
+	
+	public SwitchCase compile(StatementScope scope) {
+		Expression cValue = value == null ? null : value.compile(new ExpressionScope(scope)).eval();
+		List<Statement> cStatements = new ArrayList<>();
+		for (ParsedStatement statement : statements) {
+			cStatements.add(statement.compile(scope));
+		}
+		return new SwitchCase(cValue, cStatements);
+	}
+}

Parser/src/main/java/org/openzen/zenscript/parser/type/IParsedType.java

 import org.openzen.zenscript.linker.BaseScope;
 import org.openzen.zenscript.parser.ParseException;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
+import org.openzen.zenscript.parser.definitions.ParsedGenericParameter;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
 					
 					if (tokens.optional(ZSTokenType.T_SQCLOSE) != null) {
 						result = new ParsedTypeArray(result, dimension);
+					} else if (tokens.isNext(T_LESS)) {
+						List<ParsedGenericParameter> parameters = ParsedGenericParameter.parseAll(tokens);
+						result = new ParsedTypeGenericMap(parameters, result, modifiers);
+						tokens.required(ZSTokenType.T_SQCLOSE, "] expected");
 					} else {
 						IParsedType keyType = parse(tokens);
 						result = new ParsedTypeAssociative(keyType, result);

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedTypeGenericMap.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.parser.type;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.partial.IPartialExpression;
+import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
+import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+import org.openzen.zenscript.linker.BaseScope;
+import org.openzen.zenscript.parser.definitions.ParsedGenericParameter;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ParsedTypeGenericMap implements IParsedType {
+	private final List<ParsedGenericParameter> keys;
+	private final IParsedType value;
+	private final int modifiers;
+	
+	public ParsedTypeGenericMap(List<ParsedGenericParameter> keys, IParsedType value, int modifiers) {
+		this.keys = keys;
+		this.value = value;
+		this.modifiers = modifiers;
+	}
+
+	@Override
+	public IParsedType withOptional() {
+		return new ParsedTypeGenericMap(keys, value, modifiers | TypeMembers.MODIFIER_OPTIONAL);
+	}
+
+	@Override
+	public IParsedType withModifiers(int modifiers) {
+		return new ParsedTypeGenericMap(keys, value, modifiers | this.modifiers);
+	}
+
+	@Override
+	public ITypeID compile(BaseScope scope) {
+		TypeParameter[] cKeys = ParsedGenericParameter.getCompiled(keys);
+		ITypeID valueType = this.value.compile(new GenericMapScope(scope, cKeys));
+		
+		GlobalTypeRegistry registry = scope.getTypeRegistry();
+		return registry.getModified(modifiers, registry.getGenericMap(valueType, cKeys));
+	}
+	
+	private class GenericMapScope extends BaseScope {
+		private final BaseScope outer;
+		private final Map<String, TypeParameter> typeParameters = new HashMap<>();
+		
+		public GenericMapScope(BaseScope outer, TypeParameter[] parameters) {
+			this.outer = outer;
+			for (TypeParameter parameter : parameters)
+				typeParameters.put(parameter.name, parameter);
+		}
+
+		@Override
+		public LocalMemberCache getMemberCache() {
+			return outer.getMemberCache();
+		}
+
+		@Override
+		public IPartialExpression get(CodePosition position, GenericName name) {
+			if (typeParameters.containsKey(name.name) && name.arguments.isEmpty())
+				return new PartialTypeExpression(position, getTypeRegistry().getGeneric(typeParameters.get(name.name)));
+			
+			return outer.get(position, name);
+		}
+
+		@Override
+		public ITypeID getType(CodePosition position, List<GenericName> name) {
+			if (typeParameters.containsKey(name.get(0).name) && name.size() == 1 && name.get(0).arguments.isEmpty())
+				return getTypeRegistry().getGeneric(typeParameters.get(name.get(0).name));
+			
+			return outer.getType(position, name);
+		}
+
+		@Override
+		public LoopStatement getLoop(String name) {
+			return outer.getLoop(name);
+		}
+
+		@Override
+		public FunctionHeader getFunctionHeader() {
+			return outer.getFunctionHeader();
+		}
+
+		@Override
+		public ITypeID getThisType() {
+			return outer.getThisType();
+		}
+
+		@Override
+		public Function<CodePosition, Expression> getDollar() {
+			return outer.getDollar();
+		}
+
+		@Override
+		public IPartialExpression getOuterInstance(CodePosition position) {
+			return outer.getOuterInstance(position);
+		}
+	}
+}

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

 		
 		return shortFilename + ":" + fromLine + ":" + fromLineOffset;
 	}
-	
-	private static int compareLinePosition(int leftLine, int leftLineOffset, int rightLine, int rightLineOffset) {
-		if (leftLine == rightLine)
-			return leftLineOffset - rightLineOffset;
-		else
-			return leftLine - rightLine;
-	}
 }

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

 	INVALID_CONDITION,
 	INTERNAL_ERROR,
 	CANNOT_SET_FINAL_VARIABLE,
-	MISSING_PARAMETER
+	MISSING_PARAMETER,
+	STATEMENT_OUTSIDE_SWITCH_CASE
 }

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

 import java.util.Properties;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import java.util.regex.Pattern;
 
 /**
  *
  */
 public class StringUtils {
 	private static final Map<String, CharacterEntity> NAMED_CHARACTER_ENTITIES;
-	private static final Pattern MATCH_ACCENTS = Pattern.compile("\\p{M}");
+	
+	private StringUtils() {}
 	
 	static
 	{

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

 		LOCAL_VARIABLE_NOT_YET_INITIALIZED,
 		INVALID_SOURCE_TYPE,
 		SETTING_FINAL_FIELD,
-		SETTING_FINAL_VARIABLE
+		SETTING_FINAL_VARIABLE,
+		INVALID_SUPERTYPE
 	}
 }

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.member.StaticInitializerMember;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.validator.ValidationLogEntry;
 import org.openzen.zenscript.validator.Validator;
 		isValid &= innerDefinition.innerDefinition.accept(new DefinitionValidator(validator));
 		return isValid;
 	}
+
+	@Override
+	public Boolean visitStaticInitializer(StaticInitializerMember member) {
+		return member.body.accept(new StatementValidator(validator, new StaticInitializerScope()));
+	}
 	
 	private class FieldInitializerScope implements ExpressionScope {
 		private final FieldMember field;
 		}
 	}
 	
+	private class StaticInitializerScope implements StatementScope {
+		private final FunctionHeader header = new FunctionHeader(BasicTypeID.VOID);
+		
+		@Override
+		public boolean isConstructor() {
+			return false;
+		}
+
+		@Override
+		public boolean isStatic() {
+			return true;
+		}
+
+		@Override
+		public FunctionHeader getFunctionHeader() {
+			return header;
+		}
+
+		@Override
+		public boolean isStaticInitializer() {
+			return true;
+		}
+
+		@Override
+		public HighLevelDefinition getDefinition() {
+			return definition;
+		}
+	}
+	
 	private class EnumConstantInitializerScope implements ExpressionScope {
 
 		@Override

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

 				PUBLIC | EXPORT | PROTECTED | PRIVATE,
 				definition.position,
 				"Invalid expansion modifier");
-		isValid &= ValidationUtils.validateIdentifier(
-				validator,
-				definition.position,
-				definition.name);
 		
 		isValid &= definition.target.accept(new TypeValidator(validator, definition.position));
 		isValid &= validateMembers(definition);

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

 import org.openzen.zenscript.codemodel.expression.NewExpression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.expression.OrOrExpression;
+import org.openzen.zenscript.codemodel.expression.PostCallExpression;
 import org.openzen.zenscript.codemodel.expression.RangeExpression;
 import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
 import org.openzen.zenscript.codemodel.expression.SetFunctionParameterExpression;
 		}
 		return isValid;
 	}
+	
+	@Override
+	public Boolean visitPostCall(PostCallExpression expression) {
+		boolean isValid = true;
+		expression.target.accept(this);
+		// TODO: is target a valid increment target?
+		return isValid;
+	}
 
 	@Override
 	public Boolean visitRange(RangeExpression expression) {

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

 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.SwitchCase;
+import org.openzen.zenscript.codemodel.statement.SwitchStatement;
 import org.openzen.zenscript.codemodel.statement.ThrowStatement;
 import org.openzen.zenscript.codemodel.statement.TryCatchStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 		return isValid;
 	}
 
+	@Override
+	public Boolean visitSwitch(SwitchStatement statement) {
+		boolean isValid = true;
+		isValid &= statement.value.accept(new ExpressionValidator(validator, new StatementExpressionScope()));
+		
+		for (SwitchCase switchCase : statement.cases) {
+			// TODO: finish this
+		}
+		
+		return isValid;
+	}
+
 	@Override
 	public Boolean visitThrow(ThrowStatement statement) {
 		boolean isValid = statement.value.accept(new ExpressionValidator(validator, new StatementExpressionScope()));

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

  */
 package org.openzen.zenscript.validator.visitors;
 
+import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ConstTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
+import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeVisitor;
 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
 
 	@Override
 	public Boolean visitArray(ArrayTypeID array) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		validator.logError(ValidationLogEntry.Code.SUPERCLASS_NOT_A_CLASS, position, "Superclass cannot be an array");
+		return false;
 	}
 
 	@Override
 	public Boolean visitAssoc(AssocTypeID assoc) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		validator.logError(ValidationLogEntry.Code.SUPERCLASS_NOT_A_CLASS, position, "Superclass cannot be an associative array");
+		return false;
 	}
 
 	@Override
 	public Boolean visitIterator(IteratorTypeID iterator) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		validator.logError(ValidationLogEntry.Code.SUPERCLASS_NOT_A_CLASS, position, "Superclass cannot be an iterator");
+		return false;
 	}
 
 	@Override
 	public Boolean visitFunction(FunctionTypeID function) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		validator.logError(ValidationLogEntry.Code.SUPERCLASS_NOT_A_CLASS, position, "Superclass cannot be a function");
+		return false;
 	}
 
 	@Override
 	public Boolean visitDefinition(DefinitionTypeID definition) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		boolean isValid = true;
+		if (!Modifiers.isVirtual(definition.definition.modifiers)) {
+			validator.logError(ValidationLogEntry.Code.INVALID_SUPERTYPE, position, "Supertype must be virtual");
+			isValid = false;
+		}
+		return isValid;
 	}
 
 	@Override
 	public Boolean visitGeneric(GenericTypeID generic) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		validator.logError(ValidationLogEntry.Code.SUPERCLASS_NOT_A_CLASS, position, "Superclass cannot be a type parameter");
+		return false;
 	}
 
 	@Override
 	public Boolean visitRange(RangeTypeID range) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		validator.logError(ValidationLogEntry.Code.SUPERCLASS_NOT_A_CLASS, position, "Superclass cannot be a range");
+		return false;
 	}
 
 	@Override
 	public Boolean visitConst(ConstTypeID type) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		validator.logError(ValidationLogEntry.Code.SUPERCLASS_NOT_A_CLASS, position, "Superclass cannot be a const type");
+		return false;
 	}
 
 	@Override
 	public Boolean visitOptional(OptionalTypeID optional) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		validator.logError(ValidationLogEntry.Code.SUPERCLASS_NOT_A_CLASS, position, "Superclass cannot be an optional type");
+		return false;
+	}
+
+	@Override
+	public Boolean visitGenericMap(GenericMapTypeID map) {
+		validator.logError(ValidationLogEntry.Code.SUPERCLASS_NOT_A_CLASS, position, "Superclass cannot be a generic map");
+		return false;
 	}
-	
 }

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

 import org.openzen.zenscript.codemodel.type.ConstTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
+import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.ITypeVisitor;
 		// TODO: detect duplicate optional
 		return optional.baseType.accept(this);
 	}
+
+	@Override
+	public Boolean visitGenericMap(GenericMapTypeID map) {
+		boolean isValid = true;
+		isValid &= map.value.accept(this);
+		
+		return isValid;
+	}
 }

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

 	private ValidationUtils() {}
 	
 	public static boolean validateIdentifier(Validator target, CodePosition position, String identifier) { 
-		if (!IDENTIFIER_PATTERN.matcher(identifier).matches()) {
+		if (identifier == null || !IDENTIFIER_PATTERN.matcher(identifier).matches()) {
 			target.logError(INVALID_IDENTIFIER, position, "Invalid identifier: " + identifier);
 			return false;
 		}