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

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 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.isConst())
+			result.append("const ");
+		if (type.isImmutable())
+			result.append("immutable ");
+		result.append(type.accept(this));
+		if (type.isOptional())
+			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;
 
 /**
 	private static final FunctionParameter[] NO_PARAMETERS = new FunctionParameter[0];
 	
 	public final TypeParameter[] typeParameters;
-	public final ITypeID returnType;
+	public ITypeID returnType;
 	public final FunctionParameter[] parameters;
 	public final ITypeID thrownType;
 	
 		
 		minParameters = parameterTypes.length;
 		maxParameters = parameterTypes.length;
-		hasUnknowns = hasUnknowns(parameterTypes);
+		hasUnknowns = hasUnknowns(parameterTypes, returnType);
 	}
 	
 	public FunctionHeader(ITypeID returnType, FunctionParameter... parameters) {
 		
 		minParameters = getMinParameters(parameters);
 		maxParameters = getMaxParameters(parameters);
-		hasUnknowns = hasUnknowns(parameters);
+		hasUnknowns = hasUnknowns(parameters, returnType);
 	}
 	
 	public FunctionHeader(TypeParameter[] genericParameters, ITypeID returnType, ITypeID thrownType, FunctionParameter... parameters) {
 		
 		minParameters = getMinParameters(parameters);
 		maxParameters = getMaxParameters(parameters);
-		hasUnknowns = hasUnknowns(parameters);
+		hasUnknowns = hasUnknowns(parameters, returnType);
+	}
+	
+	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() {
 	
 	public FunctionHeader inferFromOverride(GlobalTypeRegistry registry, FunctionHeader overridden) {
 		TypeParameter[] resultTypeParameters = typeParameters;
-		GenericMapper mapper;
-		if (resultTypeParameters == TypeParameter.NONE) {
-			resultTypeParameters = overridden.typeParameters;
-			mapper = new GenericMapper(registry, Collections.emptyMap());
-		} else {
-			Map<TypeParameter, ITypeID> mapping = new HashMap<>();
-			for (int i = 0; i < overridden.typeParameters.length; i++)
-				mapping.put(overridden.typeParameters[i], new GenericTypeID(typeParameters[i]));
-			mapper = new GenericMapper(registry, mapping);
-		}
-		
 		ITypeID resultReturnType = this.returnType;
 		if (resultReturnType == BasicTypeID.UNDETERMINED)
-			resultReturnType = overridden.returnType.instance(mapper);
+			resultReturnType = overridden.returnType;
 		
 		ITypeID resultThrownType = this.thrownType;
 		if (resultThrownType == null && overridden.thrownType != null)
-			resultThrownType = overridden.thrownType.instance(mapper);
+			resultThrownType = overridden.thrownType;
 		
 		FunctionParameter[] resultParameters = Arrays.copyOf(parameters, parameters.length);
 		for (int i = 0; i < resultParameters.length; i++) {
 			if (resultParameters[i].type == BasicTypeID.UNDETERMINED) {
 				FunctionParameter parameter = resultParameters[i];
 				FunctionParameter original = overridden.parameters[i];
-				resultParameters[i] = new FunctionParameter(original.type.instance(mapper), parameter.name, parameter.defaultValue, original.variadic);
+				resultParameters[i] = new FunctionParameter(original.type, parameter.name, parameter.defaultValue, original.variadic);
 			}
 		}
 		
 		if (arguments.arguments.length < minParameters || arguments.arguments.length > maxParameters)
 			return false;
 		
-		FunctionHeader header = fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+		FunctionHeader header = fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
 		for (int i = 0; i < header.parameters.length; i++) {
 			if (arguments.arguments[i].type != header.parameters[i].type)
 				return false;
 		if (arguments.arguments.length < minParameters || arguments.arguments.length > maxParameters)
 			return false;
 		
-		FunctionHeader header = fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+		FunctionHeader header = fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
 		for (int i = 0; i < header.parameters.length; i++) {
 			if (!scope.getTypeMembers(arguments.arguments[i].type).canCastImplicit(header.parameters[i].type))
 				return false;
 	}
 	
 	public FunctionHeader withGenericArguments(GenericMapper mapper) {
+		if (typeParameters.length > 0) {
+			Map<TypeParameter, ITypeID> innerMap = new HashMap<>();
+			for (TypeParameter parameter : typeParameters)
+				innerMap.put(parameter, mapper.registry.getGeneric(parameter));
+			
+			mapper = mapper.getInner(innerMap);
+		}
+		
 		ITypeID returnType = this.returnType.instance(mapper);
 		FunctionParameter[] parameters = new FunctionParameter[this.parameters.length];
 		for (int i = 0; i < parameters.length; i++) {
 		return new FunctionHeader(typeParameters, returnType, thrownType == null ? null : thrownType.instance(mapper), parameters);
 	}
 	
-	public FunctionHeader fillGenericArguments(GlobalTypeRegistry registry, ITypeID[] arguments) {
+	public FunctionHeader fillGenericArguments(GlobalTypeRegistry registry, ITypeID[] arguments, GenericMapper typeParameterMapping) {
 		if (arguments == null || arguments.length == 0)
 			return this;
 		
 		Map<TypeParameter, ITypeID> typeArguments = new HashMap<>();
 		for (int i = 0; i < typeParameters.length; i++)
 			typeArguments.put(typeParameters[i], arguments[i]);
-		GenericMapper mapper = new GenericMapper(registry, typeArguments);
+		GenericMapper mapper = typeParameterMapping.getInner(typeArguments);
 		
 		ITypeID returnType = this.returnType.instance(mapper);
 		FunctionParameter[] parameters = new FunctionParameter[this.parameters.length];
 		return parameters[parameters.length - 1].variadic ? Integer.MAX_VALUE : parameters.length;
 	}
 	
-	private static boolean hasUnknowns(ITypeID[] types) {
+	private static boolean hasUnknowns(ITypeID[] types, ITypeID returnType) {
+		if (returnType == BasicTypeID.UNDETERMINED)
+			return true;
+		
 		for (ITypeID type : types)
 			if (type == BasicTypeID.UNDETERMINED)
 				return true;
 		return false;
 	}
 	
-	private static boolean hasUnknowns(FunctionParameter[] parameters) {
+	private static boolean hasUnknowns(FunctionParameter[] parameters, ITypeID returnType) {
+		if (returnType == BasicTypeID.UNDETERMINED)
+			return true;
+		
 		for (FunctionParameter parameter : parameters)
 			if (parameter.type == BasicTypeID.UNDETERMINED)
 				return true;

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;
 
 /**
 	public Annotation[] annotations;
 	public final ITypeID type;
 	public final String name;
-	public final Expression defaultValue;
+	public Expression defaultValue;
 	public final boolean variadic;
 	
 	public FunctionParameter(ITypeID type) {
 		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/GenericMapper.java

  */
 package org.openzen.zenscript.codemodel;
 
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
  * @author Hoofdgebruiker
  */
 public class GenericMapper {
+	public static final GenericMapper EMPTY = new GenericMapper(null, Collections.emptyMap());
+	
 	public final GlobalTypeRegistry registry;
 	private final Map<TypeParameter, ITypeID> mapping;
 	
 	}
 	
 	public ITypeID map(GenericTypeID type) {
+		if (!mapping.containsKey(type.parameter))
+			throw new IllegalStateException("No mapping found for type " + type);
+		
 		return mapping.containsKey(type.parameter) ? mapping.get(type.parameter) : type;
 	}
 	
 	public FunctionHeader map(FunctionHeader original) {
 		return mapping.isEmpty() ? original : original.withGenericArguments(this);
 	}
+	
+	public GenericMapper getInner(Map<TypeParameter, ITypeID> mapping) {
+		Map<TypeParameter, ITypeID> resultMap = new HashMap<>(this.mapping);
+		resultMap.putAll(mapping);
+		return new GenericMapper(registry, resultMap);
+	}
+	
+	public GenericMapper getInner(GlobalTypeRegistry registry, TypeParameter[] parameters) {
+		Map<TypeParameter, ITypeID> resultMap = new HashMap<>(this.mapping);
+		for (TypeParameter parameter : parameters)
+			resultMap.put(parameter, registry.getGeneric(parameter));
+		return new GenericMapper(registry, resultMap);
+	}
+	
+	@Override
+	public String toString() {
+		if (mapping.isEmpty())
+			return "{}";
+		
+		StringBuilder result = new StringBuilder();
+		result.append('{');
+		boolean first = true;
+		for (Map.Entry<TypeParameter, ITypeID> entry : mapping.entrySet()) {
+			if (first) {
+				first = false;
+			} else {
+				result.append(", ");
+			}
+			result.append(entry.getKey().toString()).append(": ").append(entry.getValue());
+		}
+		result.append('}');
+		return result.toString();
+	}
 }

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.member.InnerDefinitionMember;
+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);
+
+	public HighLevelDefinition getInnerType(String name) {
+		for (IDefinitionMember member : members) {
+			if (member instanceof InnerDefinitionMember) {
+				InnerDefinitionMember inner = (InnerDefinitionMember)member;
+				if (inner.innerDefinition.name.equals(name))
+					return inner.innerDefinition;
+			}
+		}
+		
+		return null;
+	}
 }

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.ModuleProcessor;
-import org.openzen.zenscript.codemodel.PackageDefinitions;
 import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 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.SetterMember;
 import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.scope.DefinitionScope;
 import org.openzen.zenscript.codemodel.scope.FileScope;
 import org.openzen.zenscript.codemodel.scope.FunctionScope;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class AnnotationProcessor implements ModuleProcessor {
-	private final ZSPackage rootPackage;
-	private final PackageDefinitions packageDefinitions;
-	private final GlobalTypeRegistry globalRegistry;
+	private final TypeResolutionContext context;
 	private final List<ExpansionDefinition> expansions;
-	private final List<AnnotationDefinition> annotations;
 	
-	public AnnotationProcessor(
-			ZSPackage rootPackage,
-			PackageDefinitions packageDefinitions,
-			GlobalTypeRegistry globalRegistry,
-			List<ExpansionDefinition> expansions,
-			List<AnnotationDefinition> annotations) {
-		this.rootPackage = rootPackage;
-		this.packageDefinitions = packageDefinitions;
-		this.globalRegistry = globalRegistry;
+	public AnnotationProcessor(TypeResolutionContext context, List<ExpansionDefinition> expansions) {
+		this.context = context;
 		this.expansions = expansions;
-		this.annotations = annotations;
 	}
 	
 	@Override
 	public ScriptBlock process(ScriptBlock block) {
-		FileScope fileScope = new FileScope(rootPackage, packageDefinitions, globalRegistry, expansions, new HashMap<>(), annotations);
+		FileScope fileScope = new FileScope(context, expansions, new HashMap<>(), member -> {});
 		StatementScope scope = new GlobalScriptScope(fileScope);
 		List<Statement> transformed = new ArrayList<>();
 		boolean unchanged = true;
 	
 	@Override
 	public void process(HighLevelDefinition definition) {
-		FileScope fileScope = new FileScope(rootPackage, packageDefinitions, globalRegistry, expansions, new HashMap<>(), annotations);
+		FileScope fileScope = new FileScope(context, expansions, new HashMap<>(), member -> {});
 		DefinitionScope scope = new DefinitionScope(fileScope, definition);
 		for (DefinitionAnnotation annotation : definition.annotations) {
 			annotation.apply(definition, scope);
 
 		@Override
 		public Void visitCustomIterator(CustomIteratorMember member) {
-			throw new UnsupportedOperationException("Not supported yet!");
+			return functional(member);
 		}
 
 		@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/CompilingPackage.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.context;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class CompilingPackage {
+	private final Map<String, CompilingPackage> packages = new HashMap<>();
+	private final Map<String, CompilingType> types = new HashMap<>();
+	
+	public void addPackage(String name, CompilingPackage package_) {
+		packages.put(name, package_);
+	}
+	
+	public void addType(String name, CompilingType type) {
+		types.put(name, type);
+	}
+	
+	public HighLevelDefinition getImport(TypeResolutionContext context, List<String> name) {
+		return getImport(context, name, 0);
+	}
+	
+	private HighLevelDefinition getImport(TypeResolutionContext context, List<String> name, int index) {
+		if (packages.containsKey(name.get(index)))
+			return packages.get(name.get(index)).getImport(context, name, index + 1);
+		if (types.containsKey(name.get(index)))
+			return getImportType(context, types.get(name.get(index)), name, index + 1);
+		
+		return null;
+	}
+	
+	private HighLevelDefinition getImportType(TypeResolutionContext context, CompilingType type, List<String> name, int index) {
+		if (index == name.size())
+			return type.load(context);
+		
+		return getImportType(context, type.getInner(name.get(index)), name, index + 1);
+	}
+	
+	public ITypeID getType(TypeResolutionContext context, List<GenericName> name) {
+		return getType(context, name, 0);
+	}
+	
+	private ITypeID getType(TypeResolutionContext context, List<GenericName> name, int index) {
+		if (index == name.size())
+			return null;
+		
+		if (packages.containsKey(name.get(index).name))
+			return packages.get(name.get(index)).getType(context, name, index + 1);
+		
+		if (types.containsKey(name.get(index).name)) {
+			CompilingType type = types.get(name.get(index).name);
+			DefinitionTypeID result = context.getTypeRegistry().getForDefinition(type.load(context), name.get(index).arguments);
+			return getInner(context, name, index + 1, type, result);
+		}
+		
+		return null;
+	}
+	
+	private ITypeID getInner(TypeResolutionContext context, List<GenericName> name, int index, CompilingType type, DefinitionTypeID result) {
+		if (index == name.size())
+			return result;
+		
+		CompilingType innerType = type.getInner(name.get(index).name);
+		if (innerType == null)
+			return null;
+		
+		DefinitionTypeID innerResult = context.getTypeRegistry().getForDefinition(innerType.load(context), name.get(index).arguments, result);
+		return getInner(context, name, index + 1, innerType, innerResult);
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/CompilingType.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.context;
+
+import java.util.List;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.GenericName;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface CompilingType {
+	CompilingType getInner(String name);
+	
+	HighLevelDefinition load(TypeResolutionContext context);
+	
+	default DefinitionTypeID getInnerType(TypeResolutionContext context, List<GenericName> name, int index, DefinitionTypeID outer) {
+		DefinitionTypeID type = context.getTypeRegistry().getForDefinition(load(context), name.get(index).arguments, outer);
+		index++;
+		if (index == name.size())
+			return type;
+		
+		CompilingType innerType = getInner(name.get(index).name);
+		if (innerType == null)
+			return null;
+		
+		return innerType.getInnerType(context, name, index, type);
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/FileResolutionContext.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.context;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
+import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class FileResolutionContext implements TypeResolutionContext {
+	private final ModuleTypeResolutionContext module;
+	private final Map<String, HighLevelDefinition> imports = new HashMap<>();
+	
+	public FileResolutionContext(ModuleTypeResolutionContext module) {
+		this.module = module;
+	}
+	
+	public void addImport(String name, HighLevelDefinition definition) {
+		imports.put(name, definition);
+	}
+
+	@Override
+	public GlobalTypeRegistry getTypeRegistry() {
+		return module.getTypeRegistry();
+	}
+
+	@Override
+	public AnnotationDefinition getAnnotation(String name) {
+		return module.getAnnotation(name);
+	}
+
+	@Override
+	public ITypeID getType(CodePosition position, List<GenericName> name) {
+		if (imports.containsKey(name.get(0).name)) {
+			return GenericName.getInnerType(
+					getTypeRegistry(),
+					getTypeRegistry().getForDefinition(imports.get(name.get(0).name), name.get(0).arguments),
+					name,
+					1);
+		}
+		
+		return module.getType(position, name);
+	}
+
+	@Override
+	public ITypeID getThisType() {
+		return null;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/LocalTypeResolutionContext.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.context;
+
+import java.util.List;
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class LocalTypeResolutionContext implements TypeResolutionContext {
+	private final TypeResolutionContext outer;
+	private final CompilingType type;
+	private final TypeParameter[] parameters;
+	
+	public LocalTypeResolutionContext(TypeResolutionContext outer, CompilingType type, TypeParameter[] parameters) {
+		this.outer = outer;
+		this.type = type;
+		this.parameters = parameters;
+	}
+
+	@Override
+	public GlobalTypeRegistry getTypeRegistry() {
+		return outer.getTypeRegistry();
+	}
+
+	@Override
+	public AnnotationDefinition getAnnotation(String name) {
+		return outer.getAnnotation(name);
+	}
+
+	@Override
+	public ITypeID getType(CodePosition position, List<GenericName> name) {
+		if (type != null) {
+			CompilingType compiling = type.getInner(name.get(0).name);
+			if (compiling != null) {
+				DefinitionTypeID outer = getTypeRegistry().getForMyDefinition(type.load(this));
+				return compiling.getInnerType(this, name, 0, outer);
+			}
+		}
+		
+		if (name.size() == 1 && name.get(0).hasNoArguments()) {
+			for (TypeParameter parameter : parameters)
+				if (parameter.name.equals(name.get(0).name))
+					return getTypeRegistry().getGeneric(parameter);
+		}
+		
+		return outer.getType(position, name);
+	}
+	
+	@Override
+	public ITypeID getThisType() {
+		return type == null ? null : getTypeRegistry().getForMyDefinition(type.load(this));
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/ModuleTypeResolutionContext.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.context;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ISymbol;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ModuleTypeResolutionContext implements TypeResolutionContext {
+	private final GlobalTypeRegistry registry;
+	private final Map<String, AnnotationDefinition> annotations = new HashMap<>();
+	private final Map<String, ISymbol> globals;
+	private final ZSPackage rootPackage;
+	
+	private final CompilingPackage rootCompiling;
+	
+	public ModuleTypeResolutionContext(
+			GlobalTypeRegistry registry,
+			AnnotationDefinition[] annotations,
+			ZSPackage rootPackage,
+			CompilingPackage rootCompiling,
+			Map<String, ISymbol> globals)
+	{
+		this.registry = registry;
+		this.rootPackage = rootPackage;
+		this.rootCompiling = rootCompiling;
+		this.globals = globals;
+		
+		for (AnnotationDefinition annotation : annotations)
+			this.annotations.put(annotation.getAnnotationName(), annotation);
+	}
+	
+	@Override
+	public GlobalTypeRegistry getTypeRegistry() {
+		return registry;
+	}
+	
+	@Override
+	public AnnotationDefinition getAnnotation(String name) {
+		return annotations.get(name);
+	}
+
+	@Override
+	public ITypeID getType(CodePosition position, List<GenericName> name) {
+		if (rootCompiling != null) {
+			ITypeID compiling = rootCompiling.getType(this, name);
+			if (compiling != null)
+				return compiling;
+		}
+		
+		if (name.size() == 1 && globals.containsKey(name.get(0).name))
+			return globals.get(name.get(0).name).getType(position, this, name.get(0).arguments);
+		
+		return rootPackage.getType(position, this, name);
+	}
+	
+	@Override
+	public ITypeID getThisType() {
+		return null;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/TypeResolutionContext.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.context;
+
+import java.util.List;
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
+import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface TypeResolutionContext {
+	GlobalTypeRegistry getTypeRegistry();
+	
+	AnnotationDefinition getAnnotation(String name);
+	
+	ITypeID getType(CodePosition position, List<GenericName> name);
+	
+	ITypeID getThisType();
+}

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.Modifiers;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 	}
 	
 	public void setType(ITypeID type) {
+		if (type == null)
+			throw new NullPointerException("type cannot be null!");
+		
 		this.type = type;
 	}
+	
+	@Override
+	public boolean isStatic() {
+		return true;
+	}
 
 	@Override
 	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/FunctionDefinition.java

 
 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.Modifiers;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 	public void setHeader(FunctionHeader header) {
 		this.header = header;
 		addMember(caller = new CallerMember(position, this, modifiers | Modifiers.STATIC, header, null));
-		callerGroup.addMethod(new FunctionalMemberRef(caller, caller.header), TypeMemberPriority.SPECIFIED);
+		callerGroup.addMethod(new FunctionalMemberRef(caller, GenericMapper.EMPTY), TypeMemberPriority.SPECIFIED);
 	}
 	
 	public void setCode(Statement statement) {

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

  * @author Hoofdgebruiker
  */
 public class InterfaceDefinition extends HighLevelDefinition {
-	private final List<ITypeID> baseInterfaces = new ArrayList<>();
+	public final List<ITypeID> baseInterfaces = new ArrayList<>();
 	
 	public InterfaceDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
 		super(position, pkg, name, modifiers, outerDefinition);
 	public void addBaseInterface(ITypeID baseInterface) {
 		baseInterfaces.add(baseInterface);
 	}
+	
+	@Override
+	public boolean isStatic() {
+		return true;
+	}
 
 	@Override
 	public <T> T accept(DefinitionVisitor<T> visitor) {

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

 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialPackageExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 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.scope.TypeScope;
 
 /**
  *
 		return null;
 	}
 	
-	public ITypeID getType(CodePosition position, TypeScope scope, List<GenericName> nameParts) {
-		return getType(position, scope, nameParts, 0);
+	public ITypeID getType(CodePosition position, TypeResolutionContext context, List<GenericName> nameParts) {
+		return getType(position, context, nameParts, 0);
 	}
 	
-	public ITypeID getType(CodePosition position, TypeScope scope, GenericName name) {
+	public ITypeID getType(CodePosition position, TypeResolutionContext context, GenericName name) {
 		if (types.containsKey(name.name)) {
-			return scope.getTypeRegistry().getForDefinition(types.get(name.name), name.arguments);
+			return context.getTypeRegistry().getForDefinition(types.get(name.name), name.arguments);
 		}
 		
 		return null;
 	}
 	
-	private ITypeID getType(CodePosition position, TypeScope scope, List<GenericName> nameParts, int depth) {
+	private ITypeID getType(CodePosition position, TypeResolutionContext context, List<GenericName> nameParts, int depth) {
 		if (depth >= nameParts.size())
 			return null;
 		
 		GenericName name = nameParts.get(depth);
 		if (subPackages.containsKey(name.name) && name.hasNoArguments())
-			return subPackages.get(name.name).getType(position, scope, nameParts, depth + 1);
+			return subPackages.get(name.name).getType(position, context, nameParts, depth + 1);
 		
 		if (types.containsKey(name.name)) {
-			ITypeID type = scope.getTypeRegistry().getForDefinition(types.get(name.name), name.arguments);
-			depth++;
-			while (depth < nameParts.size()) {
-				GenericName innerName = nameParts.get(depth++);
-				type = scope.getTypeMembers(type).getInnerType(position, innerName);
-				if (type == null)
-					return null;
-			}
-			
-			return type;
+			DefinitionTypeID type = context.getTypeRegistry().getForDefinition(types.get(name.name), name.arguments);
+			return GenericName.getInnerType(context.getTypeRegistry(), type, nameParts, depth + 1);
 		}
 		
 		return null;

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.
 	public final Expression value;
 	
 	public CheckNullExpression(CodePosition position, Expression value) {
-		super(position, value.type.unwrap(), value.thrownType);
+		super(position, value.type.withoutOptional(), value.thrownType);
 		
 		this.value = value;
 	}
 		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

 		super(position, BasicTypeID.BOOL, binaryThrow(position, left.thrownType, right.thrownType));
 		
 		this.left = left;
-		this.right = scope == null ? right : right.castImplicit(position, scope, operator.header.parameters[0].type);
+		this.right = scope == null ? right : right.castImplicit(position, scope, operator.getHeader().parameters[0].type);
 		this.operator = operator;
 		this.comparison = comparison;
 	}
 		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) {
-		super(position, BasicTypeID.VOID, binaryThrow(position, constructor.header.thrownType, multiThrow(position, arguments.arguments)));
+	public ConstructorSuperCallExpression(CodePosition position, ITypeID type, FunctionalMemberRef constructor, CallArguments arguments) {
+		super(position, BasicTypeID.VOID, binaryThrow(position, constructor.getHeader().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.getHeader()));
 	}
 }

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) {
-		super(position, BasicTypeID.VOID, binaryThrow(position, constructor.header.thrownType, multiThrow(position, arguments.arguments)));
+	public ConstructorThisCallExpression(CodePosition position, ITypeID type, FunctionalMemberRef constructor, CallArguments arguments) {
+		super(position, BasicTypeID.VOID, binaryThrow(position, constructor.getHeader().thrownType, multiThrow(position, arguments.arguments)));
+		
+		if (type instanceof BasicTypeID)
+			throw new IllegalArgumentException("Type cannot be basic type");
 		
 		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, objectType, constructor, tArguments);
+	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new ConstructorThisCallExpression(position, objectType, constructor, arguments.normalize(position, scope, constructor.getHeader()));
 	}
 }

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);
 		return scope.getTypeMembers(type)
 				.getOrCreateGroup(OperatorType.CALL)
 				.getMethodMembers().stream()
-				.filter(method -> method.member.header.parameters.length == arguments && !method.member.isStatic())
-				.map(method -> method.member.header)
+				.filter(method -> method.member.getHeader().parameters.length == arguments && !method.member.isStatic())
+				.map(method -> method.member.getHeader())
 				.collect(Collectors.toList());
 	}
 	
 	@Override
 	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<ITypeID> hints, GenericName name) {
 		TypeMembers members = scope.getTypeMembers(type);
-		IPartialExpression result = members.getMemberExpression(position, this, name, false);
+		IPartialExpression result = members.getMemberExpression(position, scope, this, name, false);
 		if (result == null)
 			System.out.println("No such member: " + name.name);
 		return result;

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.getHeader() : member.getHeader().fillGenericArguments(scope.getTypeRegistry(), compiledArguments.typeArguments, scope.getLocalTypeParameters()));
 	}
 	
 	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 final FieldMemberRef field;
 	
 	public GetFieldExpression(CodePosition position, Expression target, FieldMemberRef field) {
-		super(position, field.type, target.thrownType);
+		super(position, field.getType(), target.thrownType);
 		
 		this.target = target;
 		this.field = field;
 	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 final FieldMemberRef field;
 	
 	public GetStaticFieldExpression(CodePosition position, FieldMemberRef field) {
-		super(position, field.type, null);
+		super(position, field.getType(), null);
 		
 		this.field = field;
 	}
 	
 	@Override
 	public List<ITypeID> getAssignHints() {
-		return Collections.singletonList(field.type);
+		return Collections.singletonList(field.getType());
 	}
 	
 	@Override
 	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;
 
 /**
  *
 	public final GetterMemberRef getter;
 	
 	public GetterExpression(CodePosition position, Expression target, GetterMemberRef getter) {
-		super(position, getter.type, target.thrownType);
+		super(position, getter.getType(), target.thrownType);
 		
 		this.target = target;
 		this.getter = getter;
 		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.getHeader());
 	}
 	
 	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)));
+		super(position, type, binaryThrow(position, constructor.getHeader().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;
 
 /**
  *
 	public final Expression value;
 	
 	public SetFieldExpression(CodePosition position, Expression target, FieldMemberRef field, Expression value) {
-		super(position, field.type, binaryThrow(position, target.thrownType, value.thrownType));
+		super(position, field.getType(), binaryThrow(position, target.thrownType, value.thrownType));
 		
 		this.target = target;
 		this.field = field;
 				? 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;
 
 /**
  *
 	public final Expression value;
 	
 	public SetStaticFieldExpression(CodePosition position, FieldMemberRef field, Expression value) {
-		super(position, field.type, value.thrownType);
+		super(position, field.getType(), value.thrownType);
 		
 		this.field = field;
 		this.value = value;
 		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;
 
 /**
  *
 	public final Expression value;
 	
 	public SetterExpression(CodePosition position, Expression target, SetterMemberRef setter, Expression value) {
-		super(position, setter.type, value.thrownType);
+		super(position, setter.getType(), value.thrownType);
 		
 		this.target = target;
 		this.setter = setter;
 		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 final GetterMemberRef getter;
 	
 	public StaticGetterExpression(CodePosition position, GetterMemberRef getter) {
-		super(position, getter.type, null);
+		super(position, getter.getType(), null);
 		
 		this.getter = getter;
 	}
 	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;
 
 /**
  *
 	public final Expression value;
 	
 	public StaticSetterExpression(CodePosition position, SetterMemberRef setter, Expression value) {
-		super(position, setter.type, value.thrownType);
+		super(position, setter.getType(), value.thrownType);
 		
 		this.setter = setter;
 		this.value = value;
 		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(
 
 	@Override
 	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
-		type.addCaster(new CasterMemberRef(this, mapper.map(toType)), priority);
+		type.addCaster(new CasterMemberRef(this, mapper == null ? toType : mapper.map(toType)), priority);
 	}
 
 	@Override
 	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;
  *
  * @author Hoofdgebruiker
  */
-public class ConstMember extends DefinitionMember {
+public class ConstMember extends PropertyMember {
 	public final String name;
-	public ITypeID type;
 	public Expression value;
 	public final BuiltinID builtin;
 	
 	public ConstMember(CodePosition position, HighLevelDefinition definition, int modifiers, String name, ITypeID type, BuiltinID builtin) {
-		super(position, definition, modifiers);
+		super(position, definition, modifiers, type, null);
 		
 		this.name = name;
-		this.type = type;
 		this.builtin = builtin;
 	}
 
 
 	@Override
 	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
-		members.addConst(new ConstMemberRef(this, mapper.map(type)));
+		members.addConst(new ConstMemberRef(this, 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/DefinitionMember.java

 		return position;
 	}
 	
+	public MemberAnnotation[] getAnnotations() {
+		return annotations;
+	}
+	
 	public boolean isStatic() {
 		return Modifiers.isStatic(modifiers);
 	}

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;
 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 FieldMember extends DefinitionMember {
+public class FieldMember extends PropertyMember {
 	public final String name;
-	public ITypeID type;
 	public Expression initializer;
 	public final int autoGetterAccess;
 	public final int autoSetterAccess;
-	public final BuiltinID builtin;
 	
 	public final GetterMember autoGetter;
 	public final SetterMember autoSetter;
 			HighLevelDefinition definition,
 			int modifiers,
 			String name,
+			ITypeID thisType,
 			ITypeID type,
 			GlobalTypeRegistry registry,
 			int autoGetterAccess,
 			int autoSetterAccess,
 			BuiltinID builtin)
 	{
-		super(position, definition, modifiers);
+		super(position, definition, modifiers, type, builtin);
 		
 		this.name = name;
-		this.type = type;
 		this.autoGetterAccess = autoGetterAccess;
 		this.autoSetterAccess = autoSetterAccess;
-		this.builtin = builtin;
 		
 		ITypeID[] parameters = null;
 		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, null))));
 		} 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, null),
 					new GetFunctionParameterExpression(position, this.autoSetter.header.parameters[0]))));
 		} else {
 			this.autoSetter = null;
 			SetterMember autoSetter,
 			BuiltinID builtin)
 	{
-		super(position, definition, modifiers);
+		super(position, definition, modifiers, type, builtin);
 		
 		this.name = name;
-		this.type = type;
 		this.autoGetterAccess = autoGetterAccess;
 		this.autoSetterAccess = autoSetterAccess;
 		this.autoGetter = autoGetter;
 		this.autoSetter = autoSetter;
-		this.builtin = builtin;
 	}
 	
 	public boolean hasAutoGetter() {
 
 	@Override
 	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
-		members.addField(new FieldMemberRef(this, mapper.map(type)), priority);
+		members.addField(new FieldMemberRef(this, mapper), priority);
 	}
 	
 	@Override
 	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 abstract FunctionalKind getKind();
 	
 	public FunctionalMemberRef ref(GenericMapper mapper) {
-		return new FunctionalMemberRef(this, mapper.map(header));
+		return new FunctionalMemberRef(this, mapper);
 	}
 	
 	@Override
 	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/GetterMember.java

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
  *
  * @author Hoofdgebruiker
  */
-public class GetterMember extends FunctionalMember {
+public class GetterMember extends FunctionalMember implements IPropertyMember {
 	public final String name;
 	public ITypeID type;
 	private GetterMemberRef overrides;
 		this.type = type;
 	}
 	
+	@Override
+	public ITypeID getType() {
+		return type;
+	}
+	
 	@Override
 	public String getCanonicalName() {
 		return definition.getFullName() + ":getter:" + name;
 	
 	@Override
 	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
-		members.addGetter(new GetterMemberRef(this, mapper.map(type)), priority);
+		members.addGetter(new GetterMemberRef(this, mapper), priority);
 	}
 
 	@Override
 		this.overrides = override;
 		
 		if (type == BasicTypeID.UNDETERMINED)
-			type = override.type;
+			type = override.getType();
 	}
 }

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/IPropertyMember.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 org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface IPropertyMember {
+	ITypeID getType();
+	
+	CodePosition getPosition();
+	
+	String describe();
+
+	<T> T getTag(Class<T> type);
+	
+	boolean isStatic();
+	
+	boolean isFinal();
+	
+	MemberAnnotation[] getAnnotations();
+}