- Renamed enum constant index to ordinal

- Added ordinal to variant options
- Added GetMatchingVariantField; from now on values retrieved from variant option fields in a match or case will result in such expression. This may make it easier for compilers.

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

 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.GetMatchingVariantField;
 import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
 import org.openzen.zenscript.codemodel.expression.GetterExpression;
 import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
 	public ExpressionString visitGetLocalVariable(GetLocalVariableExpression expression) {
 		return new ExpressionString(expression.variable.name, ZenScriptOperator.PRIMARY);
 	}
+	
+	@Override
+	public ExpressionString visitGetMatchingVariantField(GetMatchingVariantField expression) {
+		return new ExpressionString(expression.value.parameters[expression.index], ZenScriptOperator.PRIMARY);
+	}
 
 	@Override
 	public ExpressionString visitGetStaticField(GetStaticFieldExpression expression) {

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

 	
 	public static class Option extends Taggable {
 		public final String name;
+		public final int ordinal;
 		public final ITypeID[] types;
 		
-		public Option(String name, ITypeID[] types) {
+		public Option(String name, int ordinal, ITypeID[] types) {
 			this.name = name;
+			this.ordinal = ordinal;
 			this.types = types;
 		}
 		

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

 	
 	public T visitGetLocalVariable(GetLocalVariableExpression expression);
 	
+	public T visitGetMatchingVariantField(GetMatchingVariantField expression);
+	
 	public T visitGetStaticField(GetStaticFieldExpression expression);
 	
 	public T visitGetter(GetterExpression expression);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/GetMatchingVariantField.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.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class GetMatchingVariantField extends Expression {
+	public final VariantOptionSwitchValue value;
+	public final int index;
+	
+	public GetMatchingVariantField(CodePosition position, VariantOptionSwitchValue value, int index) {
+		super(position, value.option.types[index], null);
+		
+		this.value = value;
+		this.index = index;
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitGetMatchingVariantField(this);
+	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/switchvalue/VariantOptionSwitchValue.java

 package org.openzen.zenscript.codemodel.expression.switchvalue;
 
 import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
-import org.openzen.zenscript.codemodel.statement.VarStatement;
 
 /**
  *
  */
 public class VariantOptionSwitchValue implements SwitchValue {
 	public final VariantOptionRef option;
-	public final VarStatement[] parameters;
+	public final String[] parameters;
 	
-	public VariantOptionSwitchValue(VariantOptionRef option, VarStatement[] parameters) {
+	public VariantOptionSwitchValue(VariantOptionRef option, String[] parameters) {
 		this.option = option;
 		this.parameters = parameters;
 	}

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

 	public final CodePosition position;
 	public final HighLevelDefinition definition;
 	public final String name;
-	public final int value;
+	public final int ordinal;
 	
 	public NewExpression constructor;
 	
-	public EnumConstantMember(CodePosition position, HighLevelDefinition definition, String name, int value) {
+	public EnumConstantMember(CodePosition position, HighLevelDefinition definition, String name, int ordinal) {
 		this.position = position;
 		this.definition = definition;
 		this.name = name;
-		this.value = value;
+		this.ordinal = ordinal;
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/ExpressionScope.java

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.expression.GetMatchingVariantField;
+import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 	
 	public final List<ITypeID> hints;
 	public final Map<TypeParameter, ITypeID> genericInferenceMap;
-	public final Map<String, VarStatement> innerVariables = new HashMap<>();
+	public final Map<String, Function<CodePosition, Expression>> innerVariables = new HashMap<>();
 	
 	public ExpressionScope(BaseScope outer) {
 		this.outer = outer;
 			List<ITypeID> hints,
 			Function<CodePosition, Expression> dollar,
 			Map<TypeParameter, ITypeID> genericInferenceMap,
-			Map<String, VarStatement> innerVariables) {
+			Map<String, Function<CodePosition, Expression>> innerVariables) {
 		this.outer = scope;
 		this.hints = hints;
 		this.dollar = dollar;
 	}
 	
 	public void addInnerVariable(VarStatement variable) {
-		innerVariables.put(variable.name, variable);
+		innerVariables.put(variable.name, position -> new GetLocalVariableExpression(position, variable));
+	}
+	
+	public void addMatchingVariantOption(String name, int index, VariantOptionSwitchValue value) {
+		innerVariables.put(name, position -> new GetMatchingVariantField(position, value, index));
 	}
 	
 	public List<ITypeID> getResultTypeHints() {
 	@Override
 	public IPartialExpression get(CodePosition position, GenericName name) {
 		if (name.hasNoArguments() && innerVariables.containsKey(name.name))
-			return new GetLocalVariableExpression(position, innerVariables.get(name.name));
+			return innerVariables.get(name.name).apply(position);
 		
 		return outer.get(position, name);
 	}

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

 	
 	@Override
 	public void addDefinition(HighLevelDefinition definition, SemanticModule module) {
-		String className = getClassName(definition.position.filename);
+		String className = getClassName(definition.position.getFilename());
 		JavaScriptFile scriptFile = getScriptFile(className);
 		target.register(definition.name, definition.accept(new JavaDefinitionVisitor(scriptFile.classWriter)));
 	}

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

     }
 
     public static String calcClasName(CodePosition position) {
-        return position.filename.substring(0, position.filename.lastIndexOf('.')).replace("/", "_");
+        return position.getFilename().substring(0, position.getFilename().lastIndexOf('.')).replace("/", "_");
     }
 
     public static void tagMethodParameters(FunctionHeader header, boolean isStatic) {
 
 		@Override
 		public Integer acceptEnumConstant(EnumConstantSwitchValue value) {
-			return value.constant.value;
+			return value.constant.ordinal;
 		}
 
 		@Override

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

         javaWriter.label(label);
         return null;
     }
+	
+	@Override
+	public Void visitGetMatchingVariantField(GetMatchingVariantField expression) {
+		throw new UnsupportedOperationException(); // TODO
+	}
 
     @Override
     public Void visitGetStaticField(GetStaticFieldExpression expression) {

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

 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.GetMatchingVariantField;
 import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
 import org.openzen.zenscript.codemodel.expression.GetterExpression;
 import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
 		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 visitGetMatchingVariantField(GetMatchingVariantField expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
 	@Override
 	public Void visitGetStaticField(GetStaticFieldExpression expression) {
 		if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))

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

 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.GetMatchingVariantField;
 import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
 import org.openzen.zenscript.codemodel.expression.GetterExpression;
 import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
 		return null;
 	}
 
+	@Override
+	public Void visitGetMatchingVariantField(GetMatchingVariantField expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
 	@Override
 	public Void visitGetStaticField(GetStaticFieldExpression expression) {
 		if (!expressionCompiler.checkAndGetFieldInfo(expression.field, false))

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

 
     @Override
     public byte[] visitEnum(EnumDefinition definition) {
-		System.out.println("Compiling enum " + definition.name + " in " + definition.position.filename);
+		System.out.println("Compiling enum " + definition.name + " in " + definition.position.getFilename());
 		
         final Type superType;
         if (definition.getSuperType() == null)

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

 				clinitWriter.newObject(internalName);
 				clinitWriter.dup();
 				clinitWriter.constant(constant.name);
-				clinitWriter.constant(constant.value);
+				clinitWriter.constant(constant.ordinal);
 				for (Expression argument : constant.constructor.arguments.arguments) {
 					argument.accept(clinitStatementVisitor.expressionVisitor);
 				}
 
             for (EnumConstantMember enumConstant : enumConstants) {
                 clinitWriter.dup();
-                clinitWriter.constant(enumConstant.value);
+                clinitWriter.constant(enumConstant.ordinal);
                 clinitWriter.getStaticField(definition.name, enumConstant.name, "L" + definition.name + ";");
                 clinitWriter.arrayStore(Type.getType("L" + definition.name + ";"));
             }

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/ExpressionHoistingChecker.java

 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.GetMatchingVariantField;
 import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
 import org.openzen.zenscript.codemodel.expression.GetterExpression;
 import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
 		return false;
 	}
 
+	@Override
+	public Boolean visitGetMatchingVariantField(GetMatchingVariantField expression) {
+		return false;
+	}
+
 	@Override
 	public Boolean visitGetStaticField(GetStaticFieldExpression expression) {
 		return false;

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceExpressionFormatter.java

 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.GetMatchingVariantField;
 import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
 import org.openzen.zenscript.codemodel.expression.GetterExpression;
 import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
 		return new ExpressionString(expression.variable.name, JavaOperator.PRIMARY);
 	}
 
+	@Override
+	public ExpressionString visitGetMatchingVariantField(GetMatchingVariantField expression) {
+		return new ExpressionString(expression.value.parameters[expression.index], JavaOperator.PRIMARY);
+	}
+
 	@Override
 	public ExpressionString visitGetStaticField(GetStaticFieldExpression expression) {
 		JavaSourceField field = expression.field.getTag(JavaSourceField.class);

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceStatementFormatter.java

 				String header = switchValue == null ? "default:" : "case " + switchValue.option.getName() + ":";
 				List<String> statements = new ArrayList<>();
 				if (switchValue != null) {
-					for (VarStatement var : switchValue.parameters) {
+					for (int i = 0; i < switchValue.parameters.length; i++) {
 						StringBuilder statementOutput = new StringBuilder();
-						statementOutput.append(scope.type(var.type)).append(" ").append(var.name).append(" = ((").append(variantTypeName).append(".").append(switchValue.option.getName());
+						statementOutput.append(scope.type(switchValue.option.types[i])).append(" ").append(switchValue.parameters[i]).append(" = ((").append(variantTypeName).append(".").append(switchValue.option.getName());
 						if (variant.genericParameters != null && variant.genericParameters.length > 0) {
 							statementOutput.append("<");
-							for (int i = 0; i < variantType.typeParameters.length; i++) {
-								if (i > 0)
+							for (int j = 0; j < variantType.typeParameters.length; j++) {
+								if (j > 0)
 									statementOutput.append(", ");
-								statementOutput.append(scope.type(variantType.typeParameters[i]));
+								statementOutput.append(scope.type(variantType.typeParameters[j]));
 							}
 							statementOutput.append(">");
 						}

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

 		
 		ParsedVariant result = new ParsedVariant(pkg, position, modifiers, annotations, name, typeParameters, outerDefinition);
 		
+		int ordinal = 0;
 		while (!tokens.isNext(ZSTokenType.T_ACLOSE) && !tokens.isNext(ZSTokenType.T_SEMICOLON)) {
 			String optionName = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 			List<IParsedType> types = new ArrayList<>();
 				}
 				tokens.required(ZSTokenType.T_BRCLOSE, ") expected");
 			}
-			result.addVariant(new ParsedVariantOption(optionName, types));
+			result.addVariant(new ParsedVariantOption(optionName, ordinal++, types));
 			if (tokens.optional(ZSTokenType.T_COMMA) == null)
 				break;
 		}

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

 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.parser.type.IParsedType;
 
 /**
  */
 public class ParsedVariantOption {
 	public final String name;
+	public final int ordinal;
 	public final List<IParsedType> types;
 	
-	public ParsedVariantOption(String name, List<IParsedType> types) {
+	public ParsedVariantOption(String name, int ordinal, List<IParsedType> types) {
 		this.name = name;
+		this.ordinal = ordinal;
 		this.types = types;
 	}
 	
 		for (int i = 0; i < cTypes.length; i++)
 			cTypes[i] = types.get(i).compile(context);
 		
-		return new VariantDefinition.Option(name, cTypes);
+		return new VariantDefinition.Option(name, ordinal, cTypes);
 	}
 }

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

 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
-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.codemodel.type.member.DefinitionMemberGroup;
 			if (option == null)
 				throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Variant option does not exist: " + name);
 			
-			VarStatement[] values = new VarStatement[arguments.arguments.size()];
+			String[] values = new String[arguments.arguments.size()];
 			for (int i = 0; i < values.length; i++) {
 				ParsedExpression argument = arguments.arguments.get(i);
 				ParsedFunctionParameter lambdaHeader = argument.toLambdaParameter();
-				values[i] = new VarStatement(argument.position, lambdaHeader.name, option.types[i], null, true);
+				values[i] = lambdaHeader.name;
 			}
 			
 			return new VariantOptionSwitchValue(option, values);

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

 			if (option.types.length > 0)
 				throw new CompileException(position, CompileExceptionCode.MISSING_VARIANT_CASEPARAMETERS, "Variant case is missing parameters");
 			
-			return new VariantOptionSwitchValue(option, new VarStatement[0]);
+			return new VariantOptionSwitchValue(option, new String[0]);
 		} else {
 			throw new CompileException(position, CompileExceptionCode.INVALID_SWITCH_CASE, "Invalid switch case");
 		}

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

 import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
 import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
-import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
-import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 			if (switchValue instanceof VariantOptionSwitchValue) {
 				VariantOptionSwitchValue variantSwitchValue = (VariantOptionSwitchValue)switchValue;
 				
-				for (VarStatement var : variantSwitchValue.parameters)
-					innerScope.addInnerVariable(var);
+				for (int i = 0; i < variantSwitchValue.parameters.length; i++)
+					innerScope.addMatchingVariantOption(variantSwitchValue.parameters[i], i, variantSwitchValue);
 			}
 			
 			Expression value = this.value.compile(innerScope).eval();

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

 package org.openzen.zencode.shared;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.VirtualSourceFile;
 
 public final class CodePosition {
-	public static final CodePosition BUILTIN = new CodePosition(new VirtualSourceFile("builtin"), 0, 0, 0, 0);
-	public static final CodePosition NATIVE = new CodePosition(new VirtualSourceFile("native"), 0, 0, 0, 0);
-	public final String filename;
-	public final SourceFile file;
-	public final int fromLine;
-	public final int fromLineOffset;
-	public final int toLine;
-	public final int toLineOffset;
-	
-	public CodePosition(SourceFile file, int fromLine, int fromLineOffset, int toLine, int toLineOffset) {
-		this.file = file;
-	    this.filename = file.getFilename();
-	    this.fromLine = fromLine;
-	    this.fromLineOffset = fromLineOffset;
-	    this.toLine = toLine;
-	    this.toLineOffset = toLineOffset;
-	}
-	
-	public String toShortString() {
-	    int lastSeparator = filename.lastIndexOf('/');
-	    String shortFilename = lastSeparator >= 0 ? filename.substring(lastSeparator + 1, (filename).length()) : filename;
-	    if (fromLine == 0 && fromLineOffset == 0)
-	        return shortFilename;
-	    return shortFilename + ":" + Integer.toString(fromLine) + ":" + Integer.toString(fromLineOffset);
-	}
-	
-	public CodePosition until(CodePosition to) {
-	    if (!filename.equals(to.filename))
-	        throw new AssertionError("From and to positions must be in the same file!");
-	    return new CodePosition(file, fromLine, fromLineOffset, to.toLine, to.toLineOffset);
-	}
-	
-	public String toString() {
-	    return fromLine == 0 && fromLineOffset == 0 ? filename : filename + ":" + Integer.toString(fromLine) + ":" + Integer.toString(fromLineOffset);
-	}
-	
-	public String getFilename() {
-	    return filename;
-	}
-	
-	public int getFromLine() {
-	    return fromLine;
-	}
-	
-	public int getFromLineOffset() {
-	    return fromLineOffset;
-	}
-	
-	public int getToLine() {
-	    return toLine;
-	}
-	
-	public int getToLineOffset() {
-	    return toLineOffset;
-	}
+    public static final CodePosition BUILTIN = new CodePosition(new VirtualSourceFile("builtin"), 0, 0, 0, 0);
+    public static final CodePosition NATIVE = new CodePosition(new VirtualSourceFile("native"), 0, 0, 0, 0);
+    public final SourceFile file;
+    public final int fromLine;
+    public final int fromLineOffset;
+    public final int toLine;
+    public final int toLineOffset;
+    
+    public CodePosition(SourceFile file, int fromLine, int fromLineOffset, int toLine, int toLineOffset) {
+        this.file = file;
+        this.fromLine = fromLine;
+        this.fromLineOffset = fromLineOffset;
+        this.toLine = toLine;
+        this.toLineOffset = toLineOffset;
+    }
+    
+    public String getFilename() {
+        return file.getFilename();
+    }
+    
+    public String toShortString() {
+        int lastSeparator = file.getFilename().lastIndexOf('/');
+        String shortFilename = lastSeparator >= 0 ? file.getFilename().substring(lastSeparator + 1, (file.getFilename()).length()) : file.getFilename();
+        if (fromLine == 0 && fromLineOffset == 0)
+            return shortFilename;
+        return shortFilename + ":" + Integer.toString(fromLine) + ":" + Integer.toString(fromLineOffset);
+    }
+    
+    public CodePosition until(CodePosition to) {
+        if (!(file == to.file))
+            throw new AssertionError("From and to positions must be in the same file!");
+        return new CodePosition(file, fromLine, fromLineOffset, to.toLine, to.toLineOffset);
+    }
+    
+    public String toString() {
+        return fromLine == 0 && fromLineOffset == 0 ? file.getFilename() : file.getFilename() + ":" + Integer.toString(fromLine) + ":" + Integer.toString(fromLineOffset);
+    }
+    
+    public SourceFile getFile() {
+        return file;
+    }
+    
+    public int getFromLine() {
+        return fromLine;
+    }
+    
+    public int getFromLineOffset() {
+        return fromLineOffset;
+    }
+    
+    public int getToLine() {
+        return toLine;
+    }
+    
+    public int getToLineOffset() {
+        return toLineOffset;
+    }
 }

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

 package org.openzen.zencode.shared;
 
 public enum CompileExceptionCode {
-	UNEXPECTED_TOKEN,
-	IMPORT_NOT_FOUND,
-	NO_OUTER_BECAUSE_NOT_INNER,
-	NO_OUTER_BECAUSE_STATIC,
-	NO_OUTER_BECAUSE_OUTSIDE_TYPE,
-	TYPE_ARGUMENTS_INVALID_NUMBER,
-	TYPE_ARGUMENTS_NOT_INFERRABLE,
-	USING_STATIC_ON_INSTANCE,
-	CANNOT_ASSIGN,
-	UNAVAILABLE_IN_CLOSURE,
-	USING_PACKAGE_AS_EXPRESSION,
-	USING_PACKAGE_AS_CALL_TARGET,
-	USING_TYPE_AS_EXPRESSION,
-	MEMBER_NO_SETTER,
-	MEMBER_NO_GETTER,
-	MEMBER_NOT_STATIC,
-	MEMBER_IS_FINAL,
-	MEMBER_DUPLICATE,
-	CALL_AMBIGUOUS,
-	CALL_NO_VALID_METHOD,
-	ENUM_VALUE_DUPLICATE,
-	INVALID_CAST,
-	NO_SUCH_INNER_TYPE,
-	NO_DOLLAR_HERE,
-	UNSUPPORTED_XML_EXPRESSIONS,
-	UNSUPPORTED_NAMED_ARGUMENTS,
-	TYPE_CANNOT_UNITE,
-	BRACKET_MULTIPLE_EXPRESSIONS,
-	SUPER_CALL_NO_SUPERCLASS,
-	LAMBDA_HEADER_INVALID,
-	COALESCE_TARGET_NOT_OPTIONAL,
-	MULTIPLE_MATCHING_HINTS,
-	MISSING_MAP_KEY,
-	NO_SUCH_MEMBER,
-	USING_THIS_OUTSIDE_TYPE,
-	USING_THIS_STATIC,
-	UNDEFINED_VARIABLE,
-	METHOD_BODY_REQUIRED,
-	BREAK_OUTSIDE_LOOP,
-	CONTINUE_OUTSIDE_LOOP,
-	NO_SUCH_ITERATOR,
-	NO_SUCH_TYPE,
-	RETURN_VALUE_REQUIRED,
-	RETURN_VALUE_VOID,
-	INVALID_CONDITION,
-	INTERNAL_ERROR,
-	CANNOT_SET_FINAL_VARIABLE,
-	MISSING_PARAMETER,
-	STATEMENT_OUTSIDE_SWITCH_CASE,
-	MISSING_VARIANT_CASEPARAMETERS,
-	INVALID_SWITCH_CASE,
-	TRY_CONVERT_OUTSIDE_FUNCTION,
-	TRY_CONVERT_ILLEGAL_TARGET,
-	TRY_RETHROW_NOT_A_RESULT,
-	DIFFERENT_EXCEPTIONS,
-	UNKNOWN_ANNOTATION,
-	OVERRIDE_WITHOUT_BASE,
-	OVERRIDE_AMBIGUOUS,
-	OVERRIDE_CONSTRUCTOR,
-	PRECOMPILE_FAILED,
-	UNTYPED_EMPTY_ARRAY,
-	UNTYPED_EMPTY_MAP,
-	VAR_WITHOUT_TYPE_OR_INITIALIZER,
-	NO_BRACKET_PARSER,
-	INVALID_BRACKET_EXPRESSION
+	UNEXPECTED_TOKEN(),
+	IMPORT_NOT_FOUND(),
+	NO_OUTER_BECAUSE_NOT_INNER(),
+	NO_OUTER_BECAUSE_STATIC(),
+	NO_OUTER_BECAUSE_OUTSIDE_TYPE(),
+	TYPE_ARGUMENTS_INVALID_NUMBER(),
+	TYPE_ARGUMENTS_NOT_INFERRABLE(),
+	USING_STATIC_ON_INSTANCE(),
+	CANNOT_ASSIGN(),
+	UNAVAILABLE_IN_CLOSURE(),
+	USING_PACKAGE_AS_EXPRESSION(),
+	USING_PACKAGE_AS_CALL_TARGET(),
+	USING_TYPE_AS_EXPRESSION(),
+	MEMBER_NO_SETTER(),
+	MEMBER_NO_GETTER(),
+	MEMBER_NOT_STATIC(),
+	MEMBER_IS_FINAL(),
+	MEMBER_DUPLICATE(),
+	CALL_AMBIGUOUS(),
+	CALL_NO_VALID_METHOD(),
+	ENUM_VALUE_DUPLICATE(),
+	INVALID_CAST(),
+	NO_SUCH_INNER_TYPE(),
+	NO_DOLLAR_HERE(),
+	UNSUPPORTED_XML_EXPRESSIONS(),
+	UNSUPPORTED_NAMED_ARGUMENTS(),
+	TYPE_CANNOT_UNITE(),
+	BRACKET_MULTIPLE_EXPRESSIONS(),
+	SUPER_CALL_NO_SUPERCLASS(),
+	LAMBDA_HEADER_INVALID(),
+	COALESCE_TARGET_NOT_OPTIONAL(),
+	MULTIPLE_MATCHING_HINTS(),
+	MISSING_MAP_KEY(),
+	NO_SUCH_MEMBER(),
+	USING_THIS_OUTSIDE_TYPE(),
+	USING_THIS_STATIC(),
+	UNDEFINED_VARIABLE(),
+	METHOD_BODY_REQUIRED(),
+	BREAK_OUTSIDE_LOOP(),
+	CONTINUE_OUTSIDE_LOOP(),
+	NO_SUCH_ITERATOR(),
+	NO_SUCH_TYPE(),
+	RETURN_VALUE_REQUIRED(),
+	RETURN_VALUE_VOID(),
+	INVALID_CONDITION(),
+	INTERNAL_ERROR(),
+	CANNOT_SET_FINAL_VARIABLE(),
+	MISSING_PARAMETER(),
+	STATEMENT_OUTSIDE_SWITCH_CASE(),
+	MISSING_VARIANT_CASEPARAMETERS(),
+	INVALID_SWITCH_CASE(),
+	TRY_CONVERT_OUTSIDE_FUNCTION(),
+	TRY_CONVERT_ILLEGAL_TARGET(),
+	TRY_RETHROW_NOT_A_RESULT(),
+	DIFFERENT_EXCEPTIONS(),
+	UNKNOWN_ANNOTATION(),
+	OVERRIDE_WITHOUT_BASE(),
+	OVERRIDE_AMBIGUOUS(),
+	OVERRIDE_CONSTRUCTOR(),
+	PRECOMPILE_FAILED(),
+	UNTYPED_EMPTY_ARRAY(),
+	UNTYPED_EMPTY_MAP(),
+	VAR_WITHOUT_TYPE_OR_INITIALIZER(),
+	NO_BRACKET_PARSER(),
+	INVALID_BRACKET_EXPRESSION()
 }

Shared/src/main/java/org/openzen/zencode/shared/LiteralSourceFile.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.zencode.shared;
 
 import java.io.IOException;
 import java.io.Reader;
 import java.io.StringReader;
 
-/**
- *
- * @author Hoofdgebruiker
- */
-public class LiteralSourceFile implements SourceFile {
-	private final String filename;
-	private final String contents;
-	
-	public LiteralSourceFile(String filename, String contents) {
-		this.filename = filename;
-		this.contents = contents;
-	}
-
-	@Override
-	public String getFilename() {
-		return filename;
-	}
-
-	@Override
-	public Reader open() throws IOException {
-		return new StringReader(contents);
-	}
-
-	@Override
-	public void update(String content) throws IOException {
-		throw new UnsupportedOperationException("Cannot update literal source files");
-	}
+public final class LiteralSourceFile implements SourceFile {
+    public final String filename;
+    private final String contents;
+    
+    public LiteralSourceFile(String filename, String contents) {
+        this.filename = filename;
+        this.contents = contents;
+    }
+    
+    @Override
+    public Reader open() throws IOException {
+        return new StringReader(contents);
+    }
+    
+    @Override
+    public void update(String contents) throws IOException {
+        throw new AssertionError("Cannot update literal source files");
+    }
+    
+    public String getFilename() {
+        return filename;
+    }
 }

Shared/src/main/java/org/openzen/zencode/shared/SourceFile.java

 import java.io.Reader;
 
 public interface SourceFile {
-	String getFilename();
-	
-	Reader open() throws IOException;
-	
-	void update(String content) throws IOException;
+    String getFilename();
+    
+    Reader open() throws IOException;
+    
+    void update(String content) throws IOException;
 }

Shared/src/main/java/org/openzen/zencode/shared/VirtualSourceFile.java

         throw new AssertionError("Cannot open virtual source files");
     }
     
+    @Override
+    public void update(String content) throws IOException {
+        throw new AssertionError("Cannot write to virtual source files");
+    }
+    
     public String getFilename() {
         return filename;
     }
-
-	@Override
-	public void update(String content) throws IOException {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-	}
 }

Shared/src/main/java/stdlib/Result.java

     public static class Ok<T, E> extends Result<T, E> {
         public final T value;
         
-        public Ok(T value){
+        public Ok(T value) {
             this.value = value;
         }
         
     public static class Error<T, E> extends Result<T, E> {
         public final E value;
         
-        public Error(E value){
+        public Error(E value) {
             this.value = value;
         }
         

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

 		INVALID_OVERRIDE,
 		SUPERTYPE_NOT_DESTRUCTIBLE,
 		INVALID_IMPLEMENTATION_TYPE,
-		INCOMPLETE_IMPLEMENTATION
+		INCOMPLETE_IMPLEMENTATION,
+		MATCHING_VARIANT_FIELD_INVALID
 	}
 }

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

 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.GetMatchingVariantField;
 import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
 import org.openzen.zenscript.codemodel.expression.GetterExpression;
 import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
 		}
 		return null;
 	}
+	
+	@Override
+	public Void visitGetMatchingVariantField(GetMatchingVariantField expression) {
+		if (expression.index >= expression.value.parameters.length) {
+			validator.logError(ValidationLogEntry.Code.MATCHING_VARIANT_FIELD_INVALID, expression.position, "Invalid matching variant field");
+		}
+		return null;
+	}
 
 	@Override
 	public Void visitGetStaticField(GetStaticFieldExpression expression) {