- Added type aliasing

- Changed the way modified types are processed
- Added immutable keyword
- Added expression, statement and type normalization
- Improved naming of synthetic functions

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

 		output.append(definition.name);
 		FormattingUtils.formatTypeParameters(output, definition.genericParameters, typeFormatter);
 		output.append(" ");
-		if (definition.superType != null) {
+		if (definition.getSuperType() != null) {
 			output.append("extends ");
-			output.append(definition.superType.accept(typeFormatter));
+			output.append(definition.getSuperType().accept(typeFormatter));
 			output.append(" ");
 		}
 		if (settings.classBracketOnSameLine) {

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

 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ConstTypeID;
+import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.ITypeVisitor;
 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
-import org.openzen.zenscript.codemodel.type.OptionalTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import stdlib.Chars;
 
 /**
 	}
 
 	@Override
-	public String visitConst(ConstTypeID type) {
-		return "const " + type.accept(this);
-	}
-
-	@Override
-	public String visitOptional(OptionalTypeID optional) {
-		return optional.baseType.accept(this) + "?";
+	public String visitModified(ModifiedTypeID type) {
+		StringBuilder result = new StringBuilder();
+		if ((type.modifiers & TypeMembers.MODIFIER_CONST) > 0)
+			result.append("const ");
+		if ((type.modifiers & TypeMembers.MODIFIER_IMMUTABLE) > 0)
+			result.append("immutable ");
+		result.append(type.accept(this));
+		if ((type.modifiers & TypeMembers.MODIFIER_OPTIONAL) > 0)
+			result.append("?");
+		
+		return result.toString();
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 
 /**
 		hasUnknowns = hasUnknowns(parameters);
 	}
 	
+	public boolean isDenormalized() {
+		if (returnType.getNormalized() != returnType)
+			return true;
+		for (FunctionParameter parameter : parameters)
+			if (parameter.type.getNormalized() != parameter.type)
+				return true;
+		
+		return false;
+	}
+	
+	public FunctionHeader normalize(GlobalTypeRegistry registry) {
+		if (!isDenormalized())
+			return this;
+		
+		FunctionParameter[] normalizedParameters = new FunctionParameter[parameters.length];
+		for (int i = 0; i < normalizedParameters.length; i++)
+			normalizedParameters[i] = parameters[i].normalized(registry);
+		return new FunctionHeader(typeParameters, returnType.getNormalized(), thrownType == null ? null : thrownType.getNormalized(), normalizedParameters);
+	}
+	
 	public int getNumberOfTypeParameters() {
 		return typeParameters.length;
 	}
 		} else {
 			Map<TypeParameter, ITypeID> mapping = new HashMap<>();
 			for (int i = 0; i < overridden.typeParameters.length; i++)
-				mapping.put(overridden.typeParameters[i], new GenericTypeID(typeParameters[i]));
+				mapping.put(overridden.typeParameters[i], registry.getGeneric(typeParameters[i]));
 			mapper = new GenericMapper(registry, mapping);
 		}
 		

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

 import java.util.Objects;
 import org.openzen.zencode.shared.Taggable;
 import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 		this.variadic = variadic;
 	}
 	
+	public FunctionParameter normalized(GlobalTypeRegistry registry) {
+		FunctionParameter result = new FunctionParameter(type.getNormalized(), name, defaultValue, variadic);
+		result.annotations = this.annotations;
+		return result;
+	}
+	
 	public FunctionParameter withGenericArguments(GenericMapper mapper) {
 		ITypeID instanced = type.instance(mapper);
 		if (instanced == type)

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.Taggable;
 import org.openzen.zenscript.codemodel.annotations.DefinitionAnnotation;
+import org.openzen.zenscript.codemodel.definition.AliasDefinition;
 import org.openzen.zenscript.codemodel.definition.DefinitionVisitor;
+import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.ImplementationMember;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 	public final String name;
 	public final int modifiers;
 	public final List<IDefinitionMember> members = new ArrayList<>();
-	public TypeParameter[] genericParameters = null;
+	public TypeParameter[] genericParameters = TypeParameter.NONE;
 	public DefinitionAnnotation[] annotations = DefinitionAnnotation.NONE;
 	
 	public HighLevelDefinition outerDefinition;
-	public ITypeID superType;
+	private ITypeID superType;
+	
+	private boolean isDestructible = false;
 	
 	public HighLevelDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
 		this.position = position;
 			pkg.register(this);
 	}
 	
+	public HighLevelDefinition getOutermost() {
+		HighLevelDefinition result = this;
+		while (result.outerDefinition != null)
+			result = result.outerDefinition;
+		return result;
+	}
+	
 	public String getFullName() {
 		return pkg.fullName + '.' + name;
 	}
 	
+	public ITypeID getSuperType() {
+		return superType;
+	}
+	
+	public void setSuperType(ITypeID superType) {
+		this.superType = superType;
+		if (outerDefinition != null)
+			isDestructible |= outerDefinition.isDestructible;
+	}
+	
 	public int getNumberOfGenericParameters() {
 		return genericParameters == null ? 0 : genericParameters.length;
 	}
 		return outerDefinition != null;
 	}
 	
+	public boolean isInterface() {
+		return this instanceof InterfaceDefinition;
+	}
+	
+	public boolean isAlias() {
+		return this instanceof AliasDefinition;
+	}
+	
 	public void addMember(IDefinitionMember member) {
 		if (!members.contains(member))
 			members.add(member);
 	}
 	
+	public boolean isDestructible() {
+		boolean isDestructible = false;
+		for (IDefinitionMember member : members) {
+			if (member instanceof DestructorMember)
+				isDestructible = true;
+			if ((member instanceof FieldMember) && ((FieldMember)member).type.isDestructible())
+				isDestructible = true;
+			if ((member instanceof ImplementationMember) && ((ImplementationMember)member).type.isDestructible())
+				isDestructible = true;
+		}
+		return isDestructible;
+	}
+	
 	public void setTypeParameters(TypeParameter[] typeParameters) {
 		this.genericParameters = typeParameters;
 	}
 		return (modifiers & Modifiers.STATIC) > 0;
 	}
 	
+	public void normalize(TypeScope scope) {
+		for (IDefinitionMember member : members) {
+			member.normalize(scope);
+		}
+	}
+	
 	public abstract <T> T accept(DefinitionVisitor<T> visitor);
 }

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

 
 		@Override
 		public Void visitCustomIterator(CustomIteratorMember member) {
-			throw new UnsupportedOperationException("Not supported yet!");
+			return functional(member);
 		}
 
 		@Override

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 	public <T> T accept(DefinitionVisitor<T> visitor) {
 		return visitor.visitAlias(this);
 	}
+
+	@Override
+	public void normalize(TypeScope scope) {
+		// nothing to do
+	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 	public ClassDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
 		super(position, pkg, name, modifiers, outerDefinition);
 	}
-	
-	public void setSuperclass(ITypeID superclass) {
-		this.superType = superclass;
-	}
 
 	@Override
 	public <T> T accept(DefinitionVisitor<T> visitor) {

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

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
 				? this
 				: new AndAndExpression(position, tLeft, tRight);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new AndAndExpression(position, left.normalize(scope), right.normalize(scope));
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 
 /**
 		Expression[] tExpressions = Expression.transform(expressions, transformer);
 		return tExpressions == expressions ? this : new ArrayExpression(position, tExpressions, (ArrayTypeID)type);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		Expression[] normalized = new Expression[expressions.length];
+		for (int i = 0; i < normalized.length; i++)
+			normalized[i] = expressions[i].normalize(scope);
+		return new ArrayExpression(position, normalized, arrayType.getNormalized());
+	}
 }

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

 	public final CallArguments arguments;
 	public final FunctionHeader instancedHeader;
 	
-	public CallExpression(CodePosition position, Expression target, FunctionalMemberRef member, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
+	public CallExpression(CodePosition position, Expression target, FunctionalMemberRef member, FunctionHeader instancedHeader, CallArguments arguments) {
 		super(position, instancedHeader.returnType, multiThrow(position, arguments.arguments));
 		
 		this.target = target;
 		this.member = member;
-		this.arguments = scope == null ? arguments : arguments.normalize(position, scope, instancedHeader);
+		this.arguments = arguments;
 		this.instancedHeader = instancedHeader;
 	}
 	
 		CallArguments tArguments = arguments.transform(transformer);
 		return tTarget == target && tArguments == arguments
 				? this
-				: new CallExpression(position, tTarget, member, instancedHeader, tArguments, null);
+				: new CallExpression(position, tTarget, member, instancedHeader, tArguments);
 	}
 	
 	@Override
 				throw new UnsupportedOperationException("Cannot evaluate to a string constant!");
 		}
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new CallExpression(
+				position,
+				target.normalize(scope),
+				member,
+				instancedHeader.normalize(scope.getTypeRegistry()),
+				arguments.normalize(position, scope, instancedHeader));
+	}
 }

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

 	public final CallArguments arguments;
 	public final FunctionHeader instancedHeader;
 	
-	public CallStaticExpression(CodePosition position, ITypeID target, FunctionalMemberRef member, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
+	public CallStaticExpression(CodePosition position, ITypeID target, FunctionalMemberRef member, FunctionHeader instancedHeader, CallArguments arguments) {
 		super(position, instancedHeader.returnType, multiThrow(position, arguments.arguments));
 		
 		this.member = member;
 		this.target = target;
-		this.arguments = scope == null ? arguments : arguments.normalize(position, scope, instancedHeader);
+		this.arguments = arguments;
 		this.instancedHeader = instancedHeader;
 	}
 
 	@Override
 	public Expression transform(ExpressionTransformer transformer) {
 		CallArguments tArguments = arguments.transform(transformer);
-		return arguments == tArguments ? this : new CallStaticExpression(position, target, member, instancedHeader, tArguments, null);
+		return arguments == tArguments ? this : new CallStaticExpression(position, target, member, instancedHeader, tArguments);
+	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new CallStaticExpression(
+				position,
+				target.getNormalized(),
+				member,
+				instancedHeader.normalize(scope.getTypeRegistry()),
+				arguments.normalize(position, scope, instancedHeader));
 	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 /**
  *
 			return tValue == value ? this : new CapturedClosureExpression(position, (CapturedExpression)tValue, closure);
 		}
 	}
+
+	@Override
+	public CapturedExpression normalize(TypeScope scope) {
+		return new CapturedClosureExpression(position, value.normalize(scope), closure);
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 /**
  *
 		Expression tValue = transformer.transform(value);
 		return tValue == value ? this : new CapturedDirectExpression(position, closure, tValue);
 	}
+
+	@Override
+	public CapturedExpression normalize(TypeScope scope) {
+		return new CapturedDirectExpression(position, closure, value.normalize(scope));
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 		return result;
 	}
 	
+	@Override
+	public abstract CapturedExpression normalize(TypeScope scope);
+	
 	public abstract <T> T accept(CapturedExpressionVisitor<T> visitor);
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 
 /**
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public CapturedExpression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 /**
  *
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public CapturedExpression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public CapturedExpression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.member.ref.CasterMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 /**
  *
 		Expression tTarget = target.transform(transformer);
 		return target == tTarget ? this : new CastExpression(position, tTarget, member, isImplicit);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new CastExpression(position, target.normalize(scope), member, isImplicit);
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 /**
  * Converts a value from X? to X. Throws a NullPointerException if the value is null.
 		Expression tValue = transformer.transform(value);
 		return value == tValue ? this : new CheckNullExpression(position, tValue);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new CheckNullExpression(position, value.normalize(scope));
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 /**
  *
 		Expression tRight = right.transform(transformer);
 		return tLeft == left && tRight == right ? this : new CoalesceExpression(position, tLeft, tRight);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new CoalesceExpression(position, left.normalize(scope), right.normalize(scope));
+	}
 }

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

 		Expression tRight = right.transform(transformer);
 		return left == tLeft && right == tRight ? this : new CompareExpression(position, tLeft, tRight, operator, comparison, null);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new CompareExpression(position, left.normalize(scope), right.normalize(scope), operator, comparison, scope);
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 				? this
 				: new ConditionalExpression(position, tCondition, tIfThen, tIfElse, type);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new ConditionalExpression(position, condition.normalize(scope), ifThen.normalize(scope), ifElse.normalize(scope), type.getNormalized());
+	}
 }

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

 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 /**
  *
 	public final ConstMemberRef constant;
 	
 	public ConstExpression(CodePosition position, ConstMemberRef constant) {
-		super(position, constant.type, null);
+		super(position, constant.getType(), null);
 		
 		this.constant = constant;
 	}
 	public IDefinitionMember getMember() {
 		return constant.member;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
 	public String evaluateStringConstant() {
 		return value;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 	public final FunctionalMemberRef constructor;
 	public final CallArguments arguments;
 	
-	public ConstructorSuperCallExpression(CodePosition position, ITypeID type, FunctionalMemberRef constructor, CallArguments arguments, TypeScope scope) {
+	public ConstructorSuperCallExpression(CodePosition position, ITypeID type, FunctionalMemberRef constructor, CallArguments arguments) {
 		super(position, BasicTypeID.VOID, binaryThrow(position, constructor.header.thrownType, multiThrow(position, arguments.arguments)));
 		
 		this.objectType = type;
 		this.constructor = constructor;
-		this.arguments = scope == null ? arguments : arguments.normalize(position, scope, constructor.header);
+		this.arguments = arguments;
 	}
 
 	@Override
 	@Override
 	public Expression transform(ExpressionTransformer transformer) {
 		CallArguments tArguments = arguments.transform(transformer);
-		return tArguments == arguments ? this : new ConstructorSuperCallExpression(position, type, constructor, tArguments, null);
+		return tArguments == arguments ? this : new ConstructorSuperCallExpression(position, type, constructor, tArguments);
+	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new ConstructorSuperCallExpression(position, type.getNormalized(), constructor, arguments.normalize(position, scope, constructor.header));
 	}
 }

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

 	public final FunctionalMemberRef constructor;
 	public final CallArguments arguments;
 	
-	public ConstructorThisCallExpression(CodePosition position, ITypeID type, FunctionalMemberRef constructor, CallArguments arguments, TypeScope scope) {
+	public ConstructorThisCallExpression(CodePosition position, ITypeID type, FunctionalMemberRef constructor, CallArguments arguments) {
 		super(position, BasicTypeID.VOID, binaryThrow(position, constructor.header.thrownType, multiThrow(position, arguments.arguments)));
 		
 		this.objectType = type;
 		this.constructor = constructor;
-		this.arguments = scope == null ? arguments : arguments.normalize(position, scope, constructor.header);
+		this.arguments = arguments;
 	}
 
 	@Override
 	@Override
 	public Expression transform(ExpressionTransformer transformer) {
 		CallArguments tArguments = arguments.transform(transformer);
-		return tArguments == arguments ? this : new ConstructorThisCallExpression(position, type, constructor, tArguments, null);
+		return tArguments == arguments ? this : new ConstructorThisCallExpression(position, type, constructor, tArguments);
+	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new ConstructorThisCallExpression(position, type, constructor, arguments.normalize(position, scope, constructor.header));
 	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 	public Expression transform(ExpressionTransformer transformer) {
 		throw new UnsupportedOperationException("This is a dummy expression");
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 	public EnumConstantMember evaluateEnumConstant() {
 		return value;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 		if (type == null)
 			throw new NullPointerException();
 		if (type == BasicTypeID.UNDETERMINED)
-			throw new IllegalArgumentException("Cannot use undetermined type as expression type");
+			throw new IllegalArgumentException(position + ": Cannot use undetermined type as expression type");
 		
 		this.position = position;
-		this.type = type;
+		this.type = type.getNormalized();
 		this.thrownType = thrownType;
 	}
 	
 		});
 	}
 	
+	public abstract Expression normalize(TypeScope scope);
+	
 	@Override
 	public List<ITypeID> getAssignHints() {
 		return Collections.singletonList(type);

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

 				type,
 				member,
 				compiledArguments,
-				compiledArguments.getNumberOfTypeArguments() == 0 ? member.header : member.header.fillGenericArguments(scope.getTypeRegistry(), compiledArguments.typeArguments),
-				scope);
+				compiledArguments.getNumberOfTypeArguments() == 0 ? member.header : member.header.fillGenericArguments(scope.getTypeRegistry(), compiledArguments.typeArguments));
 	}
 	
 	public Expression not(Expression value) {

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

 import org.openzen.zencode.shared.ConcatMap;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 			return null;
 		}
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new FunctionExpression(position, (FunctionTypeID)type, closure, header, body.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class)));
+	}
 	
 	private static class ReturnExpressionTransformer implements ExpressionTransformer {
 		private final LambdaClosure closure;

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

 	public IDefinitionMember getMember() {
 		return field.member;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new GetFieldExpression(position, target.normalize(scope), field);
+	}
 }

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

 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 	public IDefinitionMember getMember() {
 		return field.member;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 /**
  *
 		Expression tTarget = target.transform(transformer);
 		return target == tTarget ? this : new GetterExpression(position, tTarget, getter);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new GetterExpression(position, target.normalize(scope), getter);
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 /**
  *
 		Expression tResolution = resolution.transform(transformer);
 		return tArguments == arguments && tResolution == resolution ? this : new GlobalCallExpression(position, name, tArguments, tResolution);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new GlobalCallExpression(position, name, arguments, resolution.normalize(scope));
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 /**
  *
 		Expression tResolution = resolution.transform(transformer);
 		return resolution == tResolution ? this : new GlobalExpression(position, name, resolution);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new GlobalExpression(position, name, resolution.normalize(scope));
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 		Expression tValue = value.transform(transformer);
 		return value == tValue ? this : new InterfaceCastExpression(position, tValue, type);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new InterfaceCastExpression(position, value.normalize(scope), type.getNormalized());
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 		Expression tValue = value.transform(transformer);
 		return tValue == value ? this : new IsExpression(position, tValue, type);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new IsExpression(position, value.normalize(scope), type.getNormalized());
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 		Expression tValue = value.transform(transformer);
 		return tValue == value ? this : new MakeConstExpression(position, tValue, type);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new MakeConstExpression(position, value.normalize(scope), type.getNormalized());
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 		Expression[] tValues = Expression.transform(values, transformer);
 		return tKeys == keys && tValues == values ? this : new MapExpression(position, tKeys, tValues, type);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		Expression[] normalizedKeys = new Expression[keys.length];
+		for (int i = 0; i < normalizedKeys.length; i++)
+			normalizedKeys[i] = keys[i].normalize(scope);
+		
+		Expression[] normalizedValues = new Expression[values.length];
+		for (int i = 0; i < normalizedValues.length; i++)
+			normalizedValues[i] = values[i].normalize(scope);
+		
+		return new MapExpression(position, normalizedKeys, normalizedValues, type.getNormalized());
+	}
 }

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

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.BreakStatement;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 		}
 		return unmodified && tValue == value ? this : new MatchExpression(position, tValue, type, tCases);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		Case[] normalizedCases = new Case[cases.length];
+		for (int i = 0; i < cases.length; i++)
+			normalizedCases[i] = cases[i].normalize(scope);
+		return new MatchExpression(position, value.normalize(scope), type, normalizedCases);
+	}
 	
 	public SwitchedMatch convertToSwitch(String tempVariable) {
 		VarStatement result = new VarStatement(position, tempVariable, type, null, false);
 			Expression tValue = value.transform(transformer);
 			return tValue == value ? this : new Case(key, tValue);
 		}
+		
+		public Case normalize(TypeScope scope) {
+			return new Case(key, value.normalize(scope));
+		}
 	}
 	
 	private static ITypeID getThrownType(CodePosition position, Case[] cases) {

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

 			FunctionalMemberRef constructor,
 			CallArguments arguments)
 	{
-		super(position, type, binaryThrow(position, constructor.header.thrownType, multiThrow(position, arguments.arguments)));
-		
-		this.constructor = constructor;
-		this.arguments = arguments;
-		this.instancedHeader = constructor.header;
+		this(position, type, constructor, arguments, constructor.header);
 	}
 	
 	public NewExpression(
 			ITypeID type,
 			FunctionalMemberRef constructor,
 			CallArguments arguments,
-			FunctionHeader instancedHeader,
-			TypeScope scope)
+			FunctionHeader instancedHeader)
 	{
 		super(position, type, binaryThrow(position, constructor.header.thrownType, multiThrow(position, arguments.arguments)));
 		
 		this.constructor = constructor;
-		this.arguments = scope == null ? arguments : arguments.normalize(position, scope, instancedHeader);
+		this.arguments = arguments;
 		this.instancedHeader = instancedHeader;
 	}
 
 	@Override
 	public Expression transform(ExpressionTransformer transformer) {
 		CallArguments tArguments = arguments.transform(transformer);
-		return tArguments == arguments ? this : new NewExpression(position, type, constructor, tArguments, instancedHeader, null);
+		return tArguments == arguments ? this : new NewExpression(position, type, constructor, tArguments, instancedHeader);
+	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new NewExpression(position, type.getNormalized(), constructor, arguments.normalize(position, scope, instancedHeader), instancedHeader);
 	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
 		Expression tRight = right.transform(transformer);
 		return tLeft == left && tRight == right ? this : new OrOrExpression(position, tLeft, tRight);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new OrOrExpression(position, left.normalize(scope), right.normalize(scope));
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 	public Expression transform(ExpressionTransformer transformer) {
 		return new PanicExpression(position, type, transformer.transform(value));
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new PanicExpression(position, type, value.normalize(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.ref.FunctionalMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 /**
  * Used for post-increment and post-decrement.
 		Expression tTarget = target.transform(transformer);
 		return target == tTarget ? this : new PostCallExpression(position, tTarget, member, instancedHeader);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new PostCallExpression(position, target.normalize(scope), member, instancedHeader.normalize(scope.getTypeRegistry()));
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 		Expression tTo = to.transform(transformer);
 		return tFrom == from && tTo == to ? this : new RangeExpression(position, type, tFrom, tTo, thrownType);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new RangeExpression(position, scope.getTypeRegistry(), from.normalize(scope), to.normalize(scope));
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
 		Expression tRight = right.transform(transformer);
 		return tLeft == left && tRight == right ? this : new SameObjectExpression(position, tLeft, tRight, inverted);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new SameObjectExpression(position, left.normalize(scope), right.normalize(scope), inverted);
+	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 /**
  *
 				? this
 				: new SetFieldExpression(position, tTarget, field, tValue);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new SetFieldExpression(position, target, field, value.normalize(scope));
+	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 /**
  *
 		Expression tValue = value.transform(transformer);
 		return tValue == value ? this : new SetFunctionParameterExpression(position, parameter, tValue);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new SetFunctionParameterExpression(position, parameter, value.normalize(scope));
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 
 /**
 		Expression tValue = value.transform(transformer);
 		return tValue == value ? this : new SetLocalVariableExpression(position, variable, tValue);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new SetLocalVariableExpression(position, variable, value.normalize(scope));
+	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 /**
  *
 		Expression tValue = value.transform(transformer);
 		return value == tValue ? this : new SetStaticFieldExpression(position, field, tValue);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new SetStaticFieldExpression(position, field, value.normalize(scope));
+	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 /**
  *
 		Expression tValue = value.transform(transformer);
 		return tTarget == target && tValue == value ? this : new SetterExpression(position, tTarget, setter, tValue);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new SetterExpression(position, target.normalize(scope), setter, value.normalize(scope));
+	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 /**
  *
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 /**
  *
 		Expression tValue = value.transform(transformer);
 		return tValue == value ? this : new StaticSetterExpression(position, setter, tValue);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new StaticSetterExpression(position, setter, value.normalize(scope));
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 		Expression tValue = value.transform(transformer);
 		return tValue == value ? this : new SupertypeCastExpression(position, tValue, type);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new SupertypeCastExpression(position, value.normalize(scope), type.getNormalized());
+	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return this;
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 		Expression tValue = transformer.transform(value);
 		return tValue == value ? this : new ThrowExpression(position, type, value);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new ThrowExpression(position, type, value.normalize(scope));
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 		Expression tValue = value.transform(transformer);
 		return tValue == value ? this : new TryConvertExpression(position, type, tValue);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new TryConvertExpression(position, type, value.normalize(scope));
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 		Expression tValue = value.transform(transformer);
 		return tValue == value ? this : new TryRethrowAsExceptionExpression(position, type, tValue, thrownType);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new TryRethrowAsExceptionExpression(position, type, value.normalize(scope), thrownType.getNormalized());
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 		Expression tValue = value.transform(transformer);
 		return tValue == value ? this : new TryRethrowAsResultExpression(position, type, tValue);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new TryRethrowAsResultExpression(position, type, value.normalize(scope));
+	}
 }

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

 		Expression[] tArguments = Expression.transform(arguments, transformer);
 		return tArguments == arguments ? this : new VariantValueExpression(position, type, option, tArguments);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		Expression[] normalized = new Expression[arguments.length];
+		for (int i = 0; i < normalized.length; i++)
+			normalized[i] = arguments[i].normalize(scope);
+		return new VariantValueExpression(position, type, option, normalized);
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 		Expression tValue = value.transform(transformer);
 		return tValue == value ? this : new WrapOptionalExpression(position, tValue, type);
 	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new WrapOptionalExpression(position, value.normalize(scope), type);
+	}
 }

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.member.ref.CasterMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.ITypeID;
  * @author Hoofdgebruiker
  */
 public class CasterMember extends FunctionalMember {
-	public final ITypeID toType;
+	public ITypeID toType;
 	public CasterMemberRef overrides;
 	
 	public CasterMember(
 	public CasterMemberRef getOverrides() {
 		return overrides;
 	}
+	
+	@Override
+	public void normalize(TypeScope scope) {
+		super.normalize(scope);
+		toType = toType.getNormalized();
+	}
 }

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

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 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 members, TypeMemberPriority priority, GenericMapper mapper) {
-		members.addConst(new ConstMemberRef(this, mapper.map(type)));
+		members.addConst(new ConstMemberRef(this, type, mapper));
 	}
 
 	@Override
 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
+
+	@Override
+	public void normalize(TypeScope scope) {
+		type = type.getNormalized();
+		value = value.normalize(scope);
+	}
 }

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

 package org.openzen.zenscript.codemodel.member;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
 import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
  *
  * @author Hoofdgebruiker
  */
-public class CustomIteratorMember extends DefinitionMember implements IIteratorMember {
+public class CustomIteratorMember extends FunctionalMember implements IIteratorMember {
 	private final ITypeID[] iteratorTypes;
 	public Statement body;
 	public IteratorMemberRef overrides;
 	
-	public CustomIteratorMember(CodePosition position, HighLevelDefinition definition, int modifiers, ITypeID[] iteratorTypes) {
-		super(position, definition, modifiers);
+	public CustomIteratorMember(CodePosition position, HighLevelDefinition definition, int modifiers, ITypeID[] iteratorTypes, GlobalTypeRegistry registry, BuiltinID builtin) {
+		super(position, definition, modifiers, createIteratorHeader(registry, iteratorTypes), builtin);
 		
 		this.iteratorTypes = iteratorTypes;
 	}
 	public void setContent(Statement body) {
 		this.body = body;
 	}
+	
+	@Override
+	public String getCanonicalName() {
+		return definition.getFullName() + ":iterator:" + iteratorTypes.length;
+	}
 
 	@Override
 	public int getLoopVariableCount() {
 	public DefinitionMemberRef getOverrides() {
 		return overrides;
 	}
+	
+	@Override
+	public FunctionalKind getKind() {
+		return FunctionalKind.ITERATOR;
+	}
+	
+	private static FunctionHeader createIteratorHeader(GlobalTypeRegistry registry, ITypeID[] iteratorTypes) {
+		return new FunctionHeader(registry.getIterator(iteratorTypes));
+	}
 }

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

 import org.openzen.zenscript.codemodel.expression.ThisExpression;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 			HighLevelDefinition definition,
 			int modifiers,
 			String name,
+			ITypeID thisType,
 			ITypeID type,
 			GlobalTypeRegistry registry,
 			int autoGetterAccess,
 		if (definition.genericParameters != null) {
 			parameters = new ITypeID[definition.genericParameters.length];
 			for (int i = 0; i < parameters.length; i++)
-				parameters[i] = new GenericTypeID(definition.genericParameters[i]);
+				parameters[i] = registry.getGeneric(definition.genericParameters[i]);
 		}
 		
 		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), new FieldMemberRef(this, myType))));
+			this.autoGetter.setBody(new ReturnStatement(position, new GetFieldExpression(position, new ThisExpression(position, thisType), new FieldMemberRef(this, thisType))));
 		} else {
 			this.autoGetter = null;
 		}
 		if (autoSetterAccess != 0) {
-			ITypeID myType = registry.getForDefinition(definition, parameters);
 			this.autoSetter = new SetterMember(position, definition, autoSetterAccess, name, type, null);
 			this.autoSetter.setBody(new ExpressionStatement(position, new SetFieldExpression(
 					position,
-					new ThisExpression(position, myType),
-					new FieldMemberRef(this, myType),
+					new ThisExpression(position, thisType),
+					new FieldMemberRef(this, thisType),
 					new GetFunctionParameterExpression(position, this.autoSetter.header.parameters[0]))));
 		} else {
 			this.autoSetter = null;
 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
+
+	@Override
+	public void normalize(TypeScope scope) {
+		type = type.getNormalized();
+		if (initializer != null)
+			initializer = initializer.normalize(scope);
+	}
 }

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

 	GETTER,
 	SETTER,
 	CALLER,
-	CASTER
+	CASTER,
+	ITERATOR
 }

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

 package org.openzen.zenscript.codemodel.member;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.ConcatMap;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 
 	public BuiltinID getBuiltin() {
 		return builtin;
 	}
+
+	@Override
+	public void normalize(TypeScope scope) {
+		header = header.normalize(scope.getTypeRegistry());
+		if (body != null)
+			body = body.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class));
+	}
 }

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 	<T> boolean hasTag(Class<T> tag);
 	
 	DefinitionMemberRef getOverrides();
+
+	public void normalize(TypeScope scope);
 }

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.ImplementationMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
+
+	@Override
+	public void normalize(TypeScope scope) {
+		for (IDefinitionMember member : members)
+			member.normalize(scope);
+	}
 }

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

 		this.outerTypeArguments = outerTypeArguments;
 	}
 	
-	public DefinitionTypeID instance(GlobalTypeRegistry registry, ITypeID[] typeArguments) {
-		return registry.getForDefinition(definition, typeArguments, outerTypeArguments);
+	public DefinitionTypeID instance(GlobalTypeRegistry registry, ITypeID[] typeArguments, DefinitionTypeID outer) {
+		return registry.getForDefinition(definition, typeArguments, outer);
 	}
 }

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 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 final HighLevelDefinition innerDefinition;
 	
 	public InnerDefinitionMember(CodePosition position, HighLevelDefinition outer, int modifiers, HighLevelDefinition definition) {
-		super(position, outer, modifiers);
+		super(position, outer, definition instanceof InterfaceDefinition ? modifiers | Modifiers.STATIC : modifiers);
 		
 		this.innerDefinition = definition;
 	}
 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
+
+	@Override
+	public void normalize(TypeScope scope) {
+		innerDefinition.normalize(scope);
+	}
 }

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

 package org.openzen.zenscript.codemodel.member;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.ConcatMap;
 import org.openzen.zencode.shared.Taggable;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
+
+	@Override
+	public void normalize(TypeScope scope) {
+		body = body.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class));
+	}
 }

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

 import org.openzen.zenscript.codemodel.member.MemberVisitor;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
  * @author Hoofdgebruiker
  */
 public class ArrayIteratorKeyValues extends Taggable implements IIteratorMember {
-	private final ArrayTypeID type;
+	private ArrayTypeID type;
 	private final ITypeID[] loopVariableTypes;
 	
 	public ArrayIteratorKeyValues(ArrayTypeID type) {
 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
+
+	@Override
+	public void normalize(TypeScope scope) {
+		
+	}
 }

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

 import org.openzen.zenscript.codemodel.member.MemberVisitor;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
+
+	@Override
+	public void normalize(TypeScope scope) {
+		
+	}
 }

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

 import org.openzen.zenscript.codemodel.member.MemberVisitor;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
+
+	@Override
+	public void normalize(TypeScope scope) {
+		
+	}
 }

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

 import org.openzen.zenscript.codemodel.member.MemberVisitor;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
+
+	@Override
+	public void normalize(TypeScope scope) {
+		
+	}
 }

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

 import org.openzen.zenscript.codemodel.member.MemberVisitor;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
+
+	@Override
+	public void normalize(TypeScope scope) {
+		
+	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.ConstMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
  */
 public class ConstMemberRef implements DefinitionMemberRef {
 	public final ConstMember member;
-	public final ITypeID type;
+	private ITypeID type;
+	private ITypeID originalType;
+	private final GenericMapper mapper;
 	
-	public ConstMemberRef(ConstMember member, ITypeID type) {
+	public ConstMemberRef(ConstMember member, ITypeID originalType, GenericMapper mapper) {
 		this.member = member;
-		this.type = type;
+		this.type = originalType.instance(mapper);
+		this.originalType = originalType;
+		this.mapper = mapper;
+	}
+	
+	public ITypeID getType() {
+		if (originalType != member.type) {
+			originalType = member.type;
+			type = originalType.instance(mapper);
+		}
+		return type;
 	}
 
 	@Override

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

 	}
 	
 	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
-		return new CallExpression(position, target, this, instancedHeader, arguments, scope);
+		return new CallExpression(position, target, this, instancedHeader, arguments);
 	}
 	
 	public final Expression call(CodePosition position, Expression target, CallArguments arguments, TypeScope scope) {
 	}
 	
 	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
-		return new CallStaticExpression(position, target, this, instancedHeader, arguments, scope);
+		return new CallStaticExpression(position, target, this, instancedHeader, arguments);
 	}
 }

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**