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

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

 import org.openzen.zenscript.codemodel.expression.TryRethrowAsResultExpression;
 import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
-import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.shared.StringUtils;
 
 /**
 
 	@Override
 	public ExpressionString visitCall(CallExpression expression) {
-		if (expression.member instanceof OperatorMember) {
-			OperatorMember operator = (OperatorMember) expression.member;
-			switch (operator.operator) {
+		if (expression.member.isOperator()) {
+			switch (expression.member.getOperator()) {
 				case NOT:
 					return unaryPrefix(expression.target, ZenScriptOperator.NOT, "!");
 				case NEG:
 					return new ExpressionString(result.toString(), ZenScriptOperator.CAST);
 				}
 				default:
-					throw new UnsupportedOperationException("Unknown operator: " + operator.operator);
+					throw new UnsupportedOperationException("Unknown operator: " + expression.member.getOperator());
 			}
 		} else {
 			StringBuilder result = new StringBuilder();
 			result.append(expression.target.accept(this).value);
 			result.append(".");
-			result.append(expression.member.name);
+			result.append(expression.member.getMethodName());
 			FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
 			return new ExpressionString(result.toString(), ZenScriptOperator.PRIMARY);
 		}
 	public ExpressionString visitCallStatic(CallStaticExpression expression) {
 		StringBuilder result = new StringBuilder();
 		result.append(expression.target.accept(typeFormatter));
-		if (expression.member instanceof OperatorMember) {
-			OperatorMember operator = (OperatorMember) expression.member;
-			if (operator.operator == OperatorType.CALL) {
+		if (expression.member.isOperator()) {
+			OperatorType operator = expression.member.getOperator();
+			if (operator == OperatorType.CALL) {
 				// nothing
 			} else {
 				result.append(".");
-				result.append(expression.member.name);
+				result.append(operator.operator);
 			}
 		} else {
 			result.append(".");
-			result.append(expression.member.name);
+			result.append(expression.member.getMethodName());
 		}
 		FormattingUtils.formatCall(result, typeFormatter, this, expression.arguments);
 		return new ExpressionString(result.toString(), ZenScriptOperator.PRIMARY);
 		StringBuilder result = new StringBuilder();
 		result.append(expression.type.accept(typeFormatter));
 		result.append('.');
-		result.append(expression.constant.name);
+		result.append(expression.constant.member.name);
 		return new ExpressionString(result.toString(), ZenScriptOperator.MEMBER);
 	}
 
 		StringBuilder result = new StringBuilder();
 		result.append(expression.target.accept(this));
 		result.append('.');
-		result.append(expression.field.name);
+		result.append(expression.field.member.name);
 		return new ExpressionString(result.toString(), ZenScriptOperator.MEMBER);
 	}
 
 		StringBuilder result = new StringBuilder();
 		result.append(expression.type.accept(typeFormatter));
 		result.append('.');
-		result.append(expression.field.name);
+		result.append(expression.field.member.name);
 		return new ExpressionString(result.toString(), ZenScriptOperator.MEMBER);
 	}
 
 		StringBuilder result = new StringBuilder();
 		result.append(expression.target.accept(this));
 		result.append('.');
-		result.append(expression.getter.name);
+		result.append(expression.getter.member.name);
 		return new ExpressionString(result.toString(), ZenScriptOperator.MEMBER);
 	}
 	
 	
 	@Override
 	public ExpressionString visitPostCall(PostCallExpression expression) {
-		return unaryPostfix(expression.target, ZenScriptOperator.INCREMENT, expression.member.operator == OperatorType.INCREMENT ? "++" : "--");
+		return unaryPostfix(expression.target, ZenScriptOperator.INCREMENT, expression.member.getOperator() == OperatorType.INCREMENT ? "++" : "--");
 	}
 
 	@Override
 	@Override
 	public ExpressionString visitSetField(SetFieldExpression expression) {
 		return new ExpressionString(
-				expression.target.accept(this) + "." + expression.field.name + " = " + expression.value.accept(this).value, 
+				expression.target.accept(this) + "." + expression.field.member.name + " = " + expression.value.accept(this).value, 
 				ZenScriptOperator.ASSIGN);
 	}
 
 	@Override
 	public ExpressionString visitSetStaticField(SetStaticFieldExpression expression) {
 		return new ExpressionString(
-				expression.type.accept(typeFormatter) + "." + expression.field.name + " = " + expression.value.accept(this).value,
+				expression.type.accept(typeFormatter) + "." + expression.field.member.name + " = " + expression.value.accept(this).value,
 				ZenScriptOperator.ASSIGN);
 	}
 
 	@Override
 	public ExpressionString visitSetter(SetterExpression expression) {
 		return new ExpressionString(
-				expression.target.accept(this) + "." + expression.setter.name + " = " + expression.value.accept(this),
+				expression.target.accept(this) + "." + expression.setter.member.name + " = " + expression.value.accept(this),
 				ZenScriptOperator.ASSIGN);
 	}
 
 	@Override
 	public ExpressionString visitStaticGetter(StaticGetterExpression expression) {
 		return new ExpressionString(
-				expression.type.accept(typeFormatter) + "." + expression.getter.name, 
+				expression.type.accept(typeFormatter) + "." + expression.getter.member.name, 
 				ZenScriptOperator.MEMBER);
 	}
 
 	@Override
 	public ExpressionString visitStaticSetter(StaticSetterExpression expression) {
 		return new ExpressionString(
-				expression.type.accept(typeFormatter) + "." + expression.setter.name + " = " + expression.setter.name,
+				expression.type.accept(typeFormatter) + "." + expression.setter.member.name + " = " + expression.setter.member.name,
 				ZenScriptOperator.ASSIGN);
 	}
 	
 
 	@Override
 	public ExpressionString visitTryConvert(TryConvertExpression expression) {
-		ExpressionString value = expression.accept(this);
+		ExpressionString value = expression.value.accept(this);
 		return new ExpressionString("try?" + value.value, value.priority);
 	}
 
 	@Override
 	public ExpressionString visitTryRethrowAsException(TryRethrowAsExceptionExpression expression) {
-		ExpressionString value = expression.accept(this);
+		ExpressionString value = expression.value.accept(this);
 		return new ExpressionString("try!" + value.value, value.priority);
 	}
 
 	@Override
 	public ExpressionString visitTryRethrowAsResult(TryRethrowAsResultExpression expression) {
-		ExpressionString value = expression.accept(this);
+		ExpressionString value = expression.value.accept(this);
 		return new ExpressionString("try!" + value.value, value.priority);
 	}
 	

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

 	@Override
 	public String acceptVariantOption(VariantOptionSwitchValue value) {
 		StringBuilder result = new StringBuilder();
-		result.append(value.option.name);
+		result.append(value.option.getName());
 		result.append("(");
 		for (int i = 0; i < value.parameters.length; i++) {
 			if (i > 0)

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

 	PRIMARY(10, null);
 	
 	private final int priority;
-	private final boolean isCommutative;
 	private final String operatorString;
 	
 	private ZenScriptOperator(int priority, String operatorString) {
-		this(priority, false, operatorString);
-	}
-	
-	private ZenScriptOperator(int priority, boolean isCommutative, String operatorString) {
 		this.priority = priority;
-		this.isCommutative = isCommutative;
 		this.operatorString = operatorString;
 	}
 
 	public int getPriority() {
 		return priority;
 	}
-
-	@Override
-	public boolean isCommutative() {
-		return isCommutative;
-	}
 	
 	@Override
 	public String getOperatorString() {

CodeFormatterShared/src/main/java/org/openzen/zenscript/formattershared/ExpressionString.java

 	}
 	
 	public ExpressionString unaryPrefix(FormattableOperator operator) {
-		return new ExpressionString(operator.getOperatorString() + value, operator);
+		return new ExpressionString(operator.getOperatorString() + wrapRight(operator), operator);
 	}
 	
 	public ExpressionString unaryPostfix(FormattableOperator operator) {
-		return new ExpressionString(value + operator.getOperatorString(), operator);
+		return new ExpressionString(wrapLeft(operator) + operator.getOperatorString(), operator);
 	}
 	
 	public ExpressionString unaryPrefix(FormattableOperator operator, String operatorString) {
-		return new ExpressionString(operatorString + value, operator);
+		return new ExpressionString(operatorString + wrapRight(operator), operator);
 	}
 	
 	public ExpressionString unaryPostfix(FormattableOperator operator, String operatorString) {
-		return new ExpressionString(value + operatorString, operator);
+		return new ExpressionString(wrapLeft(operator) + operatorString, operator);
 	}
 }

CodeFormatterShared/src/main/java/org/openzen/zenscript/formattershared/FormattableOperator.java

  * @author Hoofdgebruiker
  */
 public interface FormattableOperator {
+	/**
+	 * Operator priority: if priority of the inner operation is lower, it should
+	 * be wrapped in parenthesis.
+	 * 
+	 * @return 
+	 */
 	int getPriority();
 	
-	boolean isCommutative();
-	
 	String getOperatorString();
 	
 	public static boolean shouldWrapLeft(FormattableOperator inner, FormattableOperator outer) {
 	}
 	
 	public static boolean shouldWrapRight(FormattableOperator inner, FormattableOperator outer) {
-		return (inner == outer && inner.isCommutative()) || (inner.getPriority() <= outer.getPriority());
+		return inner.getPriority() <= outer.getPriority();
 	}
 }

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

 	public final ITypeID thrownType;
 	
 	public FunctionHeader(ITypeID returnType) {
+		if (returnType == null)
+			throw new NullPointerException();
+		
 		this.typeParameters = null;
 		this.returnType = returnType;
 		this.parameters = NO_PARAMETERS;
 	}
 	
 	public FunctionHeader(ITypeID returnType, ITypeID... parameterTypes) {
+		if (returnType == null)
+			throw new NullPointerException();
+		
 		this.typeParameters = null;
 		this.returnType = returnType;
 		this.parameters = new FunctionParameter[parameterTypes.length];
 	}
 	
 	public FunctionHeader(ITypeID returnType, FunctionParameter... parameters) {
+		if (returnType == null)
+			throw new NullPointerException();
+		
 		this.typeParameters = null;
 		this.returnType = returnType;
 		this.parameters = parameters;
 	}
 	
 	public FunctionHeader(TypeParameter[] genericParameters, ITypeID returnType, ITypeID thrownType, FunctionParameter... parameters) {
+		if (returnType == null)
+			throw new NullPointerException();
+		
 		this.typeParameters = genericParameters;
 		this.returnType = returnType;
 		this.parameters = parameters;
 		return typeParameters == null ? 0 : typeParameters.length;
 	}
 	
-	public FunctionHeader instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		TypeParameter[] genericParameters = this.typeParameters == null ? null : new TypeParameter[this.typeParameters.length];
-		if (genericParameters != null)
-			for (int i = 0; i < genericParameters.length; i++)
-				genericParameters[i] = this.typeParameters[i].withGenericArguments(registry, mapping);
-		
-		ITypeID returnType = this.returnType.withGenericArguments(registry, mapping);
-		FunctionParameter[] parameters = new FunctionParameter[this.parameters.length];
-		for (int i = 0; i < parameters.length; i++)
-			parameters[i] = this.parameters[i].withGenericArguments(registry, mapping);
-		
-		return new FunctionHeader(genericParameters, returnType, thrownType == null ? null : thrownType.withGenericArguments(registry, mapping), parameters);
+	public String getCanonical() {
+		StringBuilder result = new StringBuilder();
+		if (getNumberOfTypeParameters() > 0) {
+			result.append('<');
+			for (int i = 0; i < typeParameters.length; i++) {
+				if (i > 0)
+					result.append(',');
+				result.append(typeParameters[i].getCanonical());
+			}
+			result.append('>');
+		}
+		result.append('(');
+		for (int i = 0; i < parameters.length; i++) {
+			if (i > 0)
+				result.append(',');
+			result.append(parameters[i].type.toString());
+		}
+		result.append(')');
+		return result.toString();
 	}
 	
 	public ITypeID[] inferTypes(LocalMemberCache cache, CallArguments arguments, List<ITypeID> resultHint) {
 		return true;
 	}
 	
-	public FunctionHeader withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
-		ITypeID returnType = this.returnType.withGenericArguments(registry, arguments);
+	public FunctionHeader withGenericArguments(GenericMapper mapper) {
+		ITypeID returnType = this.returnType.instance(mapper);
 		FunctionParameter[] parameters = new FunctionParameter[this.parameters.length];
 		for (int i = 0; i < parameters.length; i++) {
-			ITypeID modified = this.parameters[i].type.withGenericArguments(registry, arguments);
-			parameters[i] = modified == this.parameters[i].type ? this.parameters[i] : new FunctionParameter(modified, this.parameters[i].name);
+			parameters[i] = this.parameters[i].withGenericArguments(mapper);
 		}
-		return new FunctionHeader(typeParameters, returnType, thrownType == null ? null : thrownType.withGenericArguments(registry, arguments), parameters);
+		return new FunctionHeader(typeParameters, returnType, thrownType == null ? null : thrownType.instance(mapper), parameters);
 	}
 	
-	public FunctionHeader withGenericArguments(GlobalTypeRegistry registry, ITypeID[] arguments) {
+	public FunctionHeader fillGenericArguments(GlobalTypeRegistry registry, ITypeID[] arguments) {
+		if (arguments == null || arguments.length == 0)
+			return this;
+		
 		Map<TypeParameter, ITypeID> typeArguments = new HashMap<>();
 		if (typeParameters != null)
 			for (int i = 0; i < typeParameters.length; i++)
 				typeArguments.put(typeParameters[i], arguments[i]);
+		GenericMapper mapper = new GenericMapper(registry, typeArguments);
 		
-		ITypeID returnType = this.returnType.withGenericArguments(registry, typeArguments);
+		ITypeID returnType = this.returnType.instance(mapper);
 		FunctionParameter[] parameters = new FunctionParameter[this.parameters.length];
 		for (int i = 0; i < parameters.length; i++) {
-			ITypeID modified = this.parameters[i].type.withGenericArguments(registry, typeArguments);
-			parameters[i] = modified == this.parameters[i].type ? this.parameters[i] : new FunctionParameter(modified, this.parameters[i].name);
+			parameters[i] = this.parameters[i].withGenericArguments(mapper);
 		}
-		return new FunctionHeader(returnType, parameters);
+		return new FunctionHeader(null, returnType, thrownType == null ? null : thrownType.instance(mapper), parameters);
 	}
 	
 	public FunctionHeader forTypeParameterInference() {

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

 package org.openzen.zenscript.codemodel;
 
 import org.openzen.zenscript.codemodel.annotations.Annotation;
-import java.util.Map;
 import java.util.Objects;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.Taggable;
 
 		this.variadic = variadic;
 	}
 	
-	public FunctionParameter withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
-		FunctionParameter result = new FunctionParameter(type.withGenericArguments(registry, arguments), name, defaultValue, variadic);
+	public FunctionParameter withGenericArguments(GenericMapper mapper) {
+		ITypeID instanced = type.instance(mapper);
+		if (instanced == type)
+			return this;
+		
+		FunctionParameter result = new FunctionParameter(instanced, name, defaultValue, variadic);
 		result.annotations = annotations;
+		result.addAllTagsFrom(this); // TODO: this will cause trouble -> references?
 		return result;
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/GenericMapper.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;
+
+import java.util.Map;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.GenericTypeID;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class GenericMapper {
+	public final GlobalTypeRegistry registry;
+	private final Map<TypeParameter, ITypeID> mapping;
+	
+	public GenericMapper(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
+		this.registry = registry;
+		this.mapping = mapping;
+	}
+	
+	public Map<TypeParameter, ITypeID> getMapping() {
+		return mapping;
+	}
+	
+	public ITypeID map(ITypeID original) {
+		return mapping.isEmpty() ? original : original.instance(this);
+	}
+	
+	public ITypeID[] map(ITypeID[] original) {
+		if (mapping.isEmpty())
+			return original;
+		
+		ITypeID[] mapped = new ITypeID[original.length];
+		for (int i = 0; i < original.length; i++)
+			mapped[i] = original[i].instance(this);
+		return mapped;
+	}
+	
+	public ITypeID map(GenericTypeID type) {
+		return mapping.containsKey(type.parameter) ? mapping.get(type.parameter) : type;
+	}
+	
+	public FunctionHeader map(FunctionHeader original) {
+		return mapping.isEmpty() ? original : original.withGenericArguments(this);
+	}
+}

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

 			pkg.register(this);
 	}
 	
+	public String getFullName() {
+		return pkg.fullName + '.' + name;
+	}
+	
 	public int getNumberOfGenericParameters() {
 		return genericParameters == null ? 0 : genericParameters.length;
 	}

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.member.CallerMember;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 	public void setHeader(FunctionHeader header) {
 		this.header = header;
 		addMember(caller = new CallerMember(position, this, modifiers | Modifiers.STATIC, header, null));
-		callerGroup.addMethod(caller, TypeMemberPriority.SPECIFIED);
+		callerGroup.addMethod(new FunctionalMemberRef(caller, caller.header), TypeMemberPriority.SPECIFIED);
 	}
 	
 	public void setCode(Statement statement) {

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

 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
+import org.openzen.zenscript.shared.Taggable;
 
 /**
  *
 		return visitor.visitVariant(this);
 	}
 	
-	public static class Option {
+	public static class Option extends Taggable {
 		public final String name;
 		public final ITypeID[] types;
 		
 			this.types = types;
 		}
 		
-		public Option instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-			ITypeID[] newTypes = new ITypeID[types.length];
-			for (int i = 0; i < types.length; i++)
-				newTypes[i] = types[i].withGenericArguments(registry, mapping);
-			
-			return new Option(name, newTypes);
+		public VariantOptionRef instance(GenericMapper mapper) {
+			return new VariantOptionRef(this, mapper.map(types));
 		}
 	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.shared.CodePosition;
 
  */
 public class CallExpression extends Expression {
 	public final Expression target;
-	public final FunctionalMember member;
+	public final FunctionalMemberRef member;
 	public final CallArguments arguments;
 	public final FunctionHeader instancedHeader;
 	
-	public CallExpression(CodePosition position, Expression target, FunctionalMember member, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
+	public CallExpression(CodePosition position, Expression target, FunctionalMemberRef member, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 		super(position, instancedHeader.returnType, multiThrow(position, arguments.arguments));
 		
 		this.target = target;
 	
 	@Override
 	public String evaluateStringConstant() {
-		if (member.builtin == null)
+		if (member.getBuiltin() == null)
 			throw new UnsupportedOperationException("Cannot evaluate to a string constant!");
 		
-		switch (member.builtin) {
+		switch (member.getBuiltin()) {
 			case STRING_ADD_STRING:
 				return target.evaluateStringConstant() + arguments.arguments[0].evaluateStringConstant();
 			default:

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
  * @author Hoofdgebruiker
  */
 public class CallStaticExpression extends Expression {
-	public final FunctionalMember member;
+	public final FunctionalMemberRef member;
 	public final ITypeID target;
 	public final CallArguments arguments;
 	public final FunctionHeader instancedHeader;
 	
-	public CallStaticExpression(CodePosition position, ITypeID target, FunctionalMember member, CallArguments arguments, FunctionHeader instancedHeader, TypeScope scope) {
+	public CallStaticExpression(CodePosition position, ITypeID target, FunctionalMemberRef member, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 		super(position, instancedHeader.returnType, multiThrow(position, arguments.arguments));
 		
 		this.member = member;
 	@Override
 	public Expression transform(ExpressionTransformer transformer) {
 		CallArguments tArguments = arguments.transform(transformer);
-		return arguments == tArguments ? this : new CallStaticExpression(position, target, member, tArguments, instancedHeader, null);
+		return arguments == tArguments ? this : new CallStaticExpression(position, target, member, instancedHeader, tArguments, null);
 	}
 }

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
-import java.util.Map;
-import org.openzen.zenscript.codemodel.FunctionParameter;
-import org.openzen.zenscript.codemodel.member.CasterMember;
+import org.openzen.zenscript.codemodel.member.ref.CasterMemberRef;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
  */
 public class CastExpression extends Expression {
 	public final Expression target;
-	public final CasterMember member;
+	public final CasterMemberRef member;
 	public final boolean isImplicit;
 	
-	public CastExpression(CodePosition position, Expression target, CasterMember member, boolean isImplicit) {
-		super(position, member.getTargetType(), binaryThrow(position, target.thrownType, member.header.thrownType));
+	public CastExpression(CodePosition position, Expression target, CasterMemberRef member, boolean isImplicit) {
+		super(position, member.toType, binaryThrow(position, target.thrownType, member.member.header.thrownType));
 		
 		this.target = target;
 		this.member = member;

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zenscript.codemodel.CompareType;
-import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.shared.CodePosition;
 public class CompareExpression extends Expression {
 	public final Expression left;
 	public final Expression right;
-	public final FunctionalMember operator;
+	public final FunctionalMemberRef operator;
 	public final CompareType comparison;
 	
-	public CompareExpression(CodePosition position, Expression left, Expression right, FunctionalMember operator, CompareType comparison, TypeScope scope) {
+	public CompareExpression(CodePosition position, Expression left, Expression right, FunctionalMemberRef operator, CompareType comparison, TypeScope scope) {
 		super(position, BasicTypeID.BOOL, binaryThrow(position, left.thrownType, right.thrownType));
 		
 		this.left = left;

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
-import org.openzen.zenscript.codemodel.member.ConstMember;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
  * @author Hoofdgebruiker
  */
 public class ConstExpression extends Expression {
-	public final ConstMember constant;
+	public final ConstMemberRef constant;
 	
-	public ConstExpression(CodePosition position, ConstMember constant) {
+	public ConstExpression(CodePosition position, ConstMemberRef constant) {
 		super(position, constant.type, null);
 		
 		this.constant = constant;
 	
 	@Override
 	public String evaluateStringConstant() {
-		return constant.value.evaluateStringConstant();
+		return constant.member.value.evaluateStringConstant();
 	}
 	
 	@Override
 	public EnumConstantMember evaluateEnumConstant() {
-		return constant.value.evaluateEnumConstant();
+		return constant.member.value.evaluateEnumConstant();
 	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
  */
 public class ConstructorThisCallExpression extends Expression {
 	public final ITypeID objectType;
-	public final ConstructorMember constructor;
+	public final FunctionalMemberRef constructor;
 	public final CallArguments arguments;
 	
-	public ConstructorThisCallExpression(CodePosition position, ITypeID type, ConstructorMember constructor, CallArguments arguments, TypeScope scope) {
+	public ConstructorThisCallExpression(CodePosition position, ITypeID type, FunctionalMemberRef constructor, CallArguments arguments, TypeScope scope) {
 		super(position, BasicTypeID.VOID, binaryThrow(position, constructor.header.thrownType, multiThrow(position, arguments.arguments)));
 		
 		this.objectType = type;

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

 	public final ITypeID thrownType;
 	
 	public Expression(CodePosition position, ITypeID type, ITypeID thrownType) {
+		if (type == null)
+			throw new NullPointerException();
+		
 		this.position = position;
 		this.type = type;
 		this.thrownType = thrownType;

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

 import java.util.List;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
-import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 		DefinitionMemberGroup constructors = scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CONSTRUCTOR);
 		List<ITypeID>[] predictedTypes = constructors.predictCallTypes(scope, scope.hints, arguments.length);
 		CallArguments compiledArguments = new CallArguments(arguments);
-		FunctionalMember member = constructors.selectMethod(position, scope, compiledArguments, true, true);
+		FunctionalMemberRef member = constructors.selectMethod(position, scope, compiledArguments, true, true);
 		if (member == null)
 			throw new CompileException(position, CompileExceptionCode.CALL_NO_VALID_METHOD, "No matching constructor found");
-		if (!(member instanceof ConstructorMember))
+		if (!member.isConstructor())
 			throw new CompileException(position, CompileExceptionCode.INTERNAL_ERROR, "COMPILER BUG: constructor is not a constructor");
 		
 		return new NewExpression(
 				position,
 				type,
-				(ConstructorMember) member,
+				member,
 				compiledArguments,
-				compiledArguments.getNumberOfTypeArguments() == 0 ? member.header : member.header.withGenericArguments(scope.getTypeRegistry(), compiledArguments.typeArguments),
+				compiledArguments.getNumberOfTypeArguments() == 0 ? member.header : member.header.fillGenericArguments(scope.getTypeRegistry(), compiledArguments.typeArguments),
 				scope);
 	}
 	

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

 
 import java.util.Collections;
 import java.util.List;
-import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
  */
 public class GetFieldExpression extends Expression {
 	public final Expression target;
-	public final FieldMember field;
+	public final FieldMemberRef field;
 	
-	public GetFieldExpression(CodePosition position, Expression target, FieldMember field) {
+	public GetFieldExpression(CodePosition position, Expression target, FieldMemberRef field) {
 		super(position, field.type, target.thrownType);
 		
 		this.target = target;

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

 
 import java.util.Collections;
 import java.util.List;
-import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 
  * @author Hoofdgebruiker
  */
 public class GetStaticFieldExpression extends Expression {
-	public final FieldMember field;
+	public final FieldMemberRef field;
 	
-	public GetStaticFieldExpression(CodePosition position, FieldMember field) {
+	public GetStaticFieldExpression(CodePosition position, FieldMemberRef field) {
 		super(position, field.type, null);
 		
 		this.field = field;

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
-import org.openzen.zenscript.codemodel.member.GetterMember;
+import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
  */
 public class GetterExpression extends Expression {
 	public final Expression target;
-	public final GetterMember getter;
+	public final GetterMemberRef getter;
 	
-	public GetterExpression(CodePosition position, Expression target, GetterMember getter) {
+	public GetterExpression(CodePosition position, Expression target, GetterMemberRef getter) {
 		super(position, getter.type, target.thrownType);
 		
 		this.target = target;

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

 
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
  * @author Hoofdgebruiker
  */
 public class NewExpression extends Expression {
-	public final ConstructorMember constructor;
+	public final FunctionalMemberRef constructor;
 	public final CallArguments arguments;
 	public final FunctionHeader instancedHeader;
 	
 	public NewExpression(
 			CodePosition position,
 			ITypeID type,
-			ConstructorMember constructor,
+			FunctionalMemberRef constructor,
 			CallArguments arguments)
 	{
 		super(position, type, binaryThrow(position, constructor.header.thrownType, multiThrow(position, arguments.arguments)));
 	public NewExpression(
 			CodePosition position,
 			ITypeID type,
-			ConstructorMember constructor,
+			FunctionalMemberRef constructor,
 			CallArguments arguments,
 			FunctionHeader instancedHeader,
 			TypeScope scope)

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

 
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.OperatorType;
-import org.openzen.zenscript.codemodel.member.OperatorMember;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
  */
 public class PostCallExpression extends Expression {
 	public final Expression target;
-	public final OperatorMember member;
+	public final FunctionalMemberRef member;
 	public final FunctionHeader instancedHeader;
 	
-	public PostCallExpression(CodePosition position, Expression target, OperatorMember member, FunctionHeader instancedHeader) {
+	public PostCallExpression(CodePosition position, Expression target, FunctionalMemberRef member, FunctionHeader instancedHeader) {
 		super(position, instancedHeader.returnType, binaryThrow(position, instancedHeader.thrownType, target.thrownType));
 		
-		if (member.operator != OperatorType.DECREMENT && member.operator != OperatorType.INCREMENT)
+		if (member.getOperator() != OperatorType.DECREMENT && member.getOperator() != OperatorType.INCREMENT)
 			throw new IllegalArgumentException("Operator must be increment or decrement");
 		
 		this.target = target;

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
-import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
  */
 public class SetFieldExpression extends Expression {
 	public final Expression target;
-	public final FieldMember field;
+	public final FieldMemberRef field;
 	public final Expression value;
 	
-	public SetFieldExpression(CodePosition position, Expression target, FieldMember field, Expression value) {
+	public SetFieldExpression(CodePosition position, Expression target, FieldMemberRef field, Expression value) {
 		super(position, field.type, binaryThrow(position, target.thrownType, value.thrownType));
 		
 		this.target = target;

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
-import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
  * @author Hoofdgebruiker
  */
 public class SetStaticFieldExpression extends Expression {
-	public final FieldMember field;
+	public final FieldMemberRef field;
 	public final Expression value;
 	
-	public SetStaticFieldExpression(CodePosition position, FieldMember field, Expression value) {
+	public SetStaticFieldExpression(CodePosition position, FieldMemberRef field, Expression value) {
 		super(position, field.type, value.thrownType);
 		
 		this.field = field;

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
-import org.openzen.zenscript.codemodel.member.SetterMember;
+import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
  */
 public class SetterExpression extends Expression {
 	public final Expression target;
-	public final SetterMember setter;
+	public final SetterMemberRef setter;
 	public final Expression value;
 	
-	public SetterExpression(CodePosition position, Expression target, SetterMember setter, Expression value) {
-		super(position, setter.type, binaryThrow(position, value.thrownType, setter.header.thrownType));
+	public SetterExpression(CodePosition position, Expression target, SetterMemberRef setter, Expression value) {
+		super(position, setter.type, value.thrownType);
 		
 		this.target = target;
 		this.setter = setter;

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
-import org.openzen.zenscript.codemodel.member.GetterMember;
+import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
  * @author Hoofdgebruiker
  */
 public class StaticGetterExpression extends Expression {
-	public final GetterMember getter;
+	public final GetterMemberRef getter;
 	
-	public StaticGetterExpression(CodePosition position, GetterMember getter) {
-		super(position, getter.type, getter.header.thrownType);
+	public StaticGetterExpression(CodePosition position, GetterMemberRef getter) {
+		super(position, getter.type, null);
 		
 		this.getter = getter;
 	}

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
-import org.openzen.zenscript.codemodel.member.SetterMember;
+import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
  * @author Hoofdgebruiker
  */
 public class StaticSetterExpression extends Expression {
-	public final SetterMember setter;
+	public final SetterMemberRef setter;
 	public final Expression value;
 	
-	public StaticSetterExpression(CodePosition position, SetterMember setter, Expression value) {
-		super(position, setter.type, binaryThrow(position, setter.header.thrownType, value.thrownType));
+	public StaticSetterExpression(CodePosition position, SetterMemberRef setter, Expression value) {
+		super(position, setter.type, value.thrownType);
 		
 		this.setter = setter;
 		this.value = value;

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

 package org.openzen.zenscript.codemodel.expression;
 
 import java.util.List;
-import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
  * @author Hoofdgebruiker
  */
 public class VariantValueExpression extends Expression {
-	public final VariantDefinition.Option option;
+	public final VariantOptionRef option;
 	public final Expression[] arguments;
 	
-	public VariantValueExpression(CodePosition position, ITypeID variantType, VariantDefinition.Option option) {
+	public VariantValueExpression(CodePosition position, ITypeID variantType, VariantOptionRef option) {
 		this(position, variantType, option, Expression.NONE);
 	}
 	
-	public VariantValueExpression(CodePosition position, ITypeID variantType, VariantDefinition.Option option, Expression[] arguments) {
+	public VariantValueExpression(CodePosition position, ITypeID variantType, VariantOptionRef option, Expression[] arguments) {
 		super(position, variantType, multiThrow(position, arguments));
 		
 		this.option = option;

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

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

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

  */
 package org.openzen.zenscript.codemodel.generic;
 
-import java.util.Map;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 	
 	public abstract boolean matches(LocalMemberCache cache, ITypeID type);
 	
-	public abstract GenericParameterBound withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments);
+	public abstract GenericParameterBound instance(GenericMapper mapper);
+	
+	public abstract String getCanonical();
 }

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

  */
 package org.openzen.zenscript.codemodel.generic;
 
-import java.util.Map;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 	public ParameterSuperBound(ITypeID type) {
 		this.type = type;
 	}
+	
+	@Override
+	public String getCanonical() {
+		return "super|" + type.toString();
+	}
 
 	@Override
 	public void registerMembers(LocalMemberCache cache, TypeMembers type) {
 	}
 
 	@Override
-	public GenericParameterBound withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
-		ITypeID translated = type.withGenericArguments(registry, arguments);
+	public GenericParameterBound instance(GenericMapper mapper) {
+		ITypeID translated = type.instance(mapper);
 		if (translated == type)
 			return this;
 		

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

  */
 package org.openzen.zenscript.codemodel.generic;
 
-import java.util.Map;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 		this.position = position;
 		this.type = type;
 	}
+	
+	@Override
+	public String getCanonical() {
+		return type.toString();
+	}
 
 	@Override
 	public void registerMembers(LocalMemberCache cache, TypeMembers type) {
 	}
 
 	@Override
-	public GenericParameterBound withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
-		return new ParameterTypeBound(position, type.withGenericArguments(registry, arguments));
+	public GenericParameterBound instance(GenericMapper mapper) {
+		return new ParameterTypeBound(position, type.instance(mapper));
 	}
 
 	@Override

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

 		return this;
 	}
 	
+	public String getCanonical() {
+		StringBuilder result = new StringBuilder();
+		result.append(name);
+		for(GenericParameterBound bound : bounds) {
+			result.append(':');
+			result.append(bound.getCanonical());
+		}
+		return result.toString();
+	}
+	
+	@Override
 	public String toString() {
 		return name + "@" + position.toShortString();
 	}

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

  */
 package org.openzen.zenscript.codemodel.member;
 
-import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 	}
 	
 	@Override
-	public String getInformalName() {
-		return "caller";
+	public String getCanonicalName() {
+		return definition.getFullName() + ":caller:" + header.getCanonical();
 	}
-
+	
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addCaller(this, priority);
+	public FunctionalKind getKind() {
+		return FunctionalKind.CALLER;
 	}
 
 	@Override
-	public DefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return new CallerMember(
-				position,
-				definition,
-				modifiers,
-				header.instance(registry, mapping),
-				builtin);
+	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
+		type.addCaller(ref(mapper), priority);
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.member;
 
-import java.util.Map;
 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.expression.CallArguments;
-import org.openzen.zenscript.codemodel.expression.CastExpression;
-import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.member.ref.CasterMemberRef;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 	}
 	
 	@Override
-	public String getInformalName() {
-		return "caster to " + toType.toString();
+	public String getCanonicalName() {
+		return definition.getFullName() + ":caster:" + toType.toString();
 	}
-
+	
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addCaster(this, priority);
+	public FunctionalKind getKind() {
+		return FunctionalKind.CASTER;
 	}
 
 	@Override
-	public String describe() {
-		return "caster to " + toType.toString();
+	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
+		type.addCaster(new CasterMemberRef(this, mapper.map(toType)), priority);
 	}
 
 	@Override
-	public DefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return new CasterMember(
-				position,
-				definition,
-				modifiers,
-				toType.withGenericArguments(registry, mapping),
-				builtin);
+	public String describe() {
+		return "caster to " + toType.toString();
 	}
 	
 	public ITypeID getTargetType() {
 		return toType;
 	}
-
-	@Override
-	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
-		throw new UnsupportedOperationException("Cannot call a caster!");
-	}
-	
-	public Expression cast(CodePosition position, Expression value, boolean implicit) {
-		return new CastExpression(position, value, this, implicit);
-	}
 	
 	public boolean isImplicit() {
 		return Modifiers.isImplicit(modifiers);

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

  */
 package org.openzen.zenscript.codemodel.member;
 
-import java.util.Map;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 	}
 
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addConst(this);
-	}
-
-	@Override
-	public IDefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return this;
+	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
+		members.addConst(new ConstMemberRef(this, mapper.map(type)));
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.member;
 
-import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
 import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.statement.BlockStatement;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 	}
 	
 	@Override
-	public String getInformalName() {
-		return "constructor";
+	public String getCanonicalName() {
+		return definition.getFullName() + ":this" + header.getCanonical();
 	}
-
+	
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		if (priority == TypeMemberPriority.SPECIFIED)
-			type.addConstructor(this, priority);
+	public FunctionalKind getKind() {
+		return FunctionalKind.CONSTRUCTOR;
 	}
 
 	@Override
-	public DefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		ConstructorMember result = new ConstructorMember(
-				position,
-				definition,
-				modifiers,
-				header.instance(registry, mapping),
-				builtin);
-		return result;
+	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
+		if (priority == TypeMemberPriority.SPECIFIED)
+			type.addConstructor(ref(mapper), priority);
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.member;
 
-import java.util.Map;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
+import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
 import org.openzen.zenscript.codemodel.statement.Statement;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 	}
 
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addIterator(this, priority);
-	}
-
-	@Override
-	public DefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		ITypeID[] newIteratorTypes = new ITypeID[iteratorTypes.length];
-		for (int i = 0; i < newIteratorTypes.length; i++)
-			newIteratorTypes[i] = iteratorTypes[i].withGenericArguments(registry, mapping);
-		return new CustomIteratorMember(position, definition, modifiers, newIteratorTypes);
+	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
+		type.addIterator(new IteratorMemberRef(this, mapper.map(iteratorTypes)), priority);
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.member;
 
-import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.shared.CodePosition;
 	}
 	
 	@Override
-	public String getInformalName() {
-		return "destructor";
+	public String getCanonicalName() {
+		return definition.getFullName() + ":destructor";
 	}
-
+	
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		if (priority == TypeMemberPriority.SPECIFIED)
-			type.addDestructor(this, priority);
+	public FunctionalKind getKind() {
+		return FunctionalKind.DESTRUCTOR;
 	}
 
 	@Override
-	public DefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return this;
+	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
+		if (priority == TypeMemberPriority.SPECIFIED)
+			type.addDestructor(ref(mapper), priority);
 	}
 
 	@Override

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

 package org.openzen.zenscript.codemodel.member;
 
 import java.util.Map;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetFieldExpression;
 import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 		if (autoGetterAccess != 0) {
 			ITypeID myType = registry.getForDefinition(definition, parameters);
 			this.autoGetter = new GetterMember(position, definition, autoGetterAccess, name, type, null);
-			this.autoGetter.setBody(new ReturnStatement(position, new GetFieldExpression(position, new ThisExpression(position, myType), this)));
+			this.autoGetter.setBody(new ReturnStatement(position, new GetFieldExpression(position, new ThisExpression(position, myType), new FieldMemberRef(this, myType))));
 		} else {
 			this.autoGetter = null;
 		}
 			this.autoSetter.setBody(new ExpressionStatement(position, new SetFieldExpression(
 					position,
 					new ThisExpression(position, myType),
-					this,
+					new FieldMemberRef(this, myType),
 					new GetFunctionParameterExpression(position, this.autoSetter.header.parameters[0]))));
 		} else {
 			this.autoSetter = null;
 	}
 
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addField(this, priority);
+	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
+		members.addField(new FieldMemberRef(this, mapper.map(type)), priority);
 	}
 	
 	@Override
 		return builtin;
 	}
 
-	@Override
-	public FieldMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return new FieldMember(
-				position,
-				definition,
-				modifiers,
-				name,
-				type.withGenericArguments(registry, mapping),
-				autoGetterAccess,
-				autoSetterAccess,
-				autoGetter == null ? null : autoGetter.instance(registry, mapping),
-				autoSetter == null ? null : autoSetter.instance(registry, mapping),
-				builtin);
-	}
-
 	@Override
 	public String describe() {
 		return "field " + name;

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.member;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public enum FunctionalKind {
+	CONSTRUCTOR,
+	DESTRUCTOR,
+	METHOD,
+	OPERATOR,
+	GETTER,
+	SETTER,
+	CALLER,
+	CASTER
+}

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

  */
 package org.openzen.zenscript.codemodel.member;
 
-import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.expression.CallArguments;
-import org.openzen.zenscript.codemodel.expression.CallExpression;
-import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
-import org.openzen.zenscript.codemodel.expression.CompareExpression;
-import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.statement.Statement;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.shared.CodePosition;
 
 		this.body = body;
 	}
 	
-	public abstract String getInformalName();
+	public abstract String getCanonicalName();
 	
-	@Override
-	public BuiltinID getBuiltin() {
-		return builtin;
-	}
-	
-	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
-		return new CallExpression(position, target, this, instancedHeader, arguments, scope);
-	}
+	public abstract FunctionalKind getKind();
 	
-	public final Expression call(CodePosition position, Expression target, CallArguments arguments, TypeScope scope) {
-		return call(position, target, header, arguments, scope);
+	public FunctionalMemberRef ref(GenericMapper mapper) {
+		return new FunctionalMemberRef(this, mapper.map(header));
 	}
 	
-	public Expression callWithComparator(CodePosition position, CompareType comparison, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
-		return new CompareExpression(position, target, arguments.arguments[0], this, comparison, scope);
-	}
-	
-	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
-		return new CallStaticExpression(position, target, this, arguments, instancedHeader, scope);
+	@Override
+	public BuiltinID getBuiltin() {
+		return builtin;
 	}
 }

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

  */
 package org.openzen.zenscript.codemodel.member;
 
-import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.GetterExpression;
-import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 	}
 	
 	@Override
-	public String getInformalName() {
-		return "getter " + name;
-	}
-	
-	public Expression get(CodePosition position, Expression target) {
-		return new GetterExpression(position, target, this);
-	}
-	
-	public Expression getStatic(CodePosition position) {
-		return new StaticGetterExpression(position, this);
+	public String getCanonicalName() {
+		return definition.getFullName() + ":getter:" + name;
 	}
 	
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addGetter(this, priority);
+	public FunctionalKind getKind() {
+		return FunctionalKind.GETTER;
 	}
-
+	
 	@Override
-	public GetterMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return new GetterMember(
-				position,
-				definition,
-				modifiers,
-				name,
-				type.withGenericArguments(registry, mapping),
-				builtin);
+	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
+		members.addGetter(new GetterMemberRef(this, mapper.map(type)), priority);
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.member;
 
-import java.util.Map;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.GenericMapper;
 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 BuiltinID getBuiltin();
 	
-	public void registerTo(TypeMembers type, TypeMemberPriority priority);
-	
-	public IDefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping);
+	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper);
 	
 	public <T> T accept(MemberVisitor<T> visitor);
 	

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

 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.member.ref.ImplementationMemberRef;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 	}
 
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addImplementation(this, priority);
+	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
+		ITypeID instancedType = mapper.map(type);
+		members.addImplementation(new ImplementationMemberRef(this, instancedType), priority);
 		
-		TypeMembers interfaceTypeMembers = type.getMemberCache().get(this.type);
-		interfaceTypeMembers.copyMembersTo(position, type, TypeMemberPriority.INTERFACE);
-	}
-
-	@Override
-	public DefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		ITypeID instancedType = type.withGenericArguments(registry, mapping);
-		ImplementationMember result = new ImplementationMember(position, definition, modifiers, instancedType);
-		for (IDefinitionMember member : members)
-			result.addMember(member.instance(registry, mapping));
-		return result;
+		TypeMembers interfaceTypeMembers = members.getMemberCache().get(instancedType);
+		interfaceTypeMembers.copyMembersTo(position, members, TypeMemberPriority.INTERFACE);
 	}
 
 	@Override
 	public String describe() {
-		return "implementation " + type.toString();
+		return "implementation of " + type.toString();
 	}
 	
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.member;
 
-import java.util.Map;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 	}
 
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addInnerType(innerDefinition.name, new InnerDefinition(innerDefinition));
-	}
-
-	@Override
-	public DefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		if (this.isStatic()) {
-			return this;
+	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
+		if (isStatic() || mapper.getMapping().isEmpty()) {
+			type.addInnerType(innerDefinition.name, new InnerDefinition(innerDefinition));
 		} else {
-			return new InstancedInnerDefinitionMember(position, definition, modifiers, innerDefinition, mapping);
+			type.addInnerType(innerDefinition.name, new InnerDefinition(innerDefinition, mapper.getMapping()));
 		}
 	}
 

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

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.codemodel.member;
-
-import java.util.HashMap;
-import java.util.Map;
-import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.member.BuiltinID;
-import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
-import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-import org.openzen.zenscript.shared.CodePosition;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-// How it works:
-// - A type definition with type parameters contains an inner definition (which may contain references to one or more type parameters)
-// - The type is instanced somewhere
-// - The members of that type are instanced and registered to the TypeMembers. This will generate an InstancedInnerDefinitionMember for the inner definition.
-public class InstancedInnerDefinitionMember extends DefinitionMember {
-	public final HighLevelDefinition definition;
-	public final Map<TypeParameter, ITypeID> outerMapping;
-	
-	public InstancedInnerDefinitionMember(
-			CodePosition position,
-			HighLevelDefinition outer,
-			int modifiers,
-			HighLevelDefinition definition,
-			Map<TypeParameter, ITypeID> outerMapping)
-	{
-		super(position, outer, modifiers);
-		this.definition = definition;
-		this.outerMapping = outerMapping;
-	}
-
-	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addInnerType(this.definition.name, new InnerDefinition(this.definition, outerMapping));
-	}
-	
-	@Override
-	public BuiltinID getBuiltin() {
-		return null;
-	}
-
-	@Override
-	public DefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		if (this.isStatic()) {
-			return this;
-		} else {
-			Map<TypeParameter, ITypeID> totalMap = new HashMap<>();
-			for (Map.Entry<TypeParameter, ITypeID> entry : outerMapping.entrySet())
-				totalMap.put(entry.getKey(), entry.getValue().withGenericArguments(registry, mapping));
-			for (Map.Entry<TypeParameter, ITypeID> entry : mapping.entrySet())
-				totalMap.put(entry.getKey(), entry.getValue());
-			
-			return new InstancedInnerDefinitionMember(position, definition, modifiers, definition, totalMap);
-		}
-	}
-
-	@Override
-	public String describe() {
-		return "inner type " + definition.name;
-	}
-
-	@Override
-	public <T> T accept(MemberVisitor<T> visitor) {
-		throw new UnsupportedOperationException("Should never be called on this member!");
-	}
-}

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

  */
 package org.openzen.zenscript.codemodel.member;
 
-import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 	}
 	
 	@Override
-	public String getInformalName() {
-		return name + " method";
+	public String getCanonicalName() {
+		return definition.getFullName() + ":" + name + header.getCanonical();
 	}
-
+	
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addMethod(this, priority);
+	public FunctionalKind getKind() {
+		return FunctionalKind.METHOD;
 	}
 
 	@Override
-	public DefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return new MethodMember(
-				position,
-				definition,
-				modifiers,
-				name,
-				header.instance(registry, mapping),
-				builtin);
+	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
+		type.addMethod(name, ref(mapper), priority);
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.member;
 
-import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.OperatorType;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 	}
 	
 	@Override
-	public String getInformalName() {
-		return operator.operator + " operator";
+	public String getCanonicalName() {
+		return definition.getFullName() + ":" + operator.operator + header.getCanonical();
 	}
-
+	
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addOperator(this, priority);
+	public FunctionalKind getKind() {
+		return FunctionalKind.OPERATOR;
 	}
 
 	@Override
-	public DefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return new OperatorMember(
-				position,
-				definition,
-				modifiers,
-				operator,
-				header.instance(registry, mapping),
-				builtin);
+	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
+		type.addOperator(operator, ref(mapper), priority);
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.member;
 
-import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 	}
 	
 	@Override
-	public String getInformalName() {
-		return "setter " + name;
-	}																																							
+	public String getCanonicalName() {
+		return definition.getFullName() + ":setter:" + name;
+	}
 
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addSetter(this, priority);
+	public FunctionalKind getKind() {
+		return FunctionalKind.SETTER;
 	}
 
 	@Override
-	public SetterMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return new SetterMember(
-				position,
-				definition,
-				modifiers,
-				name,
-				type.withGenericArguments(registry, mapping),
-				builtin);
+	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
+		members.addSetter(new SetterMemberRef(this, mapper.map(type)), priority);
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.member;
 
-import java.util.Map;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.statement.Statement;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 	}
 
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
+	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
 		
 	}
 
-	@Override
-	public IDefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return this;
-	}
-
 	@Override
 	public <T> T accept(MemberVisitor<T> visitor) {
 		return visitor.visitStaticInitializer(this);

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

 		
 		this.translator = translator;
 	}
-
-	@Override
-	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
-		return translator.translate(new CallTranslator.Call(position, target, instancedHeader, arguments, scope));
-	}
 }

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

 package org.openzen.zenscript.codemodel.member.builtin;
 
 import java.util.Map;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
-import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.IIteratorMember;
 import org.openzen.zenscript.codemodel.member.MemberVisitor;
+import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 	}
 
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addIterator(this, priority);
-	}
-
-	@Override
-	public IDefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return new ArrayIteratorKeyValues(type.withGenericArguments(registry, mapping));
+	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
+		members.addIterator(new IteratorMemberRef(this, mapper.map(loopVariableTypes)), priority);
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.member.builtin;
 
-import java.util.Map;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
-import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.IIteratorMember;
 import org.openzen.zenscript.codemodel.member.MemberVisitor;
+import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 	}
 
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addIterator(this, priority);
-	}
-
-	@Override
-	public IDefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return new ArrayIteratorValues(type.withGenericArguments(registry, mapping));
+	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
+		members.addIterator(new IteratorMemberRef(this, mapper.map(loopVariableTypes)), priority);
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.member.builtin;
 
-import java.util.Map;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
-import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.IIteratorMember;
 import org.openzen.zenscript.codemodel.member.MemberVisitor;
+import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 	}
 
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addIterator(this, priority);
-	}
-
-	@Override
-	public IDefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return new AssocIterator(type.withGenericArguments(registry, mapping));
+	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
+		type.addIterator(new IteratorMemberRef(this, mapper.map(loopVariableTypes)), priority);
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.member.builtin;
 
-import java.util.Map;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
-import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.IIteratorMember;
 import org.openzen.zenscript.codemodel.member.MemberVisitor;
+import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 	}
 
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addIterator(this, priority);
-	}
-
-	@Override
-	public IDefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return this; // only use for basic types
+	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
+		type.addIterator(new IteratorMemberRef(this, mapper.map(loopVariableTypes)), priority);
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.member.builtin;
 
-import java.util.Map;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
-import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.IIteratorMember;
 import org.openzen.zenscript.codemodel.member.MemberVisitor;
+import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 	}
 
 	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addIterator(this, priority);
-	}
-
-	@Override
-	public IDefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return this;
+	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
+		type.addIterator(new IteratorMemberRef(this, TYPES), priority);
 	}
 
 	@Override

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.member.ref;
+
+import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.expression.CastExpression;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.member.CasterMember;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class CasterMemberRef implements DefinitionMemberRef {
+	public final CasterMember member;
+	public final ITypeID toType;
+	
+	public CasterMemberRef(CasterMember member, ITypeID toType) {
+		this.member = member;
+		this.toType = toType;
+	}
+
+	@Override
+	public CodePosition getPosition() {
+		return member.position;
+	}
+
+	@Override
+	public String describe() {
+		return member.describe();
+	}
+
+	@Override
+	public <T> T getTag(Class<T> type) {
+		return member.getTag(type);
+	}
+	
+	public Expression cast(CodePosition position, Expression value, boolean implicit) {
+		return new CastExpression(position, value, this, implicit);
+	}
+	
+	public boolean isImplicit() {
+		return Modifiers.isImplicit(member.modifiers);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.member.ref;
+
+import org.openzen.zenscript.codemodel.member.ConstMember;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ConstMemberRef implements DefinitionMemberRef {
+	public final ConstMember member;
+	public final ITypeID type;
+	
+	public ConstMemberRef(ConstMember member, ITypeID type) {
+		this.member = member;
+		this.type = type;
+	}
+
+	@Override
+	public CodePosition getPosition() {
+		return member.position;
+	}
+
+	@Override
+	public String describe() {
+		return member.describe();
+	}
+
+	@Override
+	public <T> T getTag(Class<T> type) {
+		return member.getTag(type);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.member.ref;
+
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DefinitionMemberRef {
+	CodePosition getPosition();
+	
+	String describe();
+	
+	<T> T getTag(Class<T> type);
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.member.ref;
+
+import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class FieldMemberRef implements DefinitionMemberRef {
+	public final FieldMember member;
+	public final ITypeID type;
+	
+	public FieldMemberRef(FieldMember member, ITypeID type) {
+		this.member = member;
+		this.type = type;
+	}
+
+	@Override
+	public CodePosition getPosition() {
+		return member.position;
+	}
+
+	@Override
+	public String describe() {
+		return member.describe();
+	}
+
+	@Override
+	public <T> T getTag(Class<T> type) {
+		return member.getTag(type);
+	}
+	
+	public boolean isStatic() {
+		return member.isStatic();
+	}
+	
+	public boolean isFinal() {
+		return member.isFinal();
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.member.ref;
+
+import org.openzen.zenscript.codemodel.CompareType;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.CallExpression;
+import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
+import org.openzen.zenscript.codemodel.expression.CompareExpression;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.member.FunctionalKind;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.MethodMember;
+import org.openzen.zenscript.codemodel.member.OperatorMember;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.BuiltinID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class FunctionalMemberRef implements DefinitionMemberRef {
+	private final FunctionalMember target;
+	public final FunctionHeader header;
+	
+	public FunctionalMemberRef(FunctionalMember target, FunctionHeader header) {
+		this.target = target;
+		this.header = header;
+	}
+	
+	@Override
+	public CodePosition getPosition() {
+		return target.position;
+	}
+	
+	public String getCanonicalName() {
+		return target.getCanonicalName();
+	}
+	
+	@Override
+	public String describe() {
+		return target.describe();
+	}
+	
+	public <T> T getTag(Class<T> cls) {
+		return target.getTag(cls);
+	}
+	
+	public BuiltinID getBuiltin() {
+		return target.builtin;
+	}
+	
+	public boolean isStatic() {
+		return target.isStatic();
+	}
+	
+	public boolean isConstructor() {
+		return target.getKind() == FunctionalKind.CONSTRUCTOR;
+	}
+	
+	public boolean isOperator() {
+		return target.getKind() == FunctionalKind.OPERATOR;
+	}
+	
+	public OperatorType getOperator() {
+		return ((OperatorMember) target).operator;
+	}
+	
+	public String getMethodName() {
+		return ((MethodMember) target).name;
+	}
+	
+	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
+		return new CallExpression(position, target, this, instancedHeader, arguments, scope);
+	}
+	
+	public final Expression call(CodePosition position, Expression target, CallArguments arguments, TypeScope scope) {
+		return call(position, target, header, arguments, scope);
+	}
+	
+	public Expression callWithComparator(CodePosition position, CompareType comparison, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
+		return new CompareExpression(position, target, arguments.arguments[0], this, comparison, scope);
+	}
+	
+	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
+		return new CallStaticExpression(position, target, this, instancedHeader, arguments, scope);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.member.ref;
+
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.GetterExpression;
+import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
+import org.openzen.zenscript.codemodel.member.GetterMember;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class GetterMemberRef implements DefinitionMemberRef {
+	public final GetterMember member;
+	public final ITypeID type;
+	
+	public GetterMemberRef(GetterMember member, ITypeID type) {
+		this.member = member;
+		this.type = type;
+	}
+
+	@Override
+	public CodePosition getPosition() {
+		return member.position;
+	}
+
+	@Override
+	public String describe() {
+		return member.describe();
+	}
+
+	@Override
+	public <T> T getTag(Class<T> type) {
+		return member.getTag(type);
+	}
+	
+	public boolean isStatic() {
+		return member.isStatic();
+	}
+	
+	public Expression get(CodePosition position, Expression target) {
+		return new GetterExpression(position, target, this);
+	}
+	
+	public Expression getStatic(CodePosition position) {
+		return new StaticGetterExpression(position, this);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.member.ref;
+
+import org.openzen.zenscript.codemodel.member.ImplementationMember;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ImplementationMemberRef implements DefinitionMemberRef {
+	public final ImplementationMember member;
+	public final ITypeID implementsType;
+	
+	public ImplementationMemberRef(ImplementationMember member, ITypeID implementsType) {
+		this.member = member;
+		this.implementsType = implementsType;
+	}
+
+	@Override
+	public CodePosition getPosition() {
+		return member.position;
+	}
+
+	@Override
+	public String describe() {
+		return member.describe();
+	}
+
+	@Override
+	public <T> T getTag(Class<T> type) {
+		return member.getTag(type);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.member.ref;
+
+import org.openzen.zenscript.codemodel.member.IIteratorMember;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class IteratorMemberRef implements DefinitionMemberRef {
+	public final IIteratorMember target;
+	public final ITypeID[] types;
+	
+	public IteratorMemberRef(IIteratorMember target, ITypeID... types) {
+		this.target = target;
+		this.types = types;
+	}
+
+	@Override
+	public CodePosition getPosition() {
+		return target.getPosition();
+	}
+
+	@Override
+	public String describe() {
+		return target.describe();
+	}
+
+	@Override
+	public <T> T getTag(Class<T> type) {
+		return target.getTag(type);
+	}
+	
+	public int getLoopVariableCount() {
+		return types.length;
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.member.ref;
+
+import org.openzen.zenscript.codemodel.member.SetterMember;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SetterMemberRef implements DefinitionMemberRef {
+	public final SetterMember member;
+	public final ITypeID type;
+	
+	public SetterMemberRef(SetterMember member, ITypeID type) {
+		this.member = member;
+		this.type = type;
+	}
+
+	@Override
+	public CodePosition getPosition() {
+		return member.position;
+	}
+
+	@Override
+	public String describe() {
+		return member.describe();
+	}
+
+	@Override
+	public <T> T getTag(Class<T> type) {
+		return member.getTag(type);
+	}
+	
+	public boolean isStatic() {
+		return member.isStatic();
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.member.ref;
+
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.CallTranslator;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.member.OperatorMember;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class TranslatedOperatorMemberRef extends FunctionalMemberRef {
+	private final CallTranslator translator;
+	
+	public TranslatedOperatorMemberRef(OperatorMember member, FunctionHeader header, CallTranslator translator) {
+		super(member, header);
+		
+		this.translator = translator;
+	}
+
+	@Override
+	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
+		return translator.translate(new CallTranslator.Call(position, target, instancedHeader, arguments, scope));
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.member.ref;
+
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class VariantOptionRef {
+	private final VariantDefinition.Option option;
+	public final ITypeID[] types;
+	
+	public VariantOptionRef(VariantDefinition.Option option, ITypeID[] types) {
+		this.option = option;
+		this.types = types;
+	}
+	
+	public String getName() {
+		return option.name;
+	}
+	
+	public ITypeID getParameterType(int index) {
+		return types[index];
+	}
+	
+	public <T> T getTag(Class<T> type) {
+		return option.getTag(type);
+	}
+}

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

 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.LambdaClosure;
-import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 		this.allowStaticUsage = allowStaticMembers;
 	}
 	
-	public PartialMemberGroupExpression(CodePosition position, Expression target, FunctionalMember member, ITypeID[] typeArguments, boolean allowStaticMembers) {
+	public PartialMemberGroupExpression(CodePosition position, Expression target, String name, FunctionalMemberRef member, ITypeID[] typeArguments, boolean allowStaticMembers) {
 		this.position = position;
 		this.target = target;
-		this.group = DefinitionMemberGroup.forMethod(member);
+		this.group = DefinitionMemberGroup.forMethod(name, member);
 		this.typeArguments = typeArguments;
 		this.allowStaticUsage = allowStaticMembers;
 	}

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
  * @author Hoofdgebruiker
  */
 public class PartialStaticMemberGroupExpression implements IPartialExpression {
-	public static PartialStaticMemberGroupExpression forMethod(CodePosition position, ITypeID target, FunctionalMember method, ITypeID[] typeArguments) {
-		DefinitionMemberGroup group = new DefinitionMemberGroup(true, method.getInformalName());
+	public static PartialStaticMemberGroupExpression forMethod(CodePosition position, String name, ITypeID target, FunctionalMemberRef method, ITypeID[] typeArguments) {
+		DefinitionMemberGroup group = new DefinitionMemberGroup(true, name);
 		group.addMethod(method, TypeMemberPriority.SPECIFIED);
 		return new PartialStaticMemberGroupExpression(position, target, group, typeArguments);
 	}
 
 	@Override
 	public List<ITypeID>[] predictCallTypes(TypeScope scope, List<ITypeID> hints, int arguments) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		return group.predictCallTypes(scope, hints, arguments);
 	}
 	
 	@Override

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

 
 	@Override
 	public List<ITypeID>[] predictCallTypes(TypeScope scope, List<ITypeID> hints, int arguments) {
-		return new List[arguments];
+		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).predictCallTypes(scope, hints, arguments);
 	}
 	
 	@Override
 
 	@Override
 	public Expression call(CodePosition position, TypeScope scope, List<ITypeID> hints, CallArguments arguments) {
+		if (arguments.getNumberOfTypeArguments() == 0 && typeParameters.length > 0)
+			arguments = new CallArguments(typeParameters, arguments.arguments);
+		
 		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).callStatic(position, type, scope, arguments);
 	}
 

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

  */
 package org.openzen.zenscript.codemodel.scope;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.function.Function;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 		interfaceMembers.copyMembersTo(implementation.position, interfaceMembers, TypeMemberPriority.INHERITED);
 		
 		for (IDefinitionMember member : implementation.members) {
-			member.registerTo(members, TypeMemberPriority.SPECIFIED);
+			member.registerTo(members, TypeMemberPriority.SPECIFIED, new GenericMapper(outer.getTypeRegistry(), Collections.emptyMap()));
 		}
 	}
 

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

 import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
-import org.openzen.zenscript.codemodel.member.IIteratorMember;
+import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
 import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.shared.ConcatMap;
 
 public class ForeachStatement extends LoopStatement {
 	public final VarStatement[] loopVariables;
 	public final Expression list;
-	public final IIteratorMember iterator;
+	public final IteratorMemberRef iterator;
 	public Statement content;
 	
-	public ForeachStatement(CodePosition position, VarStatement[] loopVariables, IIteratorMember iterator, Expression list) {
+	public ForeachStatement(CodePosition position, VarStatement[] loopVariables, IteratorMemberRef iterator, Expression list) {
 		super(position, loopVariables[0].name, null); // TODO: thrown type
 		
 		this.loopVariables = loopVariables;

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

  */
 package org.openzen.zenscript.codemodel.type;
 
-import java.util.Map;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 /**
 	}
 	
 	@Override
-	public ArrayTypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
-		return registry.getArray(elementType.withGenericArguments(registry, arguments), dimension);
+	public ArrayTypeID instance(GenericMapper mapper) {
+		return mapper.registry.getArray(elementType.instance(mapper), dimension);
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.type;
 
-import java.util.Map;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 /**
 	}
 	
 	@Override
-	public AssocTypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
-		return registry.getAssociative(
-				keyType.withGenericArguments(registry, arguments),
-				valueType.withGenericArguments(registry, arguments));
+	public AssocTypeID instance(GenericMapper mapper) {
+		return mapper.registry.getAssociative(
+				keyType.instance(mapper),
+				valueType.instance(mapper));
 	}
 	
 	@Override

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

 
 import java.util.Collections;
 import java.util.List;
-import java.util.Map;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 /**
 	}
 	
 	@Override
-	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
+	public ITypeID instance(GenericMapper mapper) {
 		return this;
 	}
 	

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

  */
 package org.openzen.zenscript.codemodel.type;
 
-import java.util.Map;
 import java.util.Objects;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 	}
 	
 	@Override
-	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
-		return registry.getModified(TypeMembers.MODIFIER_CONST, baseType.withGenericArguments(registry, arguments));
+	public ITypeID instance(GenericMapper mapper) {
+		return mapper.registry.getModified(TypeMembers.MODIFIER_CONST, baseType.instance(mapper));
 	}
 	
 	@Override

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

 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 			for (int i = 0; i < typeParameters.length; i++)
 				genericSuperArguments.put(definition.genericParameters[i], typeParameters[i]);
 			
-			superType = definition.superType.withGenericArguments(registry, genericSuperArguments);
+			superType = definition.superType.instance(new GenericMapper(registry, genericSuperArguments));
 		}
 		this.superType = superType;
 	}
 	}
 	
 	@Override
-	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
+	public ITypeID instance(GenericMapper mapper) {
 		if (!hasTypeParameters() && outerTypeParameters.isEmpty())
 			return this;
 		
 			for (int i = 0; i < typeParameters.length; i++) {
 				// TODO: why was this line written like this?
 				//instancedArguments[i] = arguments.containsKey(definition.genericParameters[i]) ? arguments.get(definition.genericParameters[i]) : typeParameters[i].withGenericArguments(registry, arguments);
-				instancedArguments[i] = typeParameters[i].withGenericArguments(registry, arguments);
+				instancedArguments[i] = typeParameters[i].instance(mapper);
 			}
 		}
 		
 		} else {
 			instancedOuter = new HashMap<>();
 			for (Map.Entry<TypeParameter, ITypeID> entry : outerTypeParameters.entrySet())
-				instancedOuter.put(entry.getKey(), entry.getValue().withGenericArguments(registry, arguments));
+				instancedOuter.put(entry.getKey(), entry.getValue().instance(mapper));
 		}
-		return registry.getForDefinition(definition, instancedArguments, instancedOuter);
+		return mapper.registry.getForDefinition(definition, instancedArguments, instancedOuter);
 	}
 	
 	@Override

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

 package org.openzen.zenscript.codemodel.type;
 
 import java.util.Arrays;
-import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 /**
 	}
 	
 	@Override
-	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
-		return registry.getFunction(header.withGenericArguments(registry, arguments));
+	public ITypeID instance(GenericMapper mapper) {
+		return mapper.registry.getFunction(mapper.map(header));
 	}
 	
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.type;
 
-import java.util.Map;
 import java.util.Objects;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 /**
 	}
 
 	@Override
-	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
-		return registry.getGenericMap(value.withGenericArguments(registry, arguments), key);
+	public ITypeID instance(GenericMapper mapper) {
+		return mapper.registry.getGenericMap(value.instance(mapper), key);
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.type;
 
-import java.util.Map;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 
 	}
 	
 	@Override
-	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
-		return arguments.containsKey(parameter) ? arguments.get(parameter) : this;
+	public ITypeID instance(GenericMapper mapper) {
+		return mapper.map(this);
 	}
 
 	@Override

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

 package org.openzen.zenscript.codemodel.type;
 
 import java.util.Map;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 		return false;
 	}
 	
-	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments);
+	public ITypeID instance(GenericMapper mapper);
 	
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters);
 	

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

 
 import java.util.Arrays;
 import java.util.Map;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 /**
 	}
 
 	@Override
-	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
+	public ITypeID instance(GenericMapper mapper) {
 		ITypeID[] instanced = new ITypeID[iteratorTypes.length];
 		for (int i = 0; i < iteratorTypes.length; i++)
-			instanced[i] = iteratorTypes[i].withGenericArguments(registry, arguments);
-		return registry.getIterator(instanced);
+			instanced[i] = iteratorTypes[i].instance(mapper);
+		return mapper.registry.getIterator(instanced);
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.type;
 
-import java.util.Map;
 import java.util.Objects;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 	}
 	
 	@Override
-	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
-		return registry.getModified(TypeMembers.MODIFIER_OPTIONAL, baseType.withGenericArguments(registry, arguments));
+	public ITypeID instance(GenericMapper mapper) {
+		return mapper.registry.getModified(TypeMembers.MODIFIER_OPTIONAL, baseType.instance(mapper));
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.type;
 
-import java.util.Map;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 /**
 	}
 	
 	@Override
-	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
-		return registry.getRange(
-				from.withGenericArguments(registry, arguments),
-				to.withGenericArguments(registry, arguments));
+	public ITypeID instance(GenericMapper mapper) {
+		return mapper.registry.getRange(
+				from.instance(mapper),
+				to.instance(mapper));
 	}
 
 	@Override

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

 	GENERICMAP_GETOPTIONAL,
 	GENERICMAP_PUT,
 	GENERICMAP_CONTAINS,
+	GENERICMAP_SIZE,
+	GENERICMAP_ISEMPTY,
 	GENERICMAP_HASHCODE,
 	GENERICMAP_EQUALS,
 	GENERICMAP_NOTEQUALS,

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

 import org.openzen.zenscript.codemodel.expression.SetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.member.FieldMember;
-import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+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.ConstMember;
-import org.openzen.zenscript.codemodel.member.FunctionalMember;
-import org.openzen.zenscript.codemodel.member.GetterMember;
-import org.openzen.zenscript.codemodel.member.OperatorMember;
+import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
 import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.shared.CompileException;
 import org.openzen.zenscript.shared.CompileExceptionCode;
  * @author Hoofdgebruiker
  */
 public class DefinitionMemberGroup {
-	public static DefinitionMemberGroup forMethod(FunctionalMember member) {
-		DefinitionMemberGroup instance = new DefinitionMemberGroup(member.isStatic(), member.getInformalName());
+	public static DefinitionMemberGroup forMethod(String name, FunctionalMemberRef member) {
+		DefinitionMemberGroup instance = new DefinitionMemberGroup(member.isStatic(), name);
 		instance.addMethod(member, TypeMemberPriority.SPECIFIED);
 		return instance;
 	}
 	
-	private TypeMember<ConstMember> constant;
-	private TypeMember<FieldMember> field;
-	private TypeMember<GetterMember> getter;
-	private TypeMember<SetterMember> setter;
-	private final List<TypeMember<FunctionalMember>> methods = new ArrayList<>();
+	private TypeMember<ConstMemberRef> constant;
+	private TypeMember<FieldMemberRef> field;
+	private TypeMember<GetterMemberRef> getter;
+	private TypeMember<SetterMemberRef> setter;
+	private final List<TypeMember<FunctionalMemberRef>> methods = new ArrayList<>();
 	public final boolean isStatic;
 	public final String name;
 	
 		if (other.setter != null)
 			setSetter(other.setter.member, priority);
 		
-		for (TypeMember<FunctionalMember> method : other.methods)
+		for (TypeMember<FunctionalMemberRef> method : other.methods)
 			addMethod(method.member, priority);
 	}
 	
-	public FieldMember getField() {
+	public FieldMemberRef getField() {
 		return this.field == null ? null : this.field.member;
 	}
 	
-	public GetterMember getGetter() {
+	public GetterMemberRef getGetter() {
 		return this.getter == null ? null : this.getter.member;
 	}
 	
-	public SetterMember getSetter() {
+	public SetterMemberRef getSetter() {
 		return this.setter == null ? null : this.setter.member;
 	}
 	
 	}
 	
 	public boolean hasMethod(FunctionHeader header) {
-		for (TypeMember<FunctionalMember> method : methods) {
+		for (TypeMember<FunctionalMemberRef> method : methods) {
 			if (method.member.header.isEquivalentTo(header))
 				return true;
 		}
 		return false;
 	}
 	
-	public List<TypeMember<FunctionalMember>> getMethodMembers() {
+	public List<TypeMember<FunctionalMemberRef>> getMethodMembers() {
 		return this.methods;
 	}
 	
-	public void setConst(ConstMember constant, TypeMemberPriority priority) {
+	public void setConst(ConstMemberRef constant, TypeMemberPriority priority) {
 		if (this.constant != null) {
 			this.constant = this.constant.resolve(new TypeMember<>(priority, constant));
 		} else {
 		}
 	}
 	
-	public void setField(FieldMember field, TypeMemberPriority priority) {
+	public void setField(FieldMemberRef field, TypeMemberPriority priority) {
 		if (this.field != null) {
 			this.field = this.field.resolve(new TypeMember<>(priority, field));
 		} else {
 		}
 	}
 	
-	public void setGetter(GetterMember getter, TypeMemberPriority priority) {
+	public void setGetter(GetterMemberRef getter, TypeMemberPriority priority) {
 		if (this.getter != null) {
 			this.getter = this.getter.resolve(new TypeMember<>(priority, getter));
 		} else {
 		}
 	}
 	
-	public void setSetter(SetterMember setter, TypeMemberPriority priority) {
+	public void setSetter(SetterMemberRef setter, TypeMemberPriority priority) {
 		if (this.setter != null) {
 			this.setter = this.setter.resolve(new TypeMember<>(priority, setter));
 		} else {
 		}
 	}
 	
-	public void addMethod(FunctionalMember method, TypeMemberPriority priority) {
+	public void addMethod(FunctionalMemberRef method, TypeMemberPriority priority) {
 		for (int i = 0; i < methods.size(); i++) {
 			if (methods.get(i).member.header.isEquivalentTo(method.header)) {
 				methods.set(i, methods.get(i).resolve(new TypeMember<>(priority, method)));
 		for (int i = 0; i < result.length; i++)
 			result[i] = new ArrayList<>();
 		
-		for (TypeMember<FunctionalMember> method : methods) {
+		for (TypeMember<FunctionalMemberRef> method : methods) {
 			FunctionHeader header = method.member.header;
 			if (header.parameters.length != arguments)
 				continue;
 				for (ITypeID resultHint : typeHints) {
 					Map<TypeParameter, ITypeID> mapping = new HashMap<>();
 					if (header.returnType.inferTypeParameters(scope.getMemberCache(), resultHint, mapping)) {
-						header = header.withGenericArguments(scope.getTypeRegistry(), mapping);
+						header = header.withGenericArguments(new GenericMapper(scope.getTypeRegistry(), mapping));
 						break;
 					}
 				}
 	}
 	
 	public Expression call(CodePosition position, TypeScope scope, Expression target, CallArguments arguments, boolean allowStaticUsage) {
-		FunctionalMember method = selectMethod(position, scope, arguments, true, allowStaticUsage);
-		FunctionHeader instancedHeader = method.header.withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+		FunctionalMemberRef method = selectMethod(position, scope, arguments, true, allowStaticUsage);
+		FunctionHeader instancedHeader = method.header.fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
 		for (int i = 0; i < arguments.arguments.length; i++) {
 			arguments.arguments[i] = arguments.arguments[i].castImplicit(position, scope, instancedHeader.parameters[i].type);
 		}
 		if (methods.isEmpty())
 			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "There is no such operator");
 		
-		FunctionalMember method = methods.get(0).member;
-		if (!(method instanceof OperatorMember)) {
+		FunctionalMemberRef method = methods.get(0).member;
+		if (!method.isOperator()) {
 			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Member is not an operator");
 		}
-		OperatorMember operator = (OperatorMember) method;
-		return new PostCallExpression(position, target, operator, operator.header);
+		return new PostCallExpression(position, target, method, method.header);
 	}
 	
 	public Expression callWithComparator(
 			Expression target,
 			CallArguments arguments,
 			CompareType compareType) {
-		FunctionalMember method = selectMethod(position, scope, arguments, true, false);
-		FunctionHeader instancedHeader = method.header.withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+		FunctionalMemberRef method = selectMethod(position, scope, arguments, true, false);
+		FunctionHeader instancedHeader = method.header.fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
 		return method.callWithComparator(position, compareType, target, instancedHeader, arguments, scope);
 	}
 	
 	public Expression callStatic(CodePosition position, ITypeID target, TypeScope scope, CallArguments arguments) {
-		FunctionalMember method = selectMethod(position, scope, arguments, false, true);
-		FunctionHeader instancedHeader = method.header.withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+		FunctionalMemberRef method = selectMethod(position, scope, arguments, false, true);
+		FunctionHeader instancedHeader = method.header.fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
 		return method.callStatic(position, target, instancedHeader, arguments, scope);
 	}
 	
-	public FunctionalMember selectMethod(CodePosition position, TypeScope scope, CallArguments arguments, boolean allowNonStatic, boolean allowStatic) {
+	public FunctionalMemberRef selectMethod(CodePosition position, TypeScope scope, CallArguments arguments, boolean allowNonStatic, boolean allowStatic) {
 		// try to match with exact types
-		outer: for (TypeMember<FunctionalMember> method : methods) {
+		outer: for (TypeMember<FunctionalMemberRef> method : methods) {
 			if (!(method.member.isStatic() ? allowStatic : allowNonStatic))
 				continue;
 			
 				continue;
 			
 			if (arguments.typeArguments.length > 0) {
-				header = header.withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+				header = header.fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
 			}
 			
 			for (int i = 0; i < header.parameters.length; i++) {
 		}
 		
 		// try to match with approximate types
-		FunctionalMember selected = null;
-		outer: for (TypeMember<FunctionalMember> method : methods) {
+		FunctionalMemberRef selected = null;
+		outer: for (TypeMember<FunctionalMemberRef> method : methods) {
 			if (!(method.member.isStatic() ? allowStatic : allowNonStatic))
 				continue;
 			
 				continue;
 			
 			if (arguments.typeArguments.length > 0) {
-				header = header.withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+				header = header.fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
 			}
 			
 			for (int i = 0; i < header.parameters.length; i++) {
 				throw new CompileException(position, CompileExceptionCode.CALL_NO_VALID_METHOD, "This type has no " + name);
 			}
 			
-			outer: for (TypeMember<FunctionalMember> method : methods) {
+			outer: for (TypeMember<FunctionalMemberRef> method : methods) {
 				if (!(method.member.isStatic() ? allowStatic : allowNonStatic)) {
 					message.append(method.member.isStatic() ? "Method must not be static" : "Method must be static").append('\n');
 					continue;

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

  */
 package org.openzen.zenscript.codemodel.type.member;
 
-import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.shared.CompileException;
 import org.openzen.zenscript.shared.CompileExceptionCode;
 
  *
  * @author Hoofdgebruiker
  */
-public class TypeMember<T extends IDefinitionMember> {
+public class TypeMember<T extends DefinitionMemberRef> {
 	public final TypeMemberPriority priority;
 	public final T member;
 	

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

 import java.util.Map;
 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.OperatorType;
-import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.CheckNullExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
-import org.openzen.zenscript.codemodel.member.CallerMember;
-import org.openzen.zenscript.codemodel.member.CasterMember;
-import org.openzen.zenscript.codemodel.member.ConstMember;
-import org.openzen.zenscript.codemodel.member.ConstructorMember;
-import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
-import org.openzen.zenscript.codemodel.member.FieldMember;
-import org.openzen.zenscript.codemodel.member.FunctionalMember;
-import org.openzen.zenscript.codemodel.member.GetterMember;
-import org.openzen.zenscript.codemodel.member.IIteratorMember;
-import org.openzen.zenscript.codemodel.member.ImplementationMember;
 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.SetterMember;
+import org.openzen.zenscript.codemodel.member.ref.CasterMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.ImplementationMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialMemberGroupExpression;
 import org.openzen.zenscript.codemodel.partial.PartialStaticMemberGroupExpression;
 	private final LocalMemberCache cache;
 	public final ITypeID type;
 	
-	private final List<TypeMember<CasterMember>> casters = new ArrayList<>();
-	private final List<TypeMember<ImplementationMember>> implementations = new ArrayList<>();
-	private final List<TypeMember<IIteratorMember>> iterators = new ArrayList<>();
+	private final List<TypeMember<CasterMemberRef>> casters = new ArrayList<>();
+	private final List<TypeMember<ImplementationMemberRef>> implementations = new ArrayList<>();
+	private final List<TypeMember<IteratorMemberRef>> iterators = new ArrayList<>();
 	
 	private final Map<String, EnumConstantMember> enumMembers = new HashMap<>();
-	private final Map<String, VariantDefinition.Option> variantOptions = new HashMap<>();
+	private final Map<String, VariantOptionRef> variantOptions = new HashMap<>();
 	private final Map<String, DefinitionMemberGroup> members = new HashMap<>();
 	private final Map<String, InnerDefinition> innerTypes = new HashMap<>();
 	private final Map<OperatorType, DefinitionMemberGroup> operators = new HashMap<>();
 				return true;
 		}
 		
-		for (TypeMember<ImplementationMember> implementation : implementations) {
-			if (implementation.member.type.equals(other)) // TODO: for some reason duplicate types are generated
+		for (TypeMember<ImplementationMemberRef> implementation : implementations) {
+			if (implementation.member.implementsType.equals(other)) // TODO: for some reason duplicate types are generated
 				return true;
-			if (cache.get(implementation.member.type).extendsOrImplements(other))
+			if (cache.get(implementation.member.implementsType).extendsOrImplements(other))
 				return true;
 		}
 		
 		
 		for (Map.Entry<String, EnumConstantMember> entry : enumMembers.entrySet())
 			other.addEnumMember(entry.getValue(), priority);
-		for (Map.Entry<String, VariantDefinition.Option> entry : variantOptions.entrySet())
+		for (Map.Entry<String, VariantOptionRef> entry : variantOptions.entrySet())
 			other.addVariantOption(entry.getValue());
 		for (Map.Entry<String, DefinitionMemberGroup> entry : members.entrySet())
 			other.getOrCreateGroup(entry.getKey(), entry.getValue().isStatic).merge(position, entry.getValue(), priority);
 		return null;
 	}
 	
-	public void addConstructor(ConstructorMember constructor, TypeMemberPriority priority) {
+	public void addConstructor(FunctionalMemberRef constructor, TypeMemberPriority priority) {
 		getOrCreateGroup(OperatorType.CONSTRUCTOR).addMethod(constructor, priority);
 	}
 	
-	public void addConstructor(ConstructorMember constructor) {
+	public void addConstructor(FunctionalMemberRef constructor) {
 		getOrCreateGroup(OperatorType.CONSTRUCTOR).addMethod(constructor, TypeMemberPriority.SPECIFIED);
 	}
 	
-	public void addDestructor(DestructorMember destructor, TypeMemberPriority priority) {
+	public void addDestructor(FunctionalMemberRef destructor, TypeMemberPriority priority) {
 		getOrCreateGroup(OperatorType.DESTRUCTOR).addMethod(destructor, priority);
 	}
 	
-	public void addCaller(CallerMember caller, TypeMemberPriority priority) {
+	public void addCaller(FunctionalMemberRef caller, TypeMemberPriority priority) {
 		getOrCreateGroup(OperatorType.CALL).addMethod(caller, priority);
 	}
 	
-	public void addCaster(CasterMember caster) {
+	public void addCaster(CasterMemberRef caster) {
 		addCaster(caster, TypeMemberPriority.SPECIFIED);
 	}
 	
-	public void addCaster(CasterMember caster, TypeMemberPriority priority) {
+	public void addCaster(CasterMemberRef caster, TypeMemberPriority priority) {
 		for (int i = 0; i < casters.size(); i++) {
-			if (casters.get(i).member.getTargetType() == caster.toType) {
+			if (casters.get(i).member.toType == caster.toType) {
 				casters.set(i, casters.get(i).resolve(new TypeMember<>(priority, caster)));
 				return;
 			}
 		casters.add(new TypeMember<>(priority, caster));
 	}
 	
-	public void addConst(ConstMember member) {
-		DefinitionMemberGroup group = getOrCreateGroup(member.name, true);
+	public void addConst(ConstMemberRef member) {
+		DefinitionMemberGroup group = getOrCreateGroup(member.member.name, true);
 		group.setConst(member, TypeMemberPriority.SPECIFIED);
 	}
 	
-	public void addField(FieldMember member) {
+	public void addField(FieldMemberRef member) {
 		addField(member, TypeMemberPriority.SPECIFIED);
 	}
 	
-	public void addField(FieldMember member, TypeMemberPriority priority) {
-		DefinitionMemberGroup group = getOrCreateGroup(member.name, member.isStatic());
+	public void addField(FieldMemberRef member, TypeMemberPriority priority) {
+		DefinitionMemberGroup group = getOrCreateGroup(member.member.name, member.isStatic());
 		group.setField(member, priority);
 	}
 	
-	public void addGetter(GetterMember member) {
+	public void addGetter(GetterMemberRef member) {
 		addGetter(member, TypeMemberPriority.SPECIFIED);
 	}
 	
-	public void addGetter(GetterMember member, TypeMemberPriority priority) {
-		DefinitionMemberGroup group = getOrCreateGroup(member.name, member.isStatic());
+	public void addGetter(GetterMemberRef member, TypeMemberPriority priority) {
+		DefinitionMemberGroup group = getOrCreateGroup(member.member.name, member.isStatic());
 		group.setGetter(member, priority);
 	}
 	
-	public void addSetter(SetterMember member) {
+	public void addSetter(SetterMemberRef member) {
 		addSetter(member, TypeMemberPriority.SPECIFIED);
 	}
 	
-	public void addSetter(SetterMember member, TypeMemberPriority priority) {
-		DefinitionMemberGroup group = getOrCreateGroup(member.name, member.isStatic());
+	public void addSetter(SetterMemberRef member, TypeMemberPriority priority) {
+		DefinitionMemberGroup group = getOrCreateGroup(member.member.name, member.isStatic());
 		group.setSetter(member, priority);
 	}
 	
-	public void addMethod(MethodMember member) {
-		addMethod(member, TypeMemberPriority.SPECIFIED);
+	public void addMethod(String name, FunctionalMemberRef member) {
+		addMethod(name, member, TypeMemberPriority.SPECIFIED);
 	}
 	
-	public void addMethod(MethodMember member, TypeMemberPriority priority) {
-		DefinitionMemberGroup group = getOrCreateGroup(member.name, member.isStatic());
+	public void addMethod(String name, FunctionalMemberRef member, TypeMemberPriority priority) {
+		DefinitionMemberGroup group = getOrCreateGroup(name, member.isStatic());
 		group.addMethod(member, priority);
 	}
 	
-	public void addOperator(OperatorMember member) {
-		addOperator(member, TypeMemberPriority.SPECIFIED);
+	public void addOperator(OperatorType operator, FunctionalMemberRef member) {
+		addOperator(operator, member, TypeMemberPriority.SPECIFIED);
 	}
 	
 	public boolean hasOperator(OperatorType operator) {
 		return operators.containsKey(operator) && operators.get(operator).hasMethods();
 	}
 	
-	public void addOperator(OperatorMember member, TypeMemberPriority priority) {
-		DefinitionMemberGroup group = getOrCreateGroup(member.operator);
-		group.addMethod(member, priority);
-	}
-	
-	public void addOperator(OperatorType operator, FunctionalMember member, TypeMemberPriority priority) {
+	public void addOperator(OperatorType operator, FunctionalMemberRef member, TypeMemberPriority priority) {
 		DefinitionMemberGroup group = getOrCreateGroup(operator);
 		group.addMethod(member, priority);
 	}
 	
-	public void addVariantOption(VariantDefinition.Option option) {
-		variantOptions.put(option.name, option);
+	public void addVariantOption(VariantOptionRef option) {
+		variantOptions.put(option.getName(), option);
 	}
 	
-	public void addIterator(IIteratorMember iterator, TypeMemberPriority priority) {
+	public void addIterator(IteratorMemberRef iterator, TypeMemberPriority priority) {
 		for (int i = 0; i < iterators.size(); i++) {
 			if (iterators.get(i).member.getLoopVariableCount() == iterator.getLoopVariableCount()) {
 				iterators.set(i, iterators.get(i).resolve(new TypeMember<>(priority, iterator)));
 		iterators.add(new TypeMember<>(priority, iterator));
 	}
 	
-	public void addImplementation(ImplementationMember member, TypeMemberPriority priority) {
+	public void addImplementation(ImplementationMemberRef member, TypeMemberPriority priority) {
 		for (int i = 0; i < implementations.size(); i++) {
-			if (implementations.get(i).member.type == member.type) {
+			if (implementations.get(i).member.implementsType == member.implementsType) {
 				implementations.set(i, implementations.get(i).resolve(new TypeMember<>(priority, member)));
 				return;
 			}
 		return enumMembers.get(name);
 	}
 	
-	public VariantDefinition.Option getVariantOption(String name) {
+	public VariantOptionRef getVariantOption(String name) {
 		return variantOptions.get(name);
 	}
 	
 	public Expression compare(CodePosition position, TypeScope scope, CompareType operator, Expression left, Expression right) {
 		if (operator == CompareType.EQ) {
 			DefinitionMemberGroup equal = getOrCreateGroup(OperatorType.EQUALS);
-			for (TypeMember<FunctionalMember> member : equal.getMethodMembers()) {
+			for (TypeMember<FunctionalMemberRef> member : equal.getMethodMembers()) {
 				if (member.member.header.accepts(scope, right))
 					return equal.call(position, scope, left, new CallArguments(right), false);
 			}
 		} else if (operator == CompareType.NE) {
 			DefinitionMemberGroup equal = getOrCreateGroup(OperatorType.NOTEQUALS);
-			for (TypeMember<FunctionalMember> member : equal.getMethodMembers()) {
+			for (TypeMember<FunctionalMemberRef> member : equal.getMethodMembers()) {
 				if (member.member.header.accepts(scope, right)) {
 					return equal.call(position, scope, left, new CallArguments(right), false);
 				}
 		return members.call(position, scope, a, new CallArguments(b, c), false);
 	}
 	
-	public IIteratorMember getIterator(int variables) {
-		for (TypeMember<IIteratorMember> iterator : iterators)
+	public IteratorMemberRef getIterator(int variables) {
+		for (TypeMember<IteratorMemberRef> iterator : iterators)
 			if (iterator.member.getLoopVariableCount() == variables)
 				return iterator.member;
 		
 	}
 	
 	public ITypeID[] getLoopTypes(int variables) {
-		for (TypeMember<IIteratorMember> iterator : iterators)
+		for (TypeMember<IteratorMemberRef> iterator : iterators)
 			if (iterator.member.getLoopVariableCount() == variables)
-				return iterator.member.getLoopVariableTypes();
+				return iterator.member.types;
 		
 		return null;
 	}
 		if (type.isOptional() && type.unwrap() == toType)
 			return true;
 		
-		for (TypeMember<CasterMember> caster : casters) {
-			if (caster.member.isImplicit() && toType == caster.member.getTargetType())
+		for (TypeMember<CasterMemberRef> caster : casters) {
+			if (caster.member.isImplicit() && toType == caster.member.toType)
 				return true;
 		}
 		
 		if (canCastImplicit(toType))
 			return true;
 		
-		for (TypeMember<CasterMember> caster : casters) {
-			if (toType == caster.member.getTargetType())
+		for (TypeMember<CasterMemberRef> caster : casters) {
+			if (toType == caster.member.toType)
 				return true;
 		}
 		
 		if (type.isOptional() && type.unwrap() == toType)
 			return new CheckNullExpression(position, value);
 		
-		for (TypeMember<CasterMember> caster : casters) {
-			if (caster.member.isImplicit() && toType == caster.member.getTargetType())
+		for (TypeMember<CasterMemberRef> caster : casters) {
+			if (caster.member.isImplicit() && toType == caster.member.toType)
 				return caster.member.cast(position, value, implicit);
 		}
-		for (TypeMember<ImplementationMember> implementation : implementations) {
-			if (implementation.member.type.equals(toType))
+		for (TypeMember<ImplementationMemberRef> implementation : implementations) {
+			if (implementation.member.implementsType.equals(toType))
 				return new InterfaceCastExpression(position, value, toType);
 		}
 		if (extendsType(toType))
 		if (this.canCastImplicit(toType))
 			return castImplicit(position, value, toType, false);
 		
-		for (TypeMember<CasterMember> caster : casters)
-			if (toType == caster.member.getTargetType())
+		for (TypeMember<CasterMemberRef> caster : casters)
+			if (toType == caster.member.toType)
 				return caster.member.cast(position, value, false);
 		
 		throw new CompileException(position, CompileExceptionCode.INVALID_CAST, "Cannot cast " + toString() + " to " + toType + ", even explicitly");

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

 			throw new IllegalStateException("Module is not yet normalized");
 		
 		Validator validator = new Validator();
-		boolean isValid = true;
 		for (ScriptBlock script : scripts) {
-			isValid &= validator.validate(script);
+			validator.validate(script);
 		}
 		for (HighLevelDefinition definition : definitions.getAll()) {
-			isValid &= validator.validate(definition);
+			validator.validate(definition);
 		}
 		
 		for (ValidationLogEntry entry : validator.getLog()) {
 			System.out.println(entry.kind + " " + entry.position.toString() + ": " + entry.message);
 		}
-		state = isValid ? State.VALIDATED : State.INVALID;
-		if (!isValid && validator.getLog().isEmpty())
-			System.out.println("ERROR: module is invalid but no errors have been generated");
-		return isValid;
+		state = validator.hasErrors() ? State.INVALID : State.VALIDATED;
+		return !validator.hasErrors();
 	}
 	
 	public void compile(ZenCodeCompiler compiler) {

Constructor/libraries/collections/module.json

-{
-	"package": "collections",
-	"host": "universal"
-}

Constructor/libraries/collections/src/HashSet.zs

-export class HashSet<T> {
-	public implements Set<T> {
-		add(value as T) as bool;
-		remove(value as T) as bool;
-		
-		get size as int;
-		
-		in(value as T) as bool;
-		for(x as T);
-	}
-}

Constructor/libraries/collections/src/LinkedList.zs

-export class LinkedList<T> {
-	var first as Node?;
-	var last as Node?;
-	var size as int : get;
-	
-	public get empty as bool
-		=> first == null;
-	
-	public add(value as T) as void {
-		if first == null {
-			first = last = new Node(value);
-		} else {
-			val node = new Node(value);
-			last.next = node;
-			node.prev = last;
-			last = node;
-		}
-		size++;
-	}
-	
-	public clear() as void {
-		first = last = null;
-		size = 0;
-	}
-	
-	public [](index as int) as T {
-		var node = first;
-		while index > 0 {
-			if node == null
-				return panic<T>("index out of bounds");
-			
-			node = node.next;
-		}
-		
-		if node == null
-			return panic<T>("index out of bounds");
-		
-		return node.value;
-	}
-	
-	public implements Queue<T> {
-		poll() as T {
-			if first == null
-				return panic<T>("Cannot poll an empty queue");
-			
-			val result = first.value;
-			first = first.next;
-			if first == null
-				last = null;
-			else
-				first.prev = null;
-				
-			size--;
-		}
-		
-		peek() as T? {
-			return first.value;
-		}
-		
-		offer(value as T) as void
-			=> add(value);
-	}
-	
-	private struct Node {
-		var next as Node?;
-		var prev as Node?;
-		val value as T;
-		
-		this(value as T) {
-			this.value = value;
-		}
-	}
-}

Constructor/libraries/collections/src/NoSuchElementException.zs

-export class NoSuchElementException : Exception {
-	public this(message as string) {
-		super(message);
-	}
-}

Constructor/libraries/collections/src/Queue.zs

-export interface Queue<T> {
-	get empty as bool;
-	
-	poll() as T;
-	peek() as T;
-	push(value as T) as void;
-}

Constructor/libraries/collections/src/Set.zs

-export interface Set<T> {
-	add(value as T) as bool;
-	remove(value as T) as bool;
-	
-	get size as int;
-	
-	toArray();
-	toArray(comparator as function(a as T, b as T) as int);
-	
-	in(value as T) as bool;
-	for(x as T);
-}