Merge remote-tracking branch 'Stan/development' into development

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

 			if (parameter.variadic)
 				result.append("...");
 			
-			if (!settings.showAnyInFunctionHeaders || parameter.type != BasicTypeID.ANY) {
+			if (!settings.showAnyInFunctionHeaders || parameter.type != BasicTypeID.UNDETERMINED) {
 				result.append(" as ");
 				result.append(header.returnType.accept(typeFormatter));
 			}
 			parameterIndex++;
 		}
 		result.append(")");
-		if (!settings.showAnyInFunctionHeaders || header.returnType != BasicTypeID.ANY) {
+		if (!settings.showAnyInFunctionHeaders || header.returnType != BasicTypeID.UNDETERMINED) {
 			result.append(" as ");
 			result.append(header.returnType.accept(typeFormatter));
 		}

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

  */
 package org.openzen.zenscript.codemodel;
 
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 
 /**
 	
 	public final int minParameters;
 	public final int maxParameters;
+	public final boolean hasUnknowns;
 	
 	public FunctionHeader(ITypeID returnType) {
 		if (returnType == null)
 		
 		minParameters = 0;
 		maxParameters = 0;
+		hasUnknowns = returnType == BasicTypeID.UNDETERMINED;
 	}
 	
 	public FunctionHeader(ITypeID returnType, ITypeID... parameterTypes) {
 		
 		minParameters = parameterTypes.length;
 		maxParameters = parameterTypes.length;
+		hasUnknowns = hasUnknowns(parameterTypes);
 	}
 	
 	public FunctionHeader(ITypeID returnType, FunctionParameter... parameters) {
 		
 		minParameters = getMinParameters(parameters);
 		maxParameters = getMaxParameters(parameters);
+		hasUnknowns = hasUnknowns(parameters);
 	}
 	
 	public FunctionHeader(TypeParameter[] genericParameters, ITypeID returnType, ITypeID thrownType, FunctionParameter... parameters) {
 		
 		minParameters = getMinParameters(parameters);
 		maxParameters = getMaxParameters(parameters);
+		hasUnknowns = hasUnknowns(parameters);
 	}
 	
 	public int getNumberOfTypeParameters() {
 		return typeParameters.length;
 	}
 	
+	public FunctionHeader withReturnType(ITypeID returnType) {
+		return new FunctionHeader(typeParameters, returnType, thrownType, parameters);
+	}
+	
+	public FunctionHeader inferFromOverride(GlobalTypeRegistry registry, FunctionHeader overridden) {
+		TypeParameter[] resultTypeParameters = typeParameters;
+		GenericMapper mapper;
+		if (resultTypeParameters == TypeParameter.NONE) {
+			resultTypeParameters = overridden.typeParameters;
+			mapper = new GenericMapper(registry, Collections.emptyMap());
+		} else {
+			Map<TypeParameter, ITypeID> mapping = new HashMap<>();
+			for (int i = 0; i < overridden.typeParameters.length; i++)
+				mapping.put(overridden.typeParameters[i], new GenericTypeID(typeParameters[i]));
+			mapper = new GenericMapper(registry, mapping);
+		}
+		
+		ITypeID resultReturnType = this.returnType;
+		if (resultReturnType == BasicTypeID.UNDETERMINED)
+			resultReturnType = overridden.returnType.instance(mapper);
+		
+		ITypeID resultThrownType = this.thrownType;
+		if (resultThrownType == null && overridden.thrownType != null)
+			resultThrownType = overridden.thrownType.instance(mapper);
+		
+		FunctionParameter[] resultParameters = Arrays.copyOf(parameters, parameters.length);
+		for (int i = 0; i < resultParameters.length; i++) {
+			if (resultParameters[i].type == BasicTypeID.UNDETERMINED) {
+				FunctionParameter parameter = resultParameters[i];
+				FunctionParameter original = overridden.parameters[i];
+				resultParameters[i] = new FunctionParameter(original.type.instance(mapper), parameter.name, parameter.defaultValue, original.variadic);
+			}
+		}
+		
+		return new FunctionHeader(resultTypeParameters, resultReturnType, resultThrownType, resultParameters);
+	}
+	
 	public boolean matchesExactly(CallArguments arguments, TypeScope scope) {
 		if (arguments.arguments.length < minParameters || arguments.arguments.length > maxParameters)
 			return false;
 		return true;
 	}
 	
+	public boolean canOverride(TypeScope scope, FunctionHeader other) {
+		if (parameters.length != other.parameters.length)
+			return false;
+		if (returnType != BasicTypeID.UNDETERMINED && !scope.getTypeMembers(returnType).canCastImplicit(other.returnType))
+			return false;
+		
+		for (int i = 0; i < parameters.length; i++) {
+			if (parameters[i].type == BasicTypeID.UNDETERMINED)
+				continue;
+			
+			if (parameters[i].variadic != other.parameters[i].variadic)
+				return false;
+			if (!scope.getTypeMembers(other.parameters[i].type).canCastImplicit(parameters[i].type))
+				return false;
+		}
+		
+		return true;
+	}
+	
 	/**
 	 * Checks if two function headers are equivalent. Functions headers are
 	 * equivalent if their types are the same.
 		
 		return parameters[parameters.length - 1].variadic ? Integer.MAX_VALUE : parameters.length;
 	}
+	
+	private static boolean hasUnknowns(ITypeID[] types) {
+		for (ITypeID type : types)
+			if (type == BasicTypeID.UNDETERMINED)
+				return true;
+		
+		return false;
+	}
+	
+	private static boolean hasUnknowns(FunctionParameter[] parameters) {
+		for (FunctionParameter parameter : parameters)
+			if (parameter.type == BasicTypeID.UNDETERMINED)
+				return true;
+		
+		return false;
+	}
 }

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

 	public static boolean isExtern(int modifiers) {
 		return (modifiers & EXTERN) > 0;
 	}
+	
+	public static boolean isOverride(int modifiers) {
+		return (modifiers & OVERRIDE) > 0;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/AnnotationProcessor.java

 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.member.ref.DefinitionMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.scope.DefinitionScope;
 import org.openzen.zenscript.codemodel.scope.FileScope;
 import org.openzen.zenscript.codemodel.scope.FunctionScope;
 		@Override
 		public Void visitStaticInitializer(StaticInitializerMember member) {
 			StatementScope scope = new FunctionScope(this.scope, new FunctionHeader(BasicTypeID.VOID));
-			member.body = process(member.body, scope);
+			if (member.body == null) {
+				throw new IllegalStateException("No body in static initializer @ " + member.position);
+			} else {
+				member.body = process(member.body, scope);
+			}
 			return null;
 		}
 		
 			for (MemberAnnotation annotation : member.annotations)
 				annotation.apply(member, scope);
 			
-			if (member.overrides != null) {
-				functional(member, member.overrides);
+			if (member.getOverrides() != null) {
+				functional(member, member.getOverrides());
 			}
 			
 			if (member.body == null)
 			return null;
 		}
 		
-		private void functional(FunctionalMember member, FunctionalMember overrides) {
-			for (MemberAnnotation annotation : overrides.annotations)
+		private void functional(FunctionalMember member, DefinitionMemberRef overrides) {
+			for (MemberAnnotation annotation : overrides.getAnnotations())
 				annotation.applyOnOverridingMethod(member, scope);
 			
-			if (overrides.overrides != null) {
-				functional(member, overrides.overrides);
+			if (overrides.getOverrides() != null) {
+				functional(member, overrides.getOverrides());
 			}
 		}
 	}

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

  * @author Hoofdgebruiker
  */
 public class CallArguments {
-	public static final ITypeID[] NO_TYPE_ARGUMENTS = new ITypeID[0];
 	public static final CallArguments EMPTY = new CallArguments(new Expression[0]);
 	
 	public final ITypeID[] typeArguments;
 	public final Expression[] arguments;
 	
 	public CallArguments(Expression... arguments) {
-		this.typeArguments = NO_TYPE_ARGUMENTS;
+		this.typeArguments = ITypeID.NONE;
 		this.arguments = arguments;
 	}
 	
 	public CallArguments(ITypeID[] typeArguments, Expression[] arguments) {
 		if (typeArguments == null)
-			typeArguments = NO_TYPE_ARGUMENTS;
+			typeArguments = ITypeID.NONE;
 		if (arguments == null)
 			throw new IllegalArgumentException("Arguments cannot be null!");
 		
 		this.arguments = arguments;
 	}
 	
+	public CallArguments(ITypeID... dummy) {
+		this.typeArguments = ITypeID.NONE;
+		this.arguments = new Expression[dummy.length];
+		for (int i = 0; i < dummy.length; i++)
+			arguments[i] = new DummyExpression(dummy[i]);
+	}
+	
 	public int getNumberOfTypeArguments() {
 		return typeArguments.length;
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/DummyExpression.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.type.ITypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DummyExpression extends Expression {
+	public DummyExpression(ITypeID type) {
+		super(CodePosition.BUILTIN, type, null);
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		throw new UnsupportedOperationException("This is a dummy expression");
+	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		throw new UnsupportedOperationException("This is a dummy expression");
+	}
+}

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

 		return scope.getTypeMembers(type).castImplicit(position, this, asType, true);
 	}
 	
+	/**
+	 * Determines if this expression aborts execution; that is, it is either a
+	 * throw or a panic expression.
+	 * 
+	 * @return abort flag
+	 */
+	public boolean aborts() {
+		return false;
+	}
+	
 	@Override
 	public List<ITypeID>[] predictCallTypes(TypeScope scope, List<ITypeID> hints, int arguments) {
 		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).predictCallTypes(scope, hints, arguments);

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

 		
 		this.value = value;
 	}
+	
+	@Override
+	public boolean aborts() {
+		return true;
+	}
 
 	@Override
 	public <T> T accept(ExpressionVisitor<T> visitor) {

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

 		
 		this.value = value;
 	}
+	
+	@Override
+	public boolean aborts() {
+		return true;
+	}
 
 	@Override
 	public <T> T accept(ExpressionVisitor<T> visitor) {

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
  * @author Hoofdgebruiker
  */
 public class CallerMember extends FunctionalMember {
+	public FunctionalMemberRef overrides;
+	
 	public CallerMember(
 			CodePosition position,
 			HighLevelDefinition definition,
 			FunctionHeader header,
 			BuiltinID builtin)
 	{
-		super(position, definition, modifiers, "()", header, builtin);
+		super(position, definition, modifiers, header, builtin);
 	}
 	
 	@Override
 	public <T> T accept(MemberVisitor<T> visitor) {
 		return visitor.visitCaller(this);
 	}
+	
+	public void setOverrides(GlobalTypeRegistry registry, FunctionalMemberRef overrides) {
+		this.overrides = overrides;
+		header = header.inferFromOverride(registry, overrides.getHeader());
+	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return overrides;
+	}
 }

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.member.ref.CasterMemberRef;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
  */
 public class CasterMember extends FunctionalMember {
 	public final ITypeID toType;
+	public CasterMemberRef overrides;
 	
 	public CasterMember(
 			CodePosition position,
 			ITypeID toType,
 			BuiltinID builtin)
 	{
-		super(position, definition, modifiers, "as", new FunctionHeader(toType), builtin);
+		super(position, definition, modifiers, new FunctionHeader(toType), builtin);
 		
 		this.toType = toType;
 	}
 	public <T> T accept(MemberVisitor<T> visitor) {
 		return visitor.visitCaster(this);
 	}
+	
+	public void setOverrides(GlobalTypeRegistry registry, CasterMemberRef overrides) {
+		this.overrides = overrides;
+	}
+
+	@Override
+	public CasterMemberRef getOverrides() {
+		return overrides;
+	}
 }

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
  */
 public class ConstMember extends DefinitionMember {
 	public final String name;
-	public final ITypeID type;
+	public ITypeID type;
 	public Expression value;
 	public final BuiltinID builtin;
 	
 	public <T> T accept(MemberVisitor<T> visitor) {
 		return visitor.visitConst(this);
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return null;
+	}
 }

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
 import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.statement.BlockStatement;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 				position,
 				definition,
 				modifiers,
-				"this",
 				new FunctionHeader(header.typeParameters, BasicTypeID.VOID, header.thrownType, header.parameters),
 				builtin);
 	}
 	public <T> T accept(MemberVisitor<T> visitor) {
 		return visitor.visitConstructor(this);
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return null;
+	}
 }

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 public class CustomIteratorMember extends DefinitionMember implements IIteratorMember {
 	private final ITypeID[] iteratorTypes;
 	public Statement body;
+	public IteratorMemberRef overrides;
 	
 	public CustomIteratorMember(CodePosition position, HighLevelDefinition definition, int modifiers, ITypeID[] iteratorTypes) {
 		super(position, definition, modifiers);
 	public <T> T acceptForIterator(ForeachIteratorVisitor<T> visitor) {
 		return visitor.visitCustomIterator();
 	}
+	
+	public void setOverrides(IteratorMemberRef overrides) {
+		this.overrides = overrides;
+	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return overrides;
+	}
 }

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

 public abstract class DefinitionMember extends Taggable implements IDefinitionMember {
 	public final CodePosition position;
 	public final HighLevelDefinition definition;
-	public final int modifiers;
+	public int modifiers;
 	public MemberAnnotation[] annotations = MemberAnnotation.NONE;
 	
 	public DefinitionMember(CodePosition position, HighLevelDefinition definition, int modifiers) {
 	public boolean isExtern() {
 		return Modifiers.isExtern(modifiers);
 	}
+	
+	public boolean isPrivate() {
+		return Modifiers.isPrivate(modifiers);
+	}
+	
+	public boolean isPublic() {
+		return Modifiers.isPublic(modifiers);
+	}
+	
+	public boolean isProtected() {
+		return Modifiers.isProtected(modifiers);
+	}
 }

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
  */
 public class DestructorMember extends FunctionalMember {
 	private static final FunctionHeader HEADER = new FunctionHeader(BasicTypeID.VOID);
+	public FunctionalMemberRef overrides;
 	
 	public DestructorMember(CodePosition position, HighLevelDefinition definition, int modifiers) {
-		super(position, definition, modifiers, "~this", HEADER, null);
+		super(position, definition, modifiers, HEADER, null);
 	}
 	
 	@Override
 	public <T> T accept(MemberVisitor<T> visitor) {
 		return visitor.visitDestructor(this);
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return overrides;
+	}
 }

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

 import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
 import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 import org.openzen.zenscript.codemodel.statement.ReturnStatement;
  */
 public class FieldMember extends DefinitionMember {
 	public final String name;
-	public final ITypeID type;
+	public ITypeID type;
 	public Expression initializer;
 	public final int autoGetterAccess;
 	public final int autoSetterAccess;
 	public <T> T accept(MemberVisitor<T> visitor) {
 		return visitor.visitField(this);
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return null;
+	}
 }

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

  * @author Hoofdgebruiker
  */
 public abstract class FunctionalMember extends DefinitionMember {
-	public final FunctionHeader header;
-	public final String name;
+	public FunctionHeader header;
 	public final BuiltinID builtin;
 	public Statement body = null;
-	public FunctionalMember overrides = null;
 	
 	public FunctionalMember(
 			CodePosition position,
 			HighLevelDefinition definition,
 			int modifiers,
-			String name,
 			FunctionHeader header,
 			BuiltinID builtin) {
 		super(position, definition, modifiers);
 		
-		this.name = name;
 		this.header = header;
 		this.builtin = builtin;
 	}

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
  */
 public class GetterMember extends FunctionalMember {
 	public final String name;
-	public final ITypeID type;
+	public ITypeID type;
+	private GetterMemberRef overrides;
 	
 	public GetterMember(
 			CodePosition position,
 			String name,
 			ITypeID type,
 			BuiltinID builtin) {
-		super(position, definition, modifiers, name, new FunctionHeader(type), builtin);
+		super(position, definition, modifiers, new FunctionHeader(type), builtin);
 		
 		this.name = name;
 		this.type = type;
 	public <T> T accept(MemberVisitor<T> visitor) {
 		return visitor.visitGetter(this);
 	}
+
+	@Override
+	public GetterMemberRef getOverrides() {
+		return overrides;
+	}
+	
+	public void setOverrides(GetterMemberRef override) {
+		this.overrides = override;
+		
+		if (type == BasicTypeID.UNDETERMINED)
+			type = override.type;
+	}
 }

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

 package org.openzen.zenscript.codemodel.member;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 	public <T> void setTag(Class<T> tag, T value);
 
 	<T> boolean hasTag(Class<T> tag);
+	
+	DefinitionMemberRef getOverrides();
 }

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.ImplementationMemberRef;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	public <T> T accept(MemberVisitor<T> visitor) {
 		return visitor.visitImplementation(this);
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return null;
+	}
 }

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 	public <T> T accept(MemberVisitor<T> visitor) {
 		return visitor.visitInnerDefinition(this);
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return null;
+	}
 }

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
  * @author Hoofdgebruiker
  */
 public class MethodMember extends FunctionalMember {
+	public final String name;
+	private FunctionalMemberRef overrides;
+	
 	public MethodMember(CodePosition position, HighLevelDefinition definition, int modifiers, String name, FunctionHeader header, BuiltinID builtin) {
-		super(position, definition, modifiers, name, header, builtin);
+		super(position, definition, modifiers, header, builtin);
+		
+		this.name = name;
 	}
 	
 	@Override
 	public <T> T accept(MemberVisitor<T> visitor) {
 		return visitor.visitMethod(this);
 	}
+
+	@Override
+	public FunctionalMemberRef getOverrides() {
+		return overrides;
+	}
+	
+	public void setOverrides(GlobalTypeRegistry registry, FunctionalMemberRef overrides) {
+		this.overrides = overrides;
+		header = header.inferFromOverride(registry, overrides.header);
+		
+		if (overrides.getTarget().isPublic())
+			modifiers |= Modifiers.PUBLIC;
+		if (overrides.getTarget().isProtected())
+			modifiers |= Modifiers.PROTECTED;
+	}
 }

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
  */
 public class OperatorMember extends FunctionalMember {
 	public final OperatorType operator;
+	private FunctionalMemberRef overrides;
 	
 	public OperatorMember(
 			CodePosition position,
 			FunctionHeader header,
 			BuiltinID builtin)
 	{
-		super(position, definition, modifiers, operator.operator, header, builtin);
+		super(position, definition, modifiers, header, builtin);
 		
 		this.operator = operator;
 	}
 	public <T> T accept(MemberVisitor<T> visitor) {
 		return visitor.visitOperator(this);
 	}
+
+	@Override
+	public FunctionalMemberRef getOverrides() {
+		return overrides;
+	}
+	
+	public void setOverrides(GlobalTypeRegistry registry, FunctionalMemberRef overrides) {
+		this.overrides = overrides;
+		header = header.inferFromOverride(registry, overrides.header);
+	}
 }

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

  * @author Hoofdgebruiker
  */
 public class SetterMember extends FunctionalMember {
-	public final ITypeID type;
+	public ITypeID type;
+	public final String name;
+	private SetterMemberRef overrides;
 	
 	public SetterMember(
 			CodePosition position,
 		super(position,
 				definition,
 				modifiers,
-				name,
 				new FunctionHeader(BasicTypeID.VOID, new FunctionParameter(type, "$")),
 				builtin);
 		
 		this.type = type;
+		this.name = name;
 	}
 	
 	@Override
 	public <T> T accept(MemberVisitor<T> visitor) {
 		return visitor.visitSetter(this);
 	}
+
+	@Override
+	public SetterMemberRef getOverrides() {
+		return overrides;
+	}
+	
+	public void setOverrides(SetterMemberRef overrides) {
+		this.overrides = overrides;
+		
+		if (type == BasicTypeID.UNDETERMINED)
+			type = overrides.type;
+	}
 }

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

 import org.openzen.zencode.shared.Taggable;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 	public <T> T accept(MemberVisitor<T> visitor) {
 		return visitor.visitStaticInitializer(this);
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return null;
+	}
 }

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

 import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
 import org.openzen.zenscript.codemodel.member.IIteratorMember;
 import org.openzen.zenscript.codemodel.member.MemberVisitor;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 	public <T> T acceptForIterator(ForeachIteratorVisitor<T> visitor) {
 		return visitor.visitArrayKeyValueIterator();
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return null;
+	}
 }

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

 import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
 import org.openzen.zenscript.codemodel.member.IIteratorMember;
 import org.openzen.zenscript.codemodel.member.MemberVisitor;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	public <T> T acceptForIterator(ForeachIteratorVisitor<T> visitor) {
 		return visitor.visitArrayValueIterator();
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return null;
+	}
 }

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

 import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
 import org.openzen.zenscript.codemodel.member.IIteratorMember;
 import org.openzen.zenscript.codemodel.member.MemberVisitor;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	public <T> T acceptForIterator(ForeachIteratorVisitor<T> visitor) {
 		return visitor.visitAssocKeyValueIterator();
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return null;
+	}
 }

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

 import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
 import org.openzen.zenscript.codemodel.member.IIteratorMember;
 import org.openzen.zenscript.codemodel.member.MemberVisitor;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	public <T> T acceptForIterator(ForeachIteratorVisitor<T> visitor) {
 		return visitor.visitIntRange();
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return null;
+	}
 }

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

 import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
 import org.openzen.zenscript.codemodel.member.IIteratorMember;
 import org.openzen.zenscript.codemodel.member.MemberVisitor;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	public <T> T accept(MemberVisitor<T> visitor) {
 		throw new UnsupportedOperationException("Not a compilable member");
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return null;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/CasterMemberRef.java

 package org.openzen.zenscript.codemodel.member.ref;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.expression.CastExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.CasterMember;
 	public boolean isImplicit() {
 		return Modifiers.isImplicit(member.modifiers);
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return member.getOverrides();
+	}
+
+	@Override
+	public FunctionHeader getHeader() {
+		return member.header;
+	}
+
+	@Override
+	public MemberAnnotation[] getAnnotations() {
+		return member.annotations;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/ConstMemberRef.java

 package org.openzen.zenscript.codemodel.member.ref;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.ConstMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 	public <T> T getTag(Class<T> type) {
 		return member.getTag(type);
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return null;
+	}
+
+	@Override
+	public FunctionHeader getHeader() {
+		return null;
+	}
+
+	@Override
+	public MemberAnnotation[] getAnnotations() {
+		return member.annotations;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/DefinitionMemberRef.java

 package org.openzen.zenscript.codemodel.member.ref;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 
 /**
  *
 	String describe();
 	
 	<T> T getTag(Class<T> type);
+	
+	DefinitionMemberRef getOverrides();
+	
+	FunctionHeader getHeader();
+	
+	MemberAnnotation[] getAnnotations();
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/FieldMemberRef.java

 package org.openzen.zenscript.codemodel.member.ref;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 	public boolean isFinal() {
 		return member.isFinal();
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return null;
+	}
+
+	@Override
+	public FunctionHeader getHeader() {
+		return null;
+	}
+
+	@Override
+	public MemberAnnotation[] getAnnotations() {
+		return member.annotations;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/FunctionalMemberRef.java

 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.CallExpression;
 import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
 		return target.position;
 	}
 	
+	public FunctionalMember getTarget() {
+		return target;
+	}
+	
 	public String getCanonicalName() {
 		return target.getCanonicalName();
 	}
 		return target.describe();
 	}
 	
+	@Override
 	public <T> T getTag(Class<T> cls) {
 		return target.getTag(cls);
 	}
 	
+	@Override
+	public MemberAnnotation[] getAnnotations() {
+		return target.annotations;
+	}
+	
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return target.getOverrides();
+	}
+
+	@Override
+	public FunctionHeader getHeader() {
+		return header;
+	}
+	
 	public BuiltinID getBuiltin() {
 		return target.builtin;
 	}
 	}
 	
 	public String getMethodName() {
-		//FIXME
-		return (target).name;
+		return ((MethodMember) target).name;
 	}
 	
 	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/GetterMemberRef.java

 package org.openzen.zenscript.codemodel.member.ref;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
 	public Expression getStatic(CodePosition position) {
 		return new StaticGetterExpression(position, this);
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return member.getOverrides();
+	}
+
+	@Override
+	public FunctionHeader getHeader() {
+		return member.header;
+	}
+
+	@Override
+	public MemberAnnotation[] getAnnotations() {
+		return member.annotations;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/ImplementationMemberRef.java

 package org.openzen.zenscript.codemodel.member.ref;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 	public <T> T getTag(Class<T> type) {
 		return member.getTag(type);
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return null;
+	}
+
+	@Override
+	public FunctionHeader getHeader() {
+		return null;
+	}
+
+	@Override
+	public MemberAnnotation[] getAnnotations() {
+		return member.annotations;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/IteratorMemberRef.java

 package org.openzen.zenscript.codemodel.member.ref;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
+import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
 import org.openzen.zenscript.codemodel.member.IIteratorMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 	public int getLoopVariableCount() {
 		return types.length;
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return target.getOverrides();
+	}
+
+	@Override
+	public FunctionHeader getHeader() {
+		return null; // TODO
+	}
+
+	@Override
+	public MemberAnnotation[] getAnnotations() {
+		if (target instanceof CustomIteratorMember) {
+			return ((CustomIteratorMember)target).annotations;
+		} else {
+			return null;
+		}
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/SetterMemberRef.java

 package org.openzen.zenscript.codemodel.member.ref;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 	public boolean isStatic() {
 		return member.isStatic();
 	}
+
+	@Override
+	public DefinitionMemberRef getOverrides() {
+		return member.getOverrides();
+	}
+
+	@Override
+	public FunctionHeader getHeader() {
+		return member.header;
+	}
+
+	@Override
+	public MemberAnnotation[] getAnnotations() {
+		return member.annotations;
+	}
 }

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

  * @author Hoofdgebruiker
  */
 public abstract class BaseScope implements TypeScope {
-	public abstract LocalMemberCache getMemberCache();
-	
 	public abstract IPartialExpression get(CodePosition position, GenericName name);
 	
 	public abstract ITypeID getType(CodePosition position, List<GenericName> name);

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

  * @author Hoofdgebruiker
  */
 public interface TypeScope {
-	public GlobalTypeRegistry getTypeRegistry();
-	
 	public LocalMemberCache getMemberCache();
 	
-	public TypeMembers getTypeMembers(ITypeID type);
+	default TypeMembers getTypeMembers(ITypeID type) {
+		return getMemberCache().get(type);
+	}
+	
+	default GlobalTypeRegistry getTypeRegistry() {
+		return getMemberCache().getRegistry();
+	}
 	
 	public AnnotationDefinition getAnnotation(String name);
 }

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

 public enum BasicTypeID implements ITypeID {
 	VOID("void"),
 	NULL("null"),
-	ANY("any"),
 	BOOL("bool"),
 	BYTE("byte"),
 	SBYTE("sbyte"),
 	
 	@Override
 	public boolean isObjectType() {
-		return this == ANY || this == STRING;
+		return this == STRING;
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.ConstExpression;
 import org.openzen.zenscript.codemodel.expression.PostCallExpression;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 		return this.setter == null ? null : this.setter.member;
 	}
 	
+	public FunctionalMemberRef getUnaryMethod() {
+		for (TypeMember<FunctionalMemberRef> method : methods)
+			if (method.member.header.parameters.length == 0)
+				return method.member;
+		
+		return null;
+	}
+	
 	public boolean hasMethods() {
 		return !methods.isEmpty();
 	}
 		
 		return selected;
 	}
+	
+	public FunctionalMemberRef getOverride(CodePosition position, TypeScope scope, FunctionalMember member) {
+		List<FunctionalMemberRef> candidates = new ArrayList<>();
+		for (TypeMember<FunctionalMemberRef> method : methods) {
+			if (member.header.canOverride(scope, method.member.header))
+				candidates.add(method.member);
+		}
+		
+		if (candidates.isEmpty())
+			return null;
+		if (candidates.size() == 1)
+			return candidates.get(0);
+		
+		throw new CompileException(position, CompileExceptionCode.OVERRIDE_AMBIGUOUS, "Ambiguous override: has " + candidates.size() + " base candidates");
+	}
 }

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

 import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.member.InnerDefinition;
+import org.openzen.zenscript.codemodel.member.MethodMember;
+import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.codemodel.member.ref.CasterMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 	
 	public Expression unary(CodePosition position, TypeScope scope, OperatorType operator, Expression value) {
 		DefinitionMemberGroup members = getOrCreateGroup(operator);
-		return members.call(position, scope, value, new CallArguments(), false);
+		return members.call(position, scope, value, new CallArguments(Expression.NONE), false);
 	}
 	
 	public Expression ternary(CodePosition position, TypeScope scope, OperatorType operator, Expression a, Expression b, Expression c) {
 			return true;
 		if (toType == null)
 			throw new NullPointerException();
-		if (type == BasicTypeID.ANY || toType == BasicTypeID.ANY || toType == BasicTypeID.UNDETERMINED)
-			return true;
 		
 		if (type == BasicTypeID.NULL && toType.isOptional())
 			return true;
 		if (type.isOptional() && type.unwrap() == toType)
 			return true;
 		
+		return getImplicitCaster(toType) != null || extendsOrImplements(toType);
+	}
+	
+	public CasterMemberRef getImplicitCaster(ITypeID toType) {
 		for (TypeMember<CasterMemberRef> caster : casters) {
 			if (caster.member.isImplicit() && toType == caster.member.toType)
-				return true;
+				return caster.member;
+		}
+		
+		return null;
+	}
+	
+	public CasterMemberRef getCaster(ITypeID toType) {
+		for (TypeMember<CasterMemberRef> caster : casters) {
+			if (toType == caster.member.toType)
+				return caster.member;
 		}
 		
-		return extendsOrImplements(toType);
+		return null;
 	}
 	
 	public boolean canCast(ITypeID toType) {

CompilerShared/src/main/java/org/openzen/zenscript/compiler/SemanticModule.java

 		if (state != State.NORMALIZED)
 			throw new IllegalStateException("Module is not yet normalized");
 		
-		Validator validator = new Validator();
+		Validator validator = new Validator(compilationUnit.globalTypeRegistry, expansions, annotations);
 		for (ScriptBlock script : scripts) {
 			validator.validate(script);
 		}

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

 			}
 		}
 		
+		if (failed)
+			return new SemanticModule(name, dependencies, SemanticModule.State.INVALID, rootPackage, pkg, definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations());
+		
 		if (failed)
 			return new SemanticModule(name, dependencies, SemanticModule.State.INVALID, rootPackage, pkg, definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations());
 		

Constructor/src/main/java/org/openzen/zenscript/constructor/module/DirectoryModuleReference.java

 import org.json.JSONArray;
 import org.json.JSONObject;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.FileSourceFile;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.compiler.CompilationUnit;
 import org.openzen.zenscript.constructor.ConstructorException;
 			if (file.isDirectory()) {
 				pkg.addPackage(loadPackage(file.getName(), file));
 			} else if (file.isFile() && file.getName().toLowerCase().endsWith(".zs")) {
-				pkg.addFile(new SourceFile(file.getName(), file));
+				pkg.addFile(new FileSourceFile(file.getName(), file));
 			}
 		}
 		

Constructor/src/main/java/org/openzen/zenscript/constructor/module/SourceFile.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;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class SourceFile {
-	public final String name;
-	public final File file;
-	
-	public SourceFile(String name, File file) {
-		this.name = name;
-		this.file = file;
-	}
-}

Constructor/src/main/java/org/openzen/zenscript/constructor/module/SourcePackage.java

 import java.io.File;
 import java.util.HashMap;
 import java.util.Map;
+import org.openzen.zencode.shared.FileSourceFile;
+import org.openzen.zencode.shared.SourceFile;
 
 /**
  *
 	}
 	
 	public void addFile(SourceFile file) {
-		sourceFiles.put(file.name, file);
+		sourceFiles.put(file.getFilename(), file);
 	}
 }

DrawableGui/src/main/java/org/openzen/drawablegui/swing/SwingRoot.java

 			component.setBounds(new DIRectangle(0, 0, getWidth(), getHeight()));
 		}
 		
-		long start = System.currentTimeMillis();
+		//long start = System.currentTimeMillis();
 		Rectangle clipBounds = g.getClipBounds();
 		DIRectangle clipBounds2 = clipBounds == null ? null : new DIRectangle(clipBounds.x, clipBounds.y, clipBounds.width, clipBounds.height);
 		Graphics2D g2d = (Graphics2D) g;
 		g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB);
 		surface.paint(g2d, clipBounds2);
 		
-		System.out.println("Paint in " + (System.currentTimeMillis() - start) + " ms, bounds: " + clipBounds.toString());
+		//System.out.println("Paint in " + (System.currentTimeMillis() - start) + " ms, bounds: " + clipBounds.toString());
 	}
 
 	@Override

IDE/src/main/java/org/openzen/zenscript/ide/codemodel/IDECodeError.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.ide.codemodel;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.ide.host.IDESourceFile;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class IDECodeError {
+	public final IDESourceFile file;
+	public final CodePosition position;
+	public final String message;
+	
+	public IDECodeError(IDESourceFile file, CodePosition position, String message) {
+		this.file = file;
+		this.position = position;
+		this.message = message;
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/codemodel/IDECodeSpace.java

  */
 package org.openzen.zenscript.ide.codemodel;
 
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+import org.openzen.zenscript.compiler.CompilationUnit;
+import org.openzen.zenscript.compiler.SemanticModule;
+import org.openzen.zenscript.compiler.ZenCodeCompiler;
+import org.openzen.zenscript.constructor.Library;
+import org.openzen.zenscript.constructor.ModuleLoader;
+import org.openzen.zenscript.constructor.module.DirectoryModuleReference;
+import org.openzen.zenscript.constructor.module.ModuleReference;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
+import org.openzen.zenscript.ide.host.IDEModule;
 import org.openzen.zenscript.ide.host.IDESourceFile;
+import org.openzen.zenscript.ide.ui.view.output.ErrorOutputSpan;
+import org.openzen.zenscript.ide.ui.view.output.OutputLine;
+import org.openzen.zenscript.validator.ValidationLogEntry;
+import stdlib.Strings;
 
 /**
  *
  */
 public class IDECodeSpace {
 	private final DevelopmentHost host;
+	private final Map<IDESourceFile, List<IDECodeError>> sourceFileErrors = new HashMap<>();
 	
 	public IDECodeSpace(DevelopmentHost host) {
 		this.host = host;
+		
+		ModuleLoader loader = new ModuleLoader(new CompilationUnit(), exception -> {
+			
+		});
+		for (IDEModule module : host.getModules()) {
+			module.prebuild(loader, this::addError);
+		}
 	}
 	
 	public void onSaved(IDESourceFile file) {
 		
 	}
+	
+	public List<IDECodeError> getErrors(IDESourceFile file) {
+		return sourceFileErrors.getOrDefault(file, Collections.emptyList());
+	}
+	
+	private void addError(IDECodeError error) {
+		if (error.file == null)
+			return;
+		if (!sourceFileErrors.containsKey(error.file))
+			sourceFileErrors.put(error.file, new ArrayList<>());
+		sourceFileErrors.get(error.file).add(error);
+	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/host/IDEModule.java

  */
 package org.openzen.zenscript.ide.host;
 
+import java.util.function.Consumer;
+import org.openzen.zenscript.constructor.ModuleLoader;
+import org.openzen.zenscript.ide.codemodel.IDECodeError;
+
 /**
  *
  * @author Hoofdgebruiker
 	public String getName();
 	
 	public IDEPackage getRootPackage();
+	
+	void prebuild(ModuleLoader loader, Consumer<IDECodeError> errors);
 }

IDE/src/main/java/org/openzen/zenscript/ide/host/IDESourceFile.java

  */
 package org.openzen.zenscript.ide.host;
 
-import java.io.IOException;
-import java.io.Reader;
 import org.openzen.drawablegui.live.LiveString;
+import org.openzen.zencode.shared.SourceFile;
 
 /**
  *
 public interface IDESourceFile {
 	public LiveString getName();
 	
-	public Reader read() throws IOException;
+	public SourceFile getFile();
 	
 	public void update(String content);
 }

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalModule.java

  */
 package org.openzen.zenscript.ide.host.local;
 
+import java.util.function.Consumer;
+import org.openzen.zenscript.compiler.SemanticModule;
+import org.openzen.zenscript.constructor.ModuleLoader;
 import org.openzen.zenscript.constructor.module.ModuleReference;
+import org.openzen.zenscript.ide.codemodel.IDECodeError;
 import org.openzen.zenscript.ide.host.IDEModule;
 import org.openzen.zenscript.ide.host.IDEPackage;
 
 	public IDEPackage getRootPackage() {
 		return rootPackage;
 	}
+	
+	@Override
+	public void prebuild(ModuleLoader loader, Consumer<IDECodeError> errors) {
+		SemanticModule module = loader.getModule(this.module.getName());
+		module.validate(entry -> errors.accept(new IDECodeError(null, entry.position, entry.message)));
+	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalPackage.java

 import org.openzen.drawablegui.live.LiveList;
 import org.openzen.drawablegui.live.MutableLiveList;
 import org.openzen.drawablegui.live.SortedLiveList;
-import org.openzen.zenscript.constructor.module.SourceFile;
+import org.openzen.zencode.shared.FileSourceFile;
+import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.constructor.module.SourcePackage;
 import org.openzen.zenscript.ide.host.IDEPackage;
 import org.openzen.zenscript.ide.host.IDESourceFile;
 			ex.printStackTrace(); // TODO
 		}
 		
-		SourceFile sourceFile = new SourceFile(name, file);
+		FileSourceFile sourceFile = new FileSourceFile(name, file);
 		IDESourceFile localSourceFile = new LocalSourceFile(sourceFile);
 		this.pkg.sourceFiles.put(name, sourceFile);
 		sourceFiles.add(localSourceFile);

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalSourceFile.java

  */
 package org.openzen.zenscript.ide.host.local;
 
-import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
-import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
-import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
-import java.io.Reader;
 import java.io.Writer;
 import java.nio.charset.StandardCharsets;
 import org.openzen.drawablegui.live.LiveString;
 import org.openzen.drawablegui.live.MutableLiveString;
 import org.openzen.drawablegui.live.SimpleLiveString;
-import org.openzen.zenscript.constructor.module.SourceFile;
+import org.openzen.zencode.shared.FileSourceFile;
+import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.ide.host.IDESourceFile;
 
 /**
 	
 	public LocalSourceFile(SourceFile file) {
 		this.file = file;
-		this.name = new SimpleLiveString(file.name);
+		this.name = new SimpleLiveString(file.getFilename());
 	}
 
 	@Override
 	}
 
 	@Override
-	public Reader read() throws IOException {
-		return new InputStreamReader(
-				new BufferedInputStream(new FileInputStream(file.file)),
-				StandardCharsets.UTF_8);
+	public SourceFile getFile() {
+		return file;
 	}
 
 	@Override
 	public void update(String content) {
 		try {
-			Writer writer = new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(file.file)), StandardCharsets.UTF_8);
-			writer.write(content);
-			writer.close();
+			if (file instanceof FileSourceFile) {
+				Writer writer = new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(((FileSourceFile)file).file)), StandardCharsets.UTF_8);
+				writer.write(content);
+				writer.close();
+			} else {
+				throw new UnsupportedOperationException("Cannot write to a non-file source file!");
+			}
 		} catch (IOException ex) {
 			ex.printStackTrace();
 		}

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalTarget.java

 				continue;
 			
 			SemanticModule dependencyModule = loader.getModule(dependency);
-			module = module.normalize();
-			module.validate(logger);
-			if (!module.isValid())
+			dependencyModule = dependencyModule.normalize();
+			dependencyModule.validate(logger);
+			if (!dependencyModule.isValid())
 				return false;
 			
 			if (!compileDependencies(loader, compiler, compiledModules, dependencyModule, logger))
 				return false;
 			
-			module.compile(compiler);
-			compiledModules.add(module.name);
+			dependencyModule.compile(compiler);
+			compiledModules.add(dependencyModule.name);
 		}
 		
 		return true;

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/editor/PathGenerator.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.ide.ui.view.editor;
+
+import org.openzen.drawablegui.DPath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class PathGenerator {
+	private PathGenerator() {}
+	
+	public static class CubicBezierCurve {
+		public final float p1x;
+		public final float p1y;
+		public final float p2x;
+		public final float p2y;
+		public final float p3x;
+		public final float p3y;
+		public final float p4x;
+		public final float p4y;
+		
+		public CubicBezierCurve(float p1x, float p1y, float p2x, float p2y, float p3x, float p3y, float p4x, float p4y) {
+			this.p1x = p1x;
+			this.p1y = p1y;
+			this.p2x = p2x;
+			this.p2y = p2y;
+			this.p3x = p3x;
+			this.p3y = p3y;
+			this.p4x = p4x;
+			this.p4y = p4y;
+		}
+		
+		public void cut(float t0, float t1) {
+			// https://stackoverflow.com/questions/11703283/cubic-bezier-curve-segment
+			// P'1 = u0u0u0 P1 + (t0u0u0 + u0t0u0 + u0u0t0) P2 + (t0t0u0 + u0t0t0 + t0u0t0) P3 + t0t0t0 P4
+			// P'2 = u0u0u1 P1 + (t0u0u1 + u0t0u1 + u0u0t1) P2 + (t0t0u1 + u0t0t1 + t0u0t1) P3 + t0t0t1 P4
+			// P'3 = u0u1u1 P1 + (t0u1u1 + u0t1u1 + u0u1t1) P2 + (t0t1u1 + u0t1t1 + t0u1t1) P3 + t0t1t1 P4
+			// P'4 = u1u1u1 P1 + (t1u1u1 + u1t1u1 + u1u1t1) P2 + (t1t1u1 + u1t1t1 + t1u1t1) P3 + t1t1t1 P4
+			// u0 = 1 − t0 and u1 = 1 − t1
+			
+		}
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/editor/SourceEditor.java

 package org.openzen.zenscript.ide.ui.view.editor;
 
 import java.io.IOException;
+import java.io.Reader;
 import java.util.ArrayList;
 import java.util.List;
 import org.openzen.drawablegui.DComponent;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.Destructible;
 import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnRectangle;
 import org.openzen.drawablegui.draw.DDrawnShape;
 	private final List<DDrawnText> lineNumbers = new ArrayList<>();
 	private final List<List<DDrawnText>> drawnTokens = new ArrayList<>();
 	
+	//private DDrawnShape test;
+	
 	public SourceEditor(DStyleClass styleClass, IDEWindow window, IDESourceFile sourceFile) {
 		this.styleClass = styleClass;
 		this.window = window;
 		this.sourceFile = sourceFile;
 		
-		tokens = new TokenModel(sourceFile.getName().getValue(), tab.length());
+		tokens = new TokenModel(sourceFile.getFile(), tab.length());
 		tokenListener = tokens.addListener(new TokenListener());
 		
 		editToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, ShadedSaveIcon.PURPLE, SaveIcon.GREY, unchanged, new ImmutableLiveString("Save file"), e -> save()));
 		updated = new InverseLiveBool(unchanged);
 		
 		try {
+			Reader reader = sourceFile.getFile().open();
 			TokenParser<ZSToken, ZSTokenType> parser = ZSTokenParser.createRaw(
-					sourceFile.getName().getValue(),
-					new ReaderCharReader(sourceFile.read()),
+					sourceFile.getFile(),
+					new ReaderCharReader(reader),
 					tab.length());
 			tokens.set(parser);
+			reader.close();
 		} catch (IOException ex) {
 			ex.printStackTrace();
 		}
 			cursor = null;
 		}
 		
+		/*if (test != null) {
+			test.close();
+			test = null;
+		}*/
+		
 		if (blinkTimer != null)
 			blinkTimer.close();
 		
 					bounds.y + style.selectionPaddingTop + i * fullLineHeight + fontMetrics.getAscent());
 		}
 		
+		//test = surface.strokePath(z + 4, new WavyLine(bounds.x + 50, bounds.y + 50, 100, surface.getContext().dp(2), surface.getContext().dp(3)), DTransform2D.IDENTITY, IDEStyling.ERROR_RED, surface.getScale());
+		
 		layoutLines(0);
 	}
 	
 		}
 	}
 	
+	private void setCursor(SourcePosition position) {
+		setCursor(position, position);
+	}
+	
 	private void setCursor(SourcePosition start, SourcePosition end) {
 		cursorStart = start;
 		cursorEnd = end;
 		if (value.equals("{")) {
 			String indent = tokens.getLine(cursorEnd.line).getIndent();
 			tokens.insert(cursorEnd, "{\n" + indent + "\t\n" + indent + "}");
-			
-			SourcePosition position = new SourcePosition(tokens, cursorEnd.line + 1, indent.length() + 1);
-			setCursor(position, position);
-		} else if (value.equals(";")) {
-			String indent = tokens.getLine(cursorEnd.line).getIndent();
-			tokens.insert(cursorEnd, ";\n" + indent);
-			
-			SourcePosition position = new SourcePosition(tokens, cursorEnd.line + 1, indent.length());
-			setCursor(position, position);
+			setCursor(new SourcePosition(tokens, cursorEnd.line + 1, indent.length() + 1));
+		} else if (value.equals("\"")) {
+			if (!tokens.extract(cursorEnd, cursorEnd.advance(1)).equals("\""))
+				tokens.insert(cursorEnd, "\"\"");
+			setCursor(cursorEnd.advance(1));
+		} else if (value.equals("(")) {
+			tokens.insert(cursorEnd, "()");
+			setCursor(cursorEnd.advance(1));
+		} else if (value.equals(")") && tokens.extract(cursorEnd, cursorEnd.advance(1)).equals(")")){
+			setCursor(cursorEnd.advance(1));
+		} else if (value.equals("[")) {
+			tokens.insert(cursorEnd, "[]");
+			setCursor(cursorEnd.advance(1));
+		} else if (value.equals("]") && tokens.extract(cursorEnd, cursorEnd.advance(1)).equals("]")) {
+			setCursor(cursorEnd.advance(1));
 		} else {
 			tokens.insert(cursorEnd, value);
-			
-			SourcePosition position = new SourcePosition(tokens, cursorEnd.line, cursorEnd.offset + value.length());
-			setCursor(position, position);
+			setCursor(cursorEnd.advance(value.length()));
 		}
 		
 		unchanged.setValue(false);
 		@Override
 		public void onLineChanged(int index) {
 			if (bounds != null) {
-				removeLineTokens(drawnTokens.get(index));
-				drawnTokens.get(index).clear();
-				drawnTokens.get(index).addAll(lineToTokens(tokens.getLine(index)));
+				Destructible.close(drawnTokens.get(index));
+				drawnTokens.set(index, lineToTokens(tokens.getLine(index)));
 				layoutLine(index);
 			}
 		}
 		public void onLineDeleted(int index) {
 			onLinesUpdated();
 			
+			if (index >= lineNumbers.size())
+				return;
+			
 			if (bounds != null) {
 				lineNumbers.remove(lineNumbers.size() - 1).close();
-				removeLineTokens(drawnTokens.remove(index));
+				Destructible.close(drawnTokens.remove(index));
 				layoutLines(index);
 			}
 		}
-		
-		private void removeLineTokens(List<DDrawnText> tokens) {
-			for (DDrawnText token : tokens)
-				token.close();
-		}
 	}
 	
 	private enum TokenClass {

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/editor/SourcePosition.java

 	private TokenModel.Position position;
 
 	public SourcePosition(TokenModel tokens, int line, int offset) {
+		if (line < 0)
+			throw new IllegalArgumentException("line cannot be negative");
+		if (offset < 0)
+			throw new IllegalArgumentException("offset cannot be negative");
+		
 		this.tokens = tokens;
 		this.line = line;
 		this.offset = offset;

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/editor/TokenLine.java

 		}
 		return indent.toString();
 	}
+	
+	/**
+	 * Adds a temporary token. This token must be relexed later using the relexer.
+	 * 
+	 * @param token 
+	 */
+	public void addTemporary(ZSToken token) {
+		tokens.add(token);
+		length += token.content.length();
+	}
 
 	public void add(ZSToken token) {
 		insert(tokens.size(), token);

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/editor/TokenModel.java

 import java.util.Set;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.listeners.ListenerList;
+import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.lexer.ZSToken;
 import org.openzen.zenscript.lexer.ZSTokenType;
 
 public class TokenModel {
 	private final ListenerList<Listener> listeners = new ListenerList<>();
 	
-	private final String filename;
+	private final SourceFile file;
 	private final int spacesPerTab;
 	private final List<TokenLine> lines = new ArrayList<>();
 	private long version = 0;
 	
-	public TokenModel(String filename, int spacesPerTab) {
-		this.filename = filename;
+	public TokenModel(SourceFile file, int spacesPerTab) {
+		this.file = file;
 		this.spacesPerTab = spacesPerTab;
 	}
 	
 		if (!remainder.isEmpty())
 			getLine(fromT.line).insert(fromT.token, new ZSToken(ZSTokenType.INVALID, remainder));
 		
-		relex(fromT.line, Math.max(0, fromT.token - 1), fromT.line, fromT.token + 1);
+		relex(fromT.line, Math.max(0, fromT.token - 1), fromT.line, Math.min(lines.get(fromT.line).getTokenCount(), fromT.token + 1));
 	}
 	
 	public void insert(SourcePosition position, String value) {
 		Position tokenPosition = position.asTokenPosition();
 		ZSToken token = getTokenAt(tokenPosition);
 		if (token == null) {
-			line.add(new ZSToken(ZSTokenType.INVALID, value));
+			line.addTemporary(new ZSToken(ZSTokenType.INVALID, value));
 		} else {
 			token = token.insert(tokenPosition.offset, value);
 			line.replace(tokenPosition.token, token);
 	}
 	
 	private void relex(int fromLine, int fromToken, int toLine, int toToken) {
-		TokenRelexer reparser = new TokenRelexer(filename, lines, fromLine, fromToken, toLine, toToken, spacesPerTab);
+		TokenRelexer reparser = new TokenRelexer(file, lines, fromLine, fromToken, toLine, toToken, spacesPerTab);
 		List<ZSToken> tokens = reparser.relex();
 		replaceTokens(fromLine, fromToken, reparser.getLine(), reparser.getToken(), tokens);
 	}
 		TokenLine currentLine = lines.get(line);
 		Set<Integer> insertedLines = new HashSet<>();
 		Set<Integer> modifiedLines = new HashSet<>();
+		modifiedLines.add(line);
 		while (tokens.hasNext()) {
 			ZSToken token = tokens.next();
 			if (token.type.multiline && token.content.indexOf('\n') >= 0) {
 		public final int offset;
 		
 		public Position(int line, int token, int offset) {
+			if (line < 0)
+				throw new IllegalArgumentException("line cannot be negative");
+			if (token < 0)
+				throw new IllegalArgumentException("token cannot be negative");
+			if (offset < 0)
+				throw new IllegalArgumentException("offset cannot be negative");
+			
 			this.line = line;
 			this.token = token;
 			this.offset = offset;

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/editor/TokenRelexer.java

 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.lexer.CharReader;
 import org.openzen.zenscript.lexer.TokenParser;
 import org.openzen.zenscript.lexer.ZSToken;
  */
 public class TokenRelexer {
 	private final List<TokenLine> lines;
-	private final String filename;
+	private final SourceFile file;
 	private final int toLine;
 	private final int toToken;
 	private final int spacesPerTab;
 	private int lineIndex;
 	private int token;
 	
-	public TokenRelexer(String filename, List<TokenLine> lines, int fromLine, int fromToken, int toLine, int toToken, int spacesPerTab) {
+	public TokenRelexer(SourceFile file, List<TokenLine> lines, int fromLine, int fromToken, int toLine, int toToken, int spacesPerTab) {
 		if (fromToken < 0 || toToken < 0)
 			throw new IllegalArgumentException("fromToken or toToken cannot be < 0");
 		
 		this.lines = lines;
-		this.filename = filename;
+		this.file = file;
 		this.toLine = toLine;
 		this.toToken = toToken;
 		
 	
 	public List<ZSToken> relex() {
 		RelexCharReader reader = new RelexCharReader();
-		TokenParser<ZSToken, ZSTokenType> reparser = ZSTokenParser.createRaw(filename, reader, spacesPerTab);
+		TokenParser<ZSToken, ZSTokenType> reparser = ZSTokenParser.createRaw(file, reader, spacesPerTab);
 		List<ZSToken> result = new ArrayList<>();
 		while ((lineIndex < toLine || token < toToken || !reader.isAtTokenBoundary()) && reparser.hasNext())
 			result.add(reparser.next());

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/editor/WavyLine.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.ide.ui.view.editor;
+
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DPathTracer;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class WavyLine implements DPath {
+	private final int x;
+	private final int y;
+	private final int width;
+	private final int height;
+	private final float stride;
+	
+	public WavyLine(int x, int y, int width, int height, float stride) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		this.stride = stride;
+	}
+	
+	@Override
+	public void trace(DPathTracer tracer) {
+		tracer.moveTo(x, y);
+		for (int i = 0; i < (width / stride); i++) {
+			if ((i % 2) == 0) {
+				tracer.bezierCubic(
+						x + (i + 0.5f) * stride, y,
+						x + (i + 0.5f) * stride, y + height,
+						x + (i + 1) * stride, y + height);
+			} else {
+				tracer.bezierCubic(
+						x + (i + 0.5f) * stride, y + height,
+						x + (i + 0.5f) * stride, y,
+						x + (i + 1) * stride, y);
+			}
+		}
+	}
+}

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

 	@Override
 	public void addScriptBlock(ScriptBlock script) {
 		final SourceFile sourceFile = script.getTag(SourceFile.class);
-		final String className = getClassName(sourceFile == null ? null : sourceFile.filename);
+		final String className = getClassName(sourceFile == null ? null : sourceFile.getFilename());
 		JavaScriptFile scriptFile = getScriptFile(className);
 		
 		String methodName = scriptFile.scriptMethods.isEmpty() ? "run" : "run" + scriptFile.scriptMethods.size();

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

 package org.openzen.zenscript.javabytecode.compiler;
 
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.StringJoiner;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Label;
 import org.objectweb.asm.Opcodes;
 							javaWriter.invokeStatic(ARRAYS_COPY_OF_RANGE_OBJECTS);
 							javaWriter.checkCast("[Ljava/lang/String;");
 							break;
-						case ANY:
-							javaWriter.invokeStatic(ARRAYS_COPY_OF_RANGE_OBJECTS);
-							javaWriter.checkCast("[Lzsynthetic/Any;");
-							break;
 						default:
 							throw new IllegalArgumentException("Unknown basic type: " + type.elementType);
 					}
 							javaWriter.invokeStatic(ARRAYS_EQUALS_CHARS);
 							break;
 						case STRING:
-						case ANY:
 							javaWriter.invokeStatic(ARRAYS_EQUALS_OBJECTS);
 							break;
 						default:
 							javaWriter.invokeStatic(ARRAYS_HASHCODE_CHARS);
 							break;
 						case STRING:
-						case ANY:
 							javaWriter.invokeStatic(ARRAYS_DEEPHASHCODE);
 							break;
 						default:

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

 				return void.class;
 			case NULL:
 				return Object.class;
-			case ANY:
-				return Object.class; // TODO
 			case BOOL:
 				return Boolean.class;
 			case BYTE:

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

 
         Type type = statement.type.accept(JavaTypeVisitor.INSTANCE);
         int local = javaWriter.local(type);
-        if(statement.initializer != null)
+        if (statement.initializer != null)
             javaWriter.store(type, local);
         final Label variableStart = new Label();
         javaWriter.label(variableStart);

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

         switch (basic) {
             case VOID:
                 return void.class;
-            case ANY:
             case NULL:
             case UNDETERMINED:
                 return Object.class;

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

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-
+import org.objectweb.asm.*;
 import static org.objectweb.asm.Opcodes.*;
+import org.objectweb.asm.commons.LocalVariablesSorter;
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.javabytecode.JavaClassInfo;
+import org.openzen.zenscript.javabytecode.JavaFieldInfo;
+import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
+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");

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

 		this.currentElementType = type;
 	}
 	
+	protected void override(boolean override) {
+		if (override) {
+			output.append(indent).append("@Override\n");
+		}
+	}
+	
 	protected void modifiers(int modifiers) {
 		if (Modifiers.isPublic(modifiers))
 			output.append("public ");
 			output.append("protected ");
 		if (Modifiers.isPrivate(modifiers))
 			output.append("private ");
+		if (Modifiers.isAbstract(modifiers))
+			output.append("abstract ");
 		if (Modifiers.isStatic(modifiers))
 			output.append("static ");
 		if (Modifiers.isFinal(modifiers))

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

 			if (parameter.variadic)
 				result.append("...");
 			
-			if (!settings.showAnyInFunctionHeaders || parameter.type != BasicTypeID.ANY) {
+			if (!settings.showAnyInFunctionHeaders || parameter.type != BasicTypeID.UNDETERMINED) {
 				result.append(" as ");
 				result.append(header.returnType.accept(typeFormatter));
 			}
 			parameterIndex++;
 		}
 		result.append(")");
-		if (!settings.showAnyInFunctionHeaders || header.returnType != BasicTypeID.ANY) {
+		if (!settings.showAnyInFunctionHeaders || header.returnType != BasicTypeID.UNDETERMINED) {
 			result.append(" as ");
 			result.append(header.returnType.accept(typeFormatter));
 		}

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

 		}
 		
 		if (mergedImplementations.size() > 0) {
-			output.append("implements ");
+			output.append(" implements ");
 			for (int i = 0; i < mergedImplementations.size(); i++) {
 				if (i > 0)
 					output.append(", ");
 			output.append("static ");
 		if (Modifiers.isAbstract(modifiers))
 			output.append("abstract ");
-		if (!Modifiers.isVirtual(modifiers))
+		if (!Modifiers.isVirtual(modifiers) && !Modifiers.isAbstract(modifiers))
 			output.append("final ");
 	}
 	

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

 import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.member.InnerDefinitionMember;
 import org.openzen.zenscript.codemodel.member.MethodMember;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
+import org.openzen.zenscript.javasource.tags.JavaSourceImplementation;
 import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 
 /**
 			
 		
 		begin(ElementType.METHOD);
+		override(member.getOverrides() != null);
 		output.append(indent);
 		if (isInterface && hasBody)
 			output.append("default ");
 
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
-		// TODO
+		JavaSourceImplementation implementation = member.getTag(JavaSourceImplementation.class);
+		if (implementation.inline) {
+			for (IDefinitionMember m : member.members) {
+				m.accept(this);
+			}
+		} else {
+			String interfaceName = member.type.accept(new JavaSourceTypeNameVisitor());
+			String implementationName = interfaceName + "Implementation";
+			
+			begin(ElementType.FIELD);
+			output.append(indent);
+			modifiers(member.modifiers);
+			output.append("final ").append(scope.type(member.type)).append(" as").append(interfaceName).append(" = new ").append(implementationName).append("();\n");
+			
+			begin(ElementType.INNERCLASS);
+			output.append("private class ").append(implementationName).append(" implements ").append(scope.type(member.type)).append(" {\n");
+			JavaMemberCompiler memberCompiler = new JavaMemberCompiler(settings, indent + settings.indent, output, scope, isInterface, definition);
+			for (IDefinitionMember m : member.members) {
+				m.accept(memberCompiler);
+			}
+			output.append(indent).append("}\n");
+		}
 		return null;
 	}
 

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

 	private String getFilename(HighLevelDefinition definition) {
 		SourceFile source = definition.getTag(SourceFile.class);
 		if (source != null) {
-			int slash = Math.max(source.filename.lastIndexOf('/'), source.filename.lastIndexOf('\\'));
-			String filename = source.filename.substring(slash < 0 ? 0 : slash + 1);
+			int slash = Math.max(source.getFilename().lastIndexOf('/'), source.getFilename().lastIndexOf('\\'));
+			String filename = source.getFilename().substring(slash < 0 ? 0 : slash + 1);
 			filename = filename.substring(0, filename.lastIndexOf('.'));
 			return filename;
 		} else {

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

 	public String visitBasic(BasicTypeID basic) {
 		switch (basic) {
 			case VOID: return "Void";
-			case ANY: return "Any";
 			case BOOL: return "Boolean";
 			case BYTE: return "Byte";
 			case SBYTE: return "Byte";

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

 	public void formatReturn(StatementFormattingTarget target, ReturnStatement statement) {
 		if (statement.value == null)
 			target.writeLine("return;");
+		else if (statement.value.aborts()) // throw or panic
+			target.writeLine(scope.expression(target, statement.value).value + ";");
 		else
 			target.writeLine("return " + scope.expression(target, statement.value).value + ";");
 	}

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

 	@Override
 	public String visitBasic(BasicTypeID basic) {
 		switch (basic) {
-			case ANY: return "Any";
 			case VOID: return "Void";
 			case BOOL: return "Bool";
 			case BYTE: return "Byte";

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

 import org.openzen.zenscript.codemodel.type.OptionalTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.javasource.tags.JavaSourceClass;
-import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 
 /**
  *
 	public String visitBasic(BasicTypeID basic) {
 		switch (basic) {
 			case VOID: return "void";
-			case ANY: return "Any";
 			case BOOL: return "boolean";
 			case BYTE: return "byte";
 			case SBYTE: return "byte";

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareClassMethodVisitor.java

 import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.member.InnerDefinitionMember;
 import org.openzen.zenscript.codemodel.member.MemberVisitor;
 import org.openzen.zenscript.javasource.JavaSourceTypeNameVisitor;
 import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 import org.openzen.zenscript.javasource.tags.JavaSourceField;
+import org.openzen.zenscript.javasource.tags.JavaSourceImplementation;
 import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 
 /**
 
 	@Override
 	public Void visitConstructor(ConstructorMember member) {
-		visitFunctional(member, member.name);
+		visitFunctional(member, "<init>");
 		return null;
 	}
 
 
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
-		// TODO: implementation merge check
 		cls.empty = false;
+		if (canMergeImplementation(member)) {
+			member.setTag(JavaSourceImplementation.class, new JavaSourceImplementation(true, cls));
+			for (IDefinitionMember m : member.members)
+				m.accept(this);
+		} else {
+			JavaSourceClass implementationClass = new JavaSourceClass(cls.pkg + "." + cls.name, member.type.accept(new JavaSourceTypeNameVisitor()) + "Implementation");
+			member.setTag(JavaSourceImplementation.class, new JavaSourceImplementation(false, implementationClass));
+			
+			JavaSourcePrepareClassMethodVisitor visitor = new JavaSourcePrepareClassMethodVisitor(implementationClass, null, true);
+			for (IDefinitionMember m : member.members)
+				m.accept(visitor);
+		}
 		return null;
 	}
+	
+	private boolean canMergeImplementation(ImplementationMember member) {
+		return true; // TODO: implementation merge check
+	}
 
 	@Override
 	public Void visitInnerDefinition(InnerDefinitionMember member) {

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareDefinitionVisitor.java

 import org.openzen.zenscript.codemodel.expression.CastExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
-import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.formattershared.ExpressionString;
 import org.openzen.zenscript.javasource.JavaOperator;
 import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 			cls.addConstructor("constructorWithCause", "");
 			nativeClasses.put("stdlib::Exception", cls);
 		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.io", "IOException"));
+			cls.addConstructor("constructor", "");
+			nativeClasses.put("io::IOException", cls);
+		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.io", "Reader"));
+			cls.addInstanceMethod("destruct", "close");
+			cls.addInstanceMethod("readCharacter", "read");
+			cls.addInstanceMethod("readArray", "read");
+			cls.addInstanceMethod("readArraySlice", "read");
+			nativeClasses.put("io::Reader", cls);
+		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.io", "StringReader"));
+			cls.addInstanceMethod("constructor", "");
+			cls.addInstanceMethod("destructor", "close");
+			cls.addInstanceMethod("readCharacter", "read");
+			cls.addInstanceMethod("readSlice", "read");
+			nativeClasses.put("io::StringReader", cls);
+		}
 	}
 	
 	private final String filename;

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareExpansionMethodVisitor.java

 import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.member.InnerDefinitionMember;
 import org.openzen.zenscript.codemodel.member.MemberVisitor;
 import org.openzen.zenscript.javasource.JavaSourceTypeNameVisitor;
 import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 import org.openzen.zenscript.javasource.tags.JavaSourceField;
+import org.openzen.zenscript.javasource.tags.JavaSourceImplementation;
 import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 
 /**
 	public Void visitField(FieldMember member) {
 		// TODO: expansion fields
 		member.setTag(JavaSourceField.class, new JavaSourceField(cls, member.name));
-		cls.empty = false;
+		if (member.hasAutoGetter() || member.hasAutoSetter())
+			cls.empty = false;
 		return null;
 	}
 
 
 	@Override
 	public Void visitDestructor(DestructorMember member) {
-		throw new UnsupportedOperationException("Destructors not allowed on expansions");
+		visitFunctional(member, "");
+		return null;
 	}
 
 	@Override
 
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
-		// TODO: implementation merge check
-		cls.empty = false;
+		JavaSourceClass implementationClass = new JavaSourceClass(cls.pkg + "." + cls.name, member.type.accept(new JavaSourceTypeNameVisitor()) + "Implementation");
+		member.setTag(JavaSourceImplementation.class, new JavaSourceImplementation(false, implementationClass));
+		for (IDefinitionMember implementedMember : member.members)
+			implementedMember.accept(this);
+		
 		return null;
 	}
 

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourceSignatureVisitor.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.javasource.prepare;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSourceSignatureVisitor {
+	
+}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/tags/JavaSourceImplementation.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.javasource.tags;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSourceImplementation {
+	public final boolean inline;
+	public final JavaSourceClass implementationClass;
+	
+	public JavaSourceImplementation(boolean inline, JavaSourceClass implementationClass) {
+		this.inline = inline;
+		this.implementationClass = implementationClass;
+	}
+}

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

 
 import java.io.IOException;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.SourceFile;
 
 /*
  * To change this license header, choose License Headers in Project Properties.
  */
 public class CountingCharReader implements CharReader {
 	private final CharReader reader;
-	private final String filename;
+	private final SourceFile file;
 	private final int tabSize;
 	
 	private int line;
 	private int lineOffset;
-
-	public CountingCharReader(CharReader reader, String filename, int tabSize)
+	
+	public CountingCharReader(CharReader reader, SourceFile file, int tabSize)
 	{
 		this.reader = reader;
-		this.filename = filename;
+		this.file = file;
 		this.tabSize = tabSize;
 		
 		line = 1;
 	}
 	
 	public CodePosition getPosition() {
-		return new CodePosition(filename, line, lineOffset, line, lineOffset);
+		return new CodePosition(file, line, lineOffset, line, lineOffset);
 	}
 
 	@Override

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zencode.shared.SourceFile;
 
 /**
  * Represents a token stream. A token stream reads characters from a reader and
     /**
      * Creates a token stream using the specified reader and DFA.
      *
-	 * @param filename filename
+	 * @param file filename
      * @param reader reader to read characters from
      * @param dfa DFA to tokenize the stream
 	 * @param eof end of file token type
      */
     public TokenParser(
-			String filename,
+			SourceFile file,
 			CharReader reader, 
 			CompiledDFA<TT> dfa,
 			TT eof,
 		if (eof.isWhitespace()) // important for the advance() method
 			throw new IllegalArgumentException("EOF cannot be whitespace");
 		
-        this.reader = new CountingCharReader(reader, filename, 4);
+        this.reader = new CountingCharReader(reader, file, 4);
         this.dfa = dfa;
 		this.eof = eof;
 		this.invalid = invalid;
     /**
      * Creates a token stream which reads data from the specified string.
      *
-	 * @param filename filename
+	 * @param file filename
      * @param data data to read
      * @param dfa DFA to tokenize the stream
 	 * @param eof end of file token type
      */
-    public TokenParser(String filename, String data, CompiledDFA<TT> dfa, TT eof, TT invalid, TokenFactory<T, TT> factory)
+    public TokenParser(SourceFile file, String data, CompiledDFA<TT> dfa, TT eof, TT invalid, TokenFactory<T, TT> factory)
 	{
-        this(filename, new StringCharReader(data), dfa, eof, invalid, factory);
+        this(file, new StringCharReader(data), dfa, eof, invalid, factory);
     }
 	
 	@Override
 				if (reader.peek() < 0 && value.length() == 0)
 					return factory.create(eof, ""); // happens on comments at the end of files
 				
-				//value.append((char) reader.next());
+				if (value.length() == 0)
+					value.append((char) reader.next());
 				return factory.create(invalid, value.toString());
             }
         } catch (IOException ex) {

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

 
 import java.io.IOException;
 import java.io.Reader;
+import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.WhitespaceInfo;
 
 /**
 public class ZSTokenParser extends LLParserTokenStream<ZSTokenType, ZSToken> {
 	private static final CompiledDFA DFA = CompiledDFA.createLexerDFA(ZSTokenType.values(), ZSTokenType.class);
 	
-	public static TokenParser<ZSToken, ZSTokenType> createRaw(String filename, CharReader reader, int spacesPerTab) {
+	public static TokenParser<ZSToken, ZSTokenType> createRaw(SourceFile file, CharReader reader, int spacesPerTab) {
 		return new TokenParser<>(
-				filename,
+				file,
 				reader,
 				DFA,
 				ZSTokenType.EOF,
 				new ZSTokenFactory(spacesPerTab));
 	}
 	
-	public static ZSTokenParser create(String filename, Reader reader, int spacesPerTab) throws IOException {
-		return new ZSTokenParser(createRaw(filename, new ReaderCharReader(reader), spacesPerTab));
+	public static ZSTokenParser create(SourceFile file, int spacesPerTab) throws IOException {
+		return new ZSTokenParser(createRaw(file, new ReaderCharReader(file.open()), spacesPerTab));
 	}
 	
 	public ZSTokenParser(TokenStream<ZSTokenType, ZSToken> parser) {
 		super(parser);
 	}
 	
-	public String getFilename() {
-		return getPosition().filename;
+	public SourceFile getFile() {
+		return getPosition().file;
 	}
 	
 	public WhitespaceInfo collectWhitespaceInfo(String whitespace, boolean skipLineBefore) {

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

 	
 	public abstract void compileMembers(BaseScope scope);
 	
-	public abstract void compileCode(BaseScope scope);
+	public abstract void listMembers(BaseScope scope, PrecompilationState state);
+	
+	public abstract void compileCode(BaseScope scope, PrecompilationState state);
 }

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

 package org.openzen.zenscript.parser;
 
 import java.io.File;
-import java.io.FileReader;
 import java.io.IOException;
-import java.io.Reader;
-import java.io.StringReader;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zencode.shared.FileSourceFile;
+import org.openzen.zencode.shared.LiteralSourceFile;
 import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
  */
 public class ParsedFile {
 	public static ParsedFile parse(ZSPackage pkg, File file) throws IOException {
-		String filename = file.toString();
-		try (FileReader reader = new FileReader(file)) {
-			return parse(pkg, filename, reader);
-		}
+		return parse(pkg, new FileSourceFile(file.getName(), file));
 	}
 	
 	public static ParsedFile parse(ZSPackage pkg, String filename, String content) {
-		try (StringReader reader = new StringReader(content)) {
-			return parse(pkg, filename, reader);
+		try {
+			return parse(pkg, new LiteralSourceFile(filename, content));
 		} catch (IOException ex) {
-			throw new AssertionError(); // supposed to never happen in a StringReader
+			throw new AssertionError(); // shouldn't happen
 		}
 	}
 	
-	public static ParsedFile parse(ZSPackage pkg, String filename, Reader reader) throws IOException {
-		ZSTokenParser tokens = ZSTokenParser.create(filename, reader, 4);
+	public static ParsedFile parse(ZSPackage pkg, SourceFile file) throws IOException {
+		ZSTokenParser tokens = ZSTokenParser.create(file, 4);
 		return parse(pkg, tokens);
 	}
 	
 	public static ParsedFile parse(ZSPackage pkg, ZSTokenParser tokens) {
-		ParsedFile result = new ParsedFile(tokens.getFilename());
+		ParsedFile result = new ParsedFile(tokens.getFile());
 		ZSToken eof = null;
 
 		while (true) {
 		return result;
 	}
 	
-	public final String filename;
+	public final SourceFile file;
 	
 	private final List<ParsedImport> imports = new ArrayList<>();
 	private final List<ParsedDefinition> definitions = new ArrayList<>();
 	private final List<ParsedStatement> statements = new ArrayList<>();
 	private WhitespacePostComment postComment = null;
 	
-	public ParsedFile(String filename) {
-		this.filename = filename;
+	public ParsedFile(SourceFile file) {
+		this.file = file;
 	}
 	
 	public boolean hasErrors() {
 	
 	public void listDefinitions(PackageDefinitions definitions) {
 		for (ParsedDefinition definition : this.definitions) {
-			definition.getCompiled().setTag(SourceFile.class, new SourceFile(filename));
+			definition.getCompiled().setTag(SourceFile.class, file);
 			definitions.add(definition.getCompiled());
 			definition.linkInnerTypes();
 		}
 			List<AnnotationDefinition> annotations) {
 		FileScope scope = new FileScope(rootPackage, packageDefinitions, globalRegistry, expansions, globalSymbols, annotations);
 		loadImports(scope, rootPackage, modulePackage);
+		
+		PrecompilationState state = new PrecompilationState();
+		for (ParsedDefinition definition : this.definitions) {
+			definition.listMembers(scope, state);
+		}
+		
 		for (ParsedDefinition definition : this.definitions) {
-			definition.compileCode(scope);
+			definition.compileCode(scope, state);
 		}
 		
 		if (!statements.isEmpty() || postComment != null) {
 			}
 			
 			ScriptBlock block = new ScriptBlock(statements);
-			block.setTag(SourceFile.class, new SourceFile(filename));
+			block.setTag(SourceFile.class, file);
 			block.setTag(WhitespacePostComment.class, postComment);
 			scripts.add(block);
 		}

Parser/src/main/java/org/openzen/zenscript/parser/PrecompilationState.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;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class PrecompilationState {
+	private final Map<IDefinitionMember, CompilableMember> members = new HashMap<>();
+	private final Set<ParsedDefinitionMember> compilingMembers = new HashSet<>();
+	
+	public PrecompilationState() {
+		
+	}
+	
+	public void register(BaseScope definitionScope, ParsedDefinitionMember member) {
+		members.put(member.getCompiled(), new CompilableMember(member, definitionScope));
+	}
+	
+	public boolean precompile(IDefinitionMember member) {
+		if (!members.containsKey(member))
+			return true;
+		
+		CompilableMember cMember = members.get(member);
+		if (compilingMembers.contains(cMember.member))
+			return false;
+		
+		compilingMembers.add(cMember.member);
+		if (!cMember.member.inferHeaders(cMember.definitionScope, this))
+			return false;
+		
+		compilingMembers.remove(cMember.member);
+		return true;
+	}
+	
+	public void end(ParsedDefinitionMember member) {
+		compilingMembers.remove(member);
+	}
+	
+	private class CompilableMember {
+		private final ParsedDefinitionMember member;
+		private final BaseScope definitionScope;
+		
+		public CompilableMember(ParsedDefinitionMember member, BaseScope definitionScope) {
+			this.member = member;
+			this.definitionScope = definitionScope;
+		}
+	}
+}

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

 import org.openzen.zenscript.codemodel.scope.DefinitionScope;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.ParsedDefinition;
+import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
 
 /**
 			getCompiled().addMember(member.getCompiled());
 		}
 	}
+	
+	@Override
+	public void listMembers(BaseScope scope, PrecompilationState state) {
+		DefinitionScope innerScope = new DefinitionScope(scope, getCompiled());
+		for (ParsedDefinitionMember member : members)
+			state.register(innerScope, member);
+	}
 
 	@Override
-	public void compileCode(BaseScope scope) {
+	public void compileCode(BaseScope scope, PrecompilationState state) {
 		DefinitionScope innerScope = new DefinitionScope(scope, getCompiled());
 		for (ParsedDefinitionMember member : members)
-			member.compile(innerScope);
+			member.compile(innerScope, state);
 	}
 }

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

 import org.openzen.zenscript.codemodel.scope.DefinitionScope;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.ParsedDefinition;
+import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.type.IParsedType;
 
 /**
 		
 		compiled.setType(type.compile(innerScope));
 	}
+	
+	@Override
+	public void listMembers(BaseScope scope, PrecompilationState state) {
+		// nothing to do
+	}
 
 	@Override
-	public void compileCode(BaseScope scope) {
+	public void compileCode(BaseScope scope, PrecompilationState state) {
 		// nothing to do
 	}
 

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

 		
 		ParsedClass result = new ParsedClass(pkg, position, modifiers, annotations, name, genericParameters, superclass, outerDefinition);
 		while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
-			result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled));
+			result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled, null));
 		}
 		return result;
 	}

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

 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.parser.ParsedAnnotation;
+import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
 
 /**
 		
 		if (tokens.optional(ZSTokenType.T_SEMICOLON) != null) {
 			while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
-				result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled));
+				result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled, null));
 			}
 		} else {
 			tokens.required(ZSTokenType.T_ACLOSE, "} expected");
 	}
 
 	@Override
-	public void compileCode(BaseScope scope) {
-		super.compileCode(scope);
+	public void compileCode(BaseScope scope, PrecompilationState state) {
+		super.compileCode(scope, state);
 		
 		DefinitionTypeID type = new DefinitionTypeID(compiled, new ITypeID[0]);
 		ExpressionScope evalScope = new ExpressionScope(scope);

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

 		
 		ParsedExpansion result = new ParsedExpansion(pkg, position, modifiers, annotations, parameters, target, outerDefinition);
 		while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
-			result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled));
+			result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled, null));
 		}
 		return result;
 	}

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

 package org.openzen.zenscript.parser.definitions;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
 import static org.openzen.zenscript.lexer.ZSTokenType.*;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.scope.FunctionScope;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.ParsedDefinition;
+import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.statements.ParsedFunctionBody;
 import org.openzen.zenscript.parser.statements.ParsedStatement;
 
 	public void compileMembers(BaseScope scope) {
 		compiled.setHeader(header.compile(scope));
 	}
+	
+	@Override
+	public void listMembers(BaseScope scope, PrecompilationState state) {
+		
+	}
 
 	@Override
-	public void compileCode(BaseScope scope) {
+	public void compileCode(BaseScope scope, PrecompilationState state) {
 		FunctionScope innerScope = new FunctionScope(scope, compiled.header);
 		compiled.setCode(body.compile(innerScope, compiled.header));
+		
+		if (compiled.header.returnType == BasicTypeID.UNDETERMINED) {
+			ITypeID result = body.precompileForResultType(new FunctionScope(scope, compiled.header), state);
+			if (result == null)
+				throw new CompileException(position, CompileExceptionCode.PRECOMPILE_FAILED, "Could not determine return type for method " + compiled.name);
+			compiled.header = compiled.header.withReturnType(result);
+		}
 	}
 }

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

 				ZSToken argName = tokens.required(T_IDENTIFIER, "identifier expected");
 				boolean variadic = tokens.optional(T_DOT3) != null;
 				
-				IParsedType type = ParsedTypeBasic.ANY;
+				IParsedType type = ParsedTypeBasic.UNDETERMINED;
 				if (tokens.optional(K_AS) != null) {
 					type = IParsedType.parse(tokens);
 				}
 			tokens.required(T_BRCLOSE, ") expected");
 		}
 
-		IParsedType returnType = ParsedTypeBasic.ANY;
+		IParsedType returnType = ParsedTypeBasic.UNDETERMINED;
 		if (tokens.optional(K_AS) != null) {
 			returnType = IParsedType.parse(tokens);
 		}