- Added support for implementations and method overriding

- Added override method header inference: if a method overrides or implements another method, and types are missing from the header, these will be inherited from the base method. This works with any kind of method (method, operator, getter, setter, caller)
- Added method return type inference, which is automatically inferred from the return value of the contents of the method. This functionality is not yet fully implemented, and will fail with certain expressions (most notably, member expressions and calls). The goal is to make this system work as long as there is no recursion. This works with methods, operators, getters, calls as well as fields and constants with initializers.
- Removed the any type. With return type inference its usefulness has become even more limited, and proper implementation of the any type is expected to be complicated, thus not worth the effort. (this may be revisited later on, as "any" remains a reserved keyword)
- Fixed compilation of throw as panic expressions in lambda function bodies
- Moved name from FunctionalMember to MethodMember, where it makes more sense
- Each method (or functional) is now also aware of the member that it overrides

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/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 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;
 	}

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());
 		

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

 							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/JavaTypeClassVisitor.java

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

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 ");

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/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/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

 	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/JavaSourcePrepareExpansionMethodVisitor.java

 
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
-		// TODO: implementation merge check
-		//cls.empty = false; -> TODO: 
-		member.setTag(JavaSourceImplementation.class, new JavaSourceImplementation(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);
 		

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

  * @author Hoofdgebruiker
  */
 public class JavaSourceImplementation {
-	public boolean inline = true;
+	public final boolean inline;
+	public final JavaSourceClass implementationClass;
 	
-	public JavaSourceImplementation() {}
-	
-	public JavaSourceImplementation(boolean inline) {
+	public JavaSourceImplementation(boolean inline, JavaSourceClass implementationClass) {
 		this.inline = inline;
+		this.implementationClass = implementationClass;
 	}
 }

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

 				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/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.util.ArrayList;
 import java.util.List;
 			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) {

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

 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.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)
+			compiled.header = compiled.header.withReturnType(body.precompileForResultType(new FunctionScope(scope, compiled.header), state));
 	}
 }

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);
 		}

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

 		
 		ParsedInterface result = new ParsedInterface(pkg, position, modifiers, annotations, name, genericParameters, superInterfaces, 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/ParsedStruct.java

 		
 		ParsedStruct result = new ParsedStruct(pkg, position, modifiers, annotations, name, parameters, 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/ParsedVariant.java

 		
 		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");

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

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	public boolean hasStrongType() {
 		return true;
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		Function<CodePosition, Expression> dollar = scope.getDollar();
+		if (dollar == null)
+			return null;
+		
+		return dollar.apply(position).type;
+	}
 }

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

 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.parser.ParseException;
+import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionParameter;
 import org.openzen.zenscript.parser.statements.ParsedFunctionBody;
 	}
 	
 	public abstract boolean hasStrongType();
+	
+	public abstract ITypeID precompileForType(ExpressionScope scope, PrecompilationState state);
 }

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

 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	public boolean hasStrongType() {
 		return left.hasStrongType() && right.hasStrongType();
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		ITypeID leftType = left.precompileForType(scope, state);
+		ITypeID rightType = right.precompileForType(scope, state);
+		if (leftType == null || rightType == null)
+			return null;
+		
+		return scope.getTypeMembers(leftType).union(rightType);
+	}
 }

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

 
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.expression.ArrayExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 
 	@Override
 	public IPartialExpression compile(ExpressionScope scope) {
-		ITypeID asBaseType = BasicTypeID.ANY;
-		ArrayTypeID asType = scope.getTypeRegistry().getArray(asBaseType, 1);
+		ITypeID asBaseType = null;
+		ArrayTypeID asType = null;
 		boolean couldHintType = false;
 		
 		for (ITypeID hint : scope.hints) {
 			for (int i = 0; i < contents.size(); i++)
 				cContents[i] = contents.get(i).compile(contentScope).eval().castImplicit(position, scope, asBaseType);
 		} else if (contents.isEmpty()) {
-			return new ArrayExpression(position, cContents, asType);
+			throw new CompileException(position, CompileExceptionCode.UNTYPED_EMPTY_ARRAY, "Empty array with unknown type");
 		} else {
 			ExpressionScope contentScope = scope.withoutHints();
 			ITypeID resultType = null;
 	public boolean hasStrongType() {
 		return false;
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		if (contents.isEmpty())
+			return null;
+		
+		ITypeID type = contents.get(0).precompileForType(scope, state);
+		if (type == null)
+			return null;
+		
+		for (int i = 1; i < contents.size(); i++) {
+			ITypeID itemType = contents.get(i).precompileForType(scope, state);
+			type = scope.getTypeMembers(type).union(itemType);
+		}
+		return type;
+	}
 }

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

 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	public boolean hasStrongType() {
 		return right.hasStrongType();
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		return left.precompileForType(scope, state);
+	}
 }

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

 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	public boolean hasStrongType() {
 		return left.hasStrongType() && right.hasStrongType();
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		ITypeID leftType = left.precompileForType(scope, state);
+		if (leftType == null)
+			return null;
+		
+		DefinitionMemberGroup members = scope.getTypeMembers(leftType).getOrCreateGroup(this.operator);
+		ExpressionScope innerScope = scope.withHints(members.predictCallTypes(scope, scope.getResultTypeHints(), 1)[0]);
+		ITypeID rightType = right.precompileForType(innerScope, state);
+		FunctionalMemberRef method = members.selectMethod(position, scope, new CallArguments(rightType), true, false);
+		if (!state.precompile(method.getTarget()))
+			return null;
+		
+		return method.getTarget().header.returnType; // TODO: this will not work properly for methods with type parameters
+	}
 }

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

 import org.openzen.zenscript.codemodel.expression.ConstantBoolExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	public boolean hasStrongType() {
 		return true;
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		return BasicTypeID.BOOL;
+	}
 }

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

 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionParameter;
 import org.openzen.zenscript.parser.type.ParsedTypeBasic;
 		for (ParsedExpression expression : expressions)
 			parameters.add(expression.toLambdaParameter());
 		
-		return new ParsedFunctionHeader(parameters, ParsedTypeBasic.ANY, null);
+		return new ParsedFunctionHeader(parameters, ParsedTypeBasic.UNDETERMINED, null);
 	}
 
 	@Override
 	public boolean hasStrongType() {
 		return expressions.get(0).hasStrongType();
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		if (expressions.size() != 1)
+			return null;
+		
+		return expressions.get(0).precompileForType(scope, state);
+	}
 }

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

 import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionParameter;
 
 /**
 	public boolean hasStrongType() {
 		return true;
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		return null; // TODO: add support for this...
+	}
 }

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.parser.ParsedAnnotation;
+import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionParameter;
 import org.openzen.zenscript.parser.type.IParsedType;
 			throw new CompileException(position, CompileExceptionCode.LAMBDA_HEADER_INVALID, "Not a valid lambda header");
 		
 		ParsedFunctionHeader header = value.toLambdaHeader();
-		if (header.returnType != ParsedTypeBasic.ANY)
+		if (header.returnType != ParsedTypeBasic.UNDETERMINED)
 			throw new CompileException(position, CompileExceptionCode.LAMBDA_HEADER_INVALID, "Lambda parameter already has a return type");
 		
 		return new ParsedFunctionHeader(header.genericParameters, header.parameters, type, null);
 			throw new CompileException(position, CompileExceptionCode.LAMBDA_HEADER_INVALID, "Not a valid lambda header");
 		
 		ParsedFunctionParameter parameter = value.toLambdaParameter();
-		if (parameter.type != ParsedTypeBasic.ANY)
+		if (parameter.type != ParsedTypeBasic.UNDETERMINED)
 			throw new CompileException(position, CompileExceptionCode.LAMBDA_HEADER_INVALID, "Lambda parameter already has a type");
 		
 		return new ParsedFunctionParameter(ParsedAnnotation.NONE, parameter.name, type, null, false);
 	public boolean hasStrongType() {
 		return true;
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		return type.compile(scope);
+	}
 }

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	public boolean hasStrongType() {
 		return left.hasStrongType();
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		ITypeID leftType = left.precompileForType(scope, state);
+		if (leftType == null)
+			return null;
+		
+		ITypeID resultType = leftType.getOptionalBase();
+		ITypeID rightType = right.precompileForType(scope.withHint(resultType), state);
+		
+		TypeMembers resultTypeMembers = scope.getTypeMembers(resultType);
+		return resultTypeMembers.union(rightType);
+	}
 }

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

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	public boolean hasStrongType() {
 		return true;
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		return BasicTypeID.BOOL;
+	}
 }

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	public boolean hasStrongType() {
 		return ifThen.hasStrongType() && ifElse.hasStrongType();
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		ITypeID thenType = ifThen.precompileForType(scope, state);
+		ITypeID elseType = ifElse.precompileForType(scope, state);
+		if (thenType == null || elseType == null)
+			return null;
+		
+		return scope.getTypeMembers(thenType).union(elseType);
+	}
 }

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

 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	public boolean hasStrongType() {
 		return false;
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		for (ITypeID hint : scope.hints) {
+			if (hint == BasicTypeID.DOUBLE)
+				return hint;
+			else if (hint == BasicTypeID.FLOAT)
+				return hint;
+		}
+		
+		return BasicTypeID.DOUBLE;
+	}
 }

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

 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.scope.LambdaScope;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 import org.openzen.zenscript.parser.statements.ParsedFunctionBody;
 
 	public boolean hasStrongType() {
 		return false;
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		return null; // TODO: meh...
+	}
 }

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

 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	public boolean hasStrongType() {
 		return true;
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		ITypeID target = value.precompileForType(scope, state);
+		if (target == null)
+			return null;
+		
+		DefinitionMemberGroup members = scope.getTypeMembers(target).getOrCreateGroup(OperatorType.INDEXGET);
+		List<ITypeID>[] predicted = members.predictCallTypes(scope, scope.getResultTypeHints(), indexes.size());
+		
+		ITypeID[] indexTypes = new ITypeID[indexes.size()];
+		for (int i = 0; i < indexTypes.length; i++) {
+			indexTypes[i] = indexes.get(i).precompileForType(scope.withHints(predicted[i]), state);
+			if (indexTypes[i] == null)
+				return null;
+		}
+		
+		FunctionalMemberRef method = members.selectMethod(position, scope, new CallArguments(indexTypes), true, false);
+		if (!state.precompile(method.getTarget()))
+			return null;
+		
+		return method.getTarget().header.returnType; // TODO: this will not work properly for methods with type parameters
+	}
 	
 	private class PartialIndexedExpression implements IPartialExpression {
 		private final ExpressionScope scope;

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

 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	public boolean hasStrongType() {
 		return false;
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		for (ITypeID hint : scope.hints) {
+			if (hint instanceof BasicTypeID) {
+				switch ((BasicTypeID) hint) {
+					case SBYTE:
+					case BYTE:
+					case SHORT:
+					case USHORT:
+					case INT:
+					case UINT:
+					case LONG:
+					case ULONG:
+					case CHAR:
+						return hint;
+					default:
+				}
+			}
+		}
+		
+		if (value <= Integer.MAX_VALUE && value >= Integer.MIN_VALUE)
+			return BasicTypeID.INT;
+		else
+			return BasicTypeID.LONG;
+	}
 }

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

 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.type.IParsedType;
 
 /**
 	public boolean hasStrongType() {
 		return true;
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		return BasicTypeID.BOOL;
+	}
 }

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

 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 				return new NewExpression(position, assocHint, constructor, CallArguments.EMPTY);
 		}
 		
-		if (!hasAssocHint && scope.hints.size() == 1 && scope.hints.get(0) != BasicTypeID.ANY) {
+		if (!hasAssocHint && scope.hints.size() == 1) {
 			// compile as constructor call
 			ITypeID hint = scope.hints.get(0);
 			for (int i = 0; i < keys.size(); i++) {
 			}
 		}
 		if (keyType == null)
-			keyType = BasicTypeID.ANY;
+			throw new CompileException(position, CompileExceptionCode.UNTYPED_EMPTY_MAP, "Empty map without known type");
+		
 		for (int i = 0; i < cKeys.length; i++)
 			cKeys[i] = cKeys[i].castImplicit(position, scope, keyType);
 		
 			}
 		}
 		if (valueType == null)
-			valueType = BasicTypeID.ANY;
+			throw new CompileException(position, CompileExceptionCode.UNTYPED_EMPTY_MAP, "Empty map without known type");
+		
 		for (int i = 0; i < cValues.length; i++)
 			cValues[i] = cValues[i].castImplicit(position, scope, valueType);
 		
 	public boolean hasStrongType() {
 		return false;
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		return null; // TODO: fill this later
+	}
 }

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.type.IParsedType;
 
 /**
 	public boolean hasStrongType() {
 		return true;
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		IPartialExpression cValue = value.compile(scope.withoutHints());
+		ITypeID[] typeParameters = IParsedType.compileList(genericParameters, scope);
+		// TODO: proper precompilation
+		IPartialExpression member = cValue.getMember(
+				position,
+				scope,
+				scope.hints,
+				new GenericName(this.member, typeParameters));
+		if (member == null)
+			return null;
+		
+		return member.eval().type;
+	}
 }

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

 import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	public boolean hasStrongType() {
 		return false;
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		return BasicTypeID.BOOL;
+	}
 }

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

 import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	public boolean hasStrongType() {
 		return right.hasStrongType();
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		return left.precompileForType(scope, state);
+	}
 }

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

 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	public boolean hasStrongType() {
 		return left.hasStrongType() && right.hasStrongType();
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		ITypeID leftType = left.precompileForType(scope, state);
+		ITypeID rightType = right.precompileForType(scope, state);
+		if (leftType == null || rightType == null)
+			return null;
+		
+		return scope.getTypeMembers(leftType).union(rightType);
+	}
 }

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

 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	public boolean hasStrongType() {
 		return value.hasStrongType();
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		return null; // TODO: how will this be handled?
+	}
 }

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

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	public boolean hasStrongType() {
 		return value.hasStrongType();
 	}
+
+	@Override
+	public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
+		return value.precompileForType(scope, state);
+	}
 }