- Fixed various issues with generics and made instancing strict (all generic types MUST be defined in the mapper or an exception is thrown)

- Member registration mapping is now all-or-nothing: either no mapping is performed (for local scopes) or ALL mentioned type parameters must have an entry in the type parameter map.
- Static inner type IDs (including inner interfaces and inner aliases) no longer record their outer type; this caused problems when comparing types

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

 	
 	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], registry.getGeneric(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];

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;
 	}
 	
 	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/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;
 
 		
 		this.type = type;
 	}
+	
+	@Override
+	public boolean isStatic() {
+		return true;
+	}
 
 	@Override
 	public <T> T accept(DefinitionVisitor<T> visitor) {

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

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 	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/expression/ExpressionBuilder.java

 				type,
 				member,
 				compiledArguments,
-				compiledArguments.getNumberOfTypeArguments() == 0 ? member.getHeader() : member.getHeader().fillGenericArguments(scope.getTypeRegistry(), compiledArguments.typeArguments));
+				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/member/CasterMember.java

 
 	@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

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

 		
 		if (autoGetterAccess != 0) {
 			this.autoGetter = new GetterMember(position, definition, autoGetterAccess, name, type, null);
-			this.autoGetter.setBody(new ReturnStatement(position, new GetFieldExpression(position, new ThisExpression(position, thisType), new FieldMemberRef(this, GenericMapper.EMPTY))));
+			this.autoGetter.setBody(new ReturnStatement(position, new GetFieldExpression(
+					position,
+					new ThisExpression(position, thisType),
+					new FieldMemberRef(this, null))));
 		} else {
 			this.autoGetter = null;
 		}
 			this.autoSetter.setBody(new ExpressionStatement(position, new SetFieldExpression(
 					position,
 					new ThisExpression(position, thisType),
-					new FieldMemberRef(this, GenericMapper.EMPTY),
+					new FieldMemberRef(this, null),
 					new GetFunctionParameterExpression(position, this.autoSetter.header.parameters[0]))));
 		} else {
 			this.autoSetter = null;

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

 
 	@Override
 	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
-		ITypeID instancedType = mapper.map(type);
+		ITypeID instancedType = mapper == null ? type : mapper.map(type);
 		members.addImplementation(new ImplementationMemberRef(this, instancedType), priority);
 		
 		TypeMembers interfaceTypeMembers = members.getMemberCache().get(instancedType);

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

 
 	@Override
 	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
-		if (isStatic() || mapper.getMapping().isEmpty()) {
+		if (isStatic() || mapper == null || mapper.getMapping().isEmpty()) {
 			type.addInnerType(innerDefinition.name, new InnerDefinition(innerDefinition));
 		} else {
 			type.addInnerType(innerDefinition.name, new InnerDefinition(innerDefinition, mapper.getMapping()));

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

 
 	@Override
 	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
-		members.addIterator(new IteratorMemberRef(this, mapper.map(loopVariableTypes)), priority);
+		members.addIterator(new IteratorMemberRef(this, mapper == null ? loopVariableTypes : mapper.map(loopVariableTypes)), priority);
 	}
 
 	@Override

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

 
 	@Override
 	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
-		members.addIterator(new IteratorMemberRef(this, mapper.map(loopVariableTypes)), priority);
+		members.addIterator(new IteratorMemberRef(this, mapper == null ? loopVariableTypes : mapper.map(loopVariableTypes)), priority);
 	}
 
 	@Override

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

 
 	@Override
 	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
-		type.addIterator(new IteratorMemberRef(this, mapper.map(loopVariableTypes)), priority);
+		type.addIterator(new IteratorMemberRef(this, mapper == null ? loopVariableTypes : mapper.map(loopVariableTypes)), priority);
 	}
 
 	@Override

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

 
 	@Override
 	public void registerTo(TypeMembers type, TypeMemberPriority priority, GenericMapper mapper) {
-		type.addIterator(new IteratorMemberRef(this, mapper.map(loopVariableTypes)), priority);
+		type.addIterator(new IteratorMemberRef(this, mapper == null ? loopVariableTypes : mapper.map(loopVariableTypes)), priority);
 	}
 
 	@Override

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

 			header = null;
 			this.mapper = mapper;
 		} else {
-			header = mapper.map(target.header);
+			header = mapper == null ? target.header : mapper.map(target.header);
 			this.mapper = null;
 		}
 	}
 			if (target.header.hasUnknowns)
 				throw new IllegalStateException("member is not yet resolved!");
 			
-			header = mapper.map(target.header);
+			header = mapper == null ? target.header : mapper.map(target.header);
 			this.mapper = null;
 		}
 		

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

 package org.openzen.zenscript.codemodel.member.ref;
 
 import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;

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

 			type = null;
 			this.mapper = mapper;
 		} else {
-			type = member.getType().instance(mapper);
+			type = mapper == null ? member.getType() : member.getType().instance(mapper);
 			this.mapper = null;
 		}
 	}
 			if (member.getType() == BasicTypeID.UNDETERMINED)
 				throw new IllegalStateException("Property is not yet resolved!");
 			
-			type = member.getType().instance(mapper);
+			type = mapper == null ? member.getType() : member.getType().instance(mapper);
 			mapper = null;
 		}
 		

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 	public TypeMemberPreparer getPreparer() {
 		return parent.getPreparer();
 	}
+
+	@Override
+	public GenericMapper getLocalTypeParameters() {
+		return parent.getLocalTypeParameters();
+	}
 }

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

 import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 	public TypeMemberPreparer getPreparer() {
 		return outer.getPreparer();
 	}
+
+	@Override
+	public GenericMapper getLocalTypeParameters() {
+		return outer.getLocalTypeParameters();
+	}
 }

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

 
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
 	private final TypeMembers members;
 	private final Map<String, TypeParameter> genericParameters = new HashMap<>();
 	private final Map<String, Supplier<HighLevelDefinition>> innerTypes = new HashMap<>();
+	private final GenericMapper typeParameterMap;
 	
 	public DefinitionScope(BaseScope outer, HighLevelDefinition definition) {
 		this(outer, definition, true);
 		this.outer = outer;
 		this.definition = definition;
 		
+		Map<TypeParameter, ITypeID> typeParameters = new HashMap<>();
 		if (definition instanceof ExpansionDefinition) {
 			ExpansionDefinition expansion = (ExpansionDefinition)definition;
 			type = expansion.target;
 			
 			for (TypeParameter parameter : expansion.genericParameters) {
 				genericParameters.put(parameter.name, parameter);
+				typeParameters.put(parameter, outer.getTypeRegistry().getGeneric(parameter));
 			}
 		} else {
 			DefinitionTypeID definitionType = outer.getTypeRegistry().getForMyDefinition(definition);
 			while (definitionType != null) {
 				for (TypeParameter parameter : definitionType.definition.genericParameters) {
 					genericParameters.put(parameter.name, parameter);
+					typeParameters.put(parameter, outer.getTypeRegistry().getGeneric(parameter));
 				}
 				definitionType = definitionType.definition.isStatic() ? null : definitionType.outer;
 			}
 		}
 		
 		members = withMembers ? outer.getMemberCache().get(type) : null;
+		typeParameterMap = outer.getLocalTypeParameters().getInner(typeParameters);
 	}
 	
 	public void addInnerType(String name, Supplier<HighLevelDefinition> innerType) {
 	public TypeMemberPreparer getPreparer() {
 		return outer.getPreparer();
 	}
+
+	@Override
+	public GenericMapper getLocalTypeParameters() {
+		return typeParameterMap;
+	}
 }

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 	public TypeMemberPreparer getPreparer() {
 		return outer.getPreparer();
 	}
+
+	@Override
+	public GenericMapper getLocalTypeParameters() {
+		return outer.getLocalTypeParameters();
+	}
 }

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

 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
 	public TypeMemberPreparer getPreparer() {
 		return preparer;
 	}
+
+	@Override
+	public GenericMapper getLocalTypeParameters() {
+		return GenericMapper.EMPTY;
+	}
 }

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 	public TypeMemberPreparer getPreparer() {
 		return outer.getPreparer();
 	}
+
+	@Override
+	public GenericMapper getLocalTypeParameters() {
+		return outer.getLocalTypeParameters();
+	}
 }

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

 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 public class FunctionScope extends StatementScope {
 	private final BaseScope outer;
 	private final FunctionHeader header;
+	private final GenericMapper typeParameterMap;
 	
 	public FunctionScope(BaseScope outer, FunctionHeader header) {
 		this.outer = outer;
 		this.header = header;
+		typeParameterMap = outer.getLocalTypeParameters().getInner(outer.getTypeRegistry(), header.typeParameters);
 	}
 	
 	@Override
 	public TypeMemberPreparer getPreparer() {
 		return outer.getPreparer();
 	}
+
+	@Override
+	public GenericMapper getLocalTypeParameters() {
+		return typeParameterMap;
+	}
 }

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 	public TypeMemberPreparer getPreparer() {
 		return outer.getPreparer();
 	}
+
+	@Override
+	public GenericMapper getLocalTypeParameters() {
+		return outer.getLocalTypeParameters();
+	}
 }

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 	public TypeMemberPreparer getPreparer() {
 		return file.getPreparer();
 	}
+
+	@Override
+	public GenericMapper getLocalTypeParameters() {
+		return GenericMapper.EMPTY;
+	}
 }

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

  */
 package org.openzen.zenscript.codemodel.scope;
 
-import java.util.Collections;
 import java.util.List;
 import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
-import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
-import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
 		this.implementation = implementation;
 		
 		members = outer.getTypeMembers(implementation.type);
-		/*members = new TypeMembers(outer.getMemberCache(), implementation.type);
-		interfaceMembers.copyMembersTo(implementation.position, interfaceMembers, TypeMemberPriority.INHERITED);
-		
-		for (IDefinitionMember member : implementation.members) {
-			member.registerTo(members, TypeMemberPriority.SPECIFIED, new GenericMapper(outer.getTypeRegistry(), Collections.emptyMap()));
-		}*/
 	}
 
 	@Override
 	public TypeMemberPreparer getPreparer() {
 		return outer.getPreparer();
 	}
+
+	@Override
+	public GenericMapper getLocalTypeParameters() {
+		return outer.getLocalTypeParameters();
+	}
 }

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

 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
 import org.openzen.zenscript.codemodel.expression.LambdaClosure;
 	public TypeMemberPreparer getPreparer() {
 		return outer.getPreparer();
 	}
+
+	@Override
+	public GenericMapper getLocalTypeParameters() {
+		return outer.getLocalTypeParameters();
+	}
 }

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 	public TypeMemberPreparer getPreparer() {
 		return outer.getPreparer();
 	}
+
+	@Override
+	public GenericMapper getLocalTypeParameters() {
+		return outer.getLocalTypeParameters();
+	}
 }

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

  */
 package org.openzen.zenscript.codemodel.scope;
 
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	}
 	
 	TypeMemberPreparer getPreparer();
+	
+	GenericMapper getLocalTypeParameters();
 }

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

 	}
 	
 	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, ITypeID[] typeParameters, DefinitionTypeID outer) {
-		DefinitionTypeID id = new DefinitionTypeID(this, definition, typeParameters, outer);
+		DefinitionTypeID id = new DefinitionTypeID(this, definition, typeParameters, definition.isStatic() ? null : outer);
 		
 		if (definitionTypes.containsKey(id)) {
 			return definitionTypes.get(id);

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

 	// Infers type parameters for this type so it matches with targetType
 	// returns false if that isn't possible
 	public default boolean inferTypeParameters(LocalMemberCache cache, ITypeID targetType, Map<TypeParameter, ITypeID> mapping) {
-		return accept(new MatchingTypeVisitor(cache, targetType, mapping));
+		return targetType.accept(new MatchingTypeVisitor(cache, this, mapping));
 	}
 	
 	public void extractTypeParameters(List<TypeParameter> typeParameters);
 		public Boolean visitAssoc(AssocTypeID assoc) {
 			if (type instanceof AssocTypeID) {
 				AssocTypeID assocType = (AssocTypeID) type;
-				return match(assoc.keyType, assocType.keyType)
-						&& match(assoc.valueType, assocType.valueType);
+				return match(assocType.keyType, assoc.keyType)
+						&& match(assocType.valueType, assoc.valueType);
 			} else {
 				return false;
 			}
 		public Boolean visitGeneric(GenericTypeID generic) {
 			if (mapping.containsKey(generic.parameter)) {
 				return mapping.get(generic.parameter) == type;
-			} else if (generic.matches(cache, type)) {
+			} else if (type == generic || generic.matches(cache, type)) {
 				mapping.put(generic.parameter, type);
 				return true;
 			} else {
 		}
 		
 		private boolean match(ITypeID type, ITypeID pattern) {
-			if (type == pattern)
-				return true;
-			
 			return pattern.accept(new MatchingTypeVisitor(cache, type, mapping));
 		}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/StaticDefinitionTypeID.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.type;
-
-import org.openzen.zenscript.codemodel.HighLevelDefinition;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class StaticDefinitionTypeID extends DefinitionTypeID {
-	public StaticDefinitionTypeID(HighLevelDefinition definition) {
-		super(definition);
-	}
-}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/TypeParameterCollector.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.type;
+
+import java.util.Map;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class TypeParameterCollector implements ITypeVisitor<Void> {
+	private final Map<TypeParameter, ITypeID> map;
+	
+	public TypeParameterCollector(Map<TypeParameter, ITypeID> map) {
+		this.map = map;
+	}
+
+	@Override
+	public Void visitBasic(BasicTypeID basic) {
+		return null;
+	}
+
+	@Override
+	public Void visitArray(ArrayTypeID array) {
+		array.elementType.accept(this);
+		return null;
+	}
+
+	@Override
+	public Void visitAssoc(AssocTypeID assoc) {
+		assoc.keyType.accept(this);
+		assoc.valueType.accept(this);
+		return null;
+	}
+
+	@Override
+	public Void visitGenericMap(GenericMapTypeID map) {
+		return null;
+	}
+
+	@Override
+	public Void visitIterator(IteratorTypeID iterator) {
+		for (ITypeID type : iterator.iteratorTypes)
+			type.accept(this);
+		return null;
+	}
+
+	@Override
+	public Void visitFunction(FunctionTypeID function) {
+		function.header.returnType.accept(this);
+		for (FunctionParameter parameter : function.header.parameters)
+			parameter.type.accept(this);
+		return null;
+	}
+
+	@Override
+	public Void visitDefinition(DefinitionTypeID definition) {
+		for (ITypeID argument : definition.typeParameters)
+			argument.accept(this);
+		if (definition.outer != null)
+			visitDefinition(definition.outer);
+		return null;
+	}
+
+	@Override
+	public Void visitGeneric(GenericTypeID generic) {
+		map.put(generic.parameter, generic);
+		return null;
+	}
+
+	@Override
+	public Void visitRange(RangeTypeID range) {
+		range.from.accept(this);
+		range.to.accept(this);
+		return null;
+	}
+
+	@Override
+	public Void visitModified(ModifiedTypeID type) {
+		type.baseType.accept(this);
+		return null;
+	}
+}

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

 	
 	public Expression call(CodePosition position, TypeScope scope, Expression target, CallArguments arguments, boolean allowStaticUsage) {
 		FunctionalMemberRef method = selectMethod(position, scope, arguments, true, allowStaticUsage);
-		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
 		for (int i = 0; i < arguments.arguments.length; i++) {
 			arguments.arguments[i] = arguments.arguments[i].castImplicit(position, scope, instancedHeader.parameters[i].type);
 		}
 			CallArguments arguments,
 			CompareType compareType) {
 		FunctionalMemberRef method = selectMethod(position, scope, arguments, true, false);
-		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
 		return method.callWithComparator(position, compareType, target, instancedHeader, arguments, scope);
 	}
 	
 	public Expression callStatic(CodePosition position, ITypeID target, TypeScope scope, CallArguments arguments) {
 		FunctionalMemberRef method = selectMethod(position, scope, arguments, false, true);
-		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments, scope.getLocalTypeParameters());
 		return method.callStatic(position, target, instancedHeader, arguments, scope);
 	}
 	

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

 	private final GlobalTypeRegistry registry;
 	private final TypeMembers members;
 	private final LocalMemberCache cache;
-	private final GenericMapper emptyMapper;
 	
 	public TypeMemberBuilder(GlobalTypeRegistry registry, TypeMembers members, LocalMemberCache cache) {
 		this.registry = registry;
 		this.members = members;
 		this.cache = cache;
-		emptyMapper = new GenericMapper(registry, Collections.emptyMap());
 	}
 	
 	private void processType(HighLevelDefinition definition, ITypeID type) {
 				throw new CompileException(expansion.position, CompileExceptionCode.INTERNAL_ERROR, "Missing expansion target");
 			
 			Map<TypeParameter, ITypeID> mapping = matchType(type, expansion.target);
+			if (mapping == null)
+				continue;
+			
 			GenericMapper mapper = new GenericMapper(registry, mapping);
-			if (mapping != null) {
-				for (IDefinitionMember member : expansion.members)
-					member.registerTo(members, TypeMemberPriority.SPECIFIED, mapper);
-			}
+			for (IDefinitionMember member : expansion.members)
+				member.registerTo(members, TypeMemberPriority.SPECIFIED, mapper);
 		}
 		
 		if (members.hasOperator(OperatorType.EQUALS)) {
 	}
 	
 	private Map<TypeParameter, ITypeID> matchType(ITypeID type, ITypeID pattern) {
-		if (type == pattern)
-			return Collections.emptyMap();
-		
 		Map<TypeParameter, ITypeID> mapping = new HashMap<>();
-		if (pattern.inferTypeParameters(cache, type, mapping))
+		if (type.inferTypeParameters(cache, pattern, mapping))
 			return mapping;
 		
 		return null;
 					definition,
 					0,
 					new FunctionHeader(VOID, indexGetParameters),
-					ARRAY_CONSTRUCTOR_SIZED).ref(emptyMapper));
+					ARRAY_CONSTRUCTOR_SIZED).ref(null));
 		}
 
 		FunctionParameter[] initialValueConstructorParameters = new FunctionParameter[dimension + 1];
 				0,
 				initialValueConstructorHeader,
 				ARRAY_CONSTRUCTOR_INITIAL_VALUE)
-				.registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+				.registerTo(members, TypeMemberPriority.SPECIFIED, null);
 		
 		FunctionParameter[] lambdaConstructorParameters = new FunctionParameter[dimension + 1];
 		for (int i = 0; i < dimension; i++)
 				definition,
 				0,
 				lambdaConstructorHeader,
-				ARRAY_CONSTRUCTOR_LAMBDA).ref(emptyMapper));
+				ARRAY_CONSTRUCTOR_LAMBDA).ref(null));
 		
 		{
 			TypeParameter mappedConstructorParameter = new TypeParameter(BUILTIN, "T");
 					definition,
 					Modifiers.PUBLIC,
 					mappedConstructorFunctionWithoutIndex,
-					ARRAY_CONSTRUCTOR_PROJECTED).ref(emptyMapper));
+					ARRAY_CONSTRUCTOR_PROJECTED).ref(null));
 		}
 		
 		{
 
 		getter(definition, ARRAY_ISEMPTY, "isEmpty", BOOL);
 		getter(definition, ARRAY_HASHCODE, "objectHashCode", INT);
-		new ArrayIteratorKeyValues(array).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
-		new ArrayIteratorValues(array).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		new ArrayIteratorKeyValues(array).registerTo(members, TypeMemberPriority.SPECIFIED, null);
+		new ArrayIteratorValues(array).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 		
 		equals(definition, ARRAY_EQUALS, array);
 		notequals(definition, ARRAY_NOTEQUALS, array);
 		getter(builtin, BuiltinID.ASSOC_VALUES, "values", cache.getRegistry().getArray(valueType, 1));
 		getter(builtin, BuiltinID.ASSOC_HASHCODE, "objectHashCode", BasicTypeID.INT);
 		
-		new AssocIterator(assoc).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		new AssocIterator(assoc).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 		
 		equals(builtin, BuiltinID.ASSOC_EQUALS, assoc);
 		notequals(builtin, BuiltinID.ASSOC_NOTEQUALS, assoc);
 	@Override
 	public Void visitFunction(FunctionTypeID function) {
 		FunctionDefinition builtin = new FunctionDefinition(BUILTIN, null, "", Modifiers.EXPORT, function.header);
-		new CallerMember(BUILTIN, builtin, 0, function.header, FUNCTION_CALL).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		new CallerMember(BUILTIN, builtin, 0, function.header, FUNCTION_CALL).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 		
 		same(builtin, FUNCTION_SAME, function);
 		notsame(builtin, FUNCTION_NOTSAME, function);
 	@Override
 	public Void visitDefinition(DefinitionTypeID type) {
 		HighLevelDefinition definition = type.definition;
-		GenericMapper mapper = emptyMapper;
+		GenericMapper mapper = null;
 		if (type.hasTypeParameters() || (type.outer != null && type.outer.hasTypeParameters())) {
 			Map<TypeParameter, ITypeID> mapping = type.getTypeParameterMapping();
 			mapper = new GenericMapper(registry, mapping);
 							definition,
 							Modifiers.PUBLIC,
 							new FunctionHeader(VOID, parameters),
-							STRUCT_VALUE_CONSTRUCTOR).ref(emptyMapper), TypeMemberPriority.SPECIFIED);
+							STRUCT_VALUE_CONSTRUCTOR).ref(null), TypeMemberPriority.SPECIFIED);
 				}
 			} else if (definition instanceof EnumDefinition) {
 				// add default constructor
 						definition,
 						Modifiers.PRIVATE,
 						new FunctionHeader(VOID),
-						ENUM_EMPTY_CONSTRUCTOR).ref(emptyMapper), TypeMemberPriority.SPECIFIED);
+						ENUM_EMPTY_CONSTRUCTOR).ref(null), TypeMemberPriority.SPECIFIED);
 			}
 		}
 		
 				|| range.from == UINT
 				|| range.from == LONG
 				|| range.from == ULONG)) {
-			new RangeIterator(range).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+			new RangeIterator(range).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 		}
 		
 		processType(definition, range);
 		method(builtin, STRING_TO_LOWER_CASE, "toLowerCase", STRING);
 		method(builtin, STRING_TO_UPPER_CASE, "toUpperCase", STRING);
 		
-		new StringCharIterator().registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		new StringCharIterator().registerTo(members, TypeMemberPriority.SPECIFIED, null);
 		
 		processType(builtin, STRING);
 	}
 	
 	private void castedTargetCall(OperatorMember member, BuiltinID casterBuiltin) {
 		CasterMemberRef caster = castImplicitRef(member.definition, casterBuiltin, member.header.parameters[0].type);
-		TranslatedOperatorMemberRef method = new TranslatedOperatorMemberRef(member, GenericMapper.EMPTY, call -> member.ref(emptyMapper).call(call.position, caster.cast(call.position, call.target, true), call.arguments, call.scope));
+		TranslatedOperatorMemberRef method = new TranslatedOperatorMemberRef(member, GenericMapper.EMPTY, call -> member.ref(null).call(call.position, caster.cast(call.position, call.target, true), call.arguments, call.scope));
 		members.getOrCreateGroup(member.operator).addMethod(method, TypeMemberPriority.SPECIFIED);
 	}
 	
 	private void register(IDefinitionMember member) {
-		member.registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		member.registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void operator(
 				Modifiers.PUBLIC,
 				operator,
 				header,
-				builtin).ref(emptyMapper));
+				builtin).ref(null));
 	}
 	
 	private void not(HighLevelDefinition cls, BuiltinID id, ITypeID result) {
 	}
 	
 	private void add(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result) {
-		addOp(definition, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		addOp(definition, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void add(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
 	}
 	
 	private void sub(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
-		subOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		subOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void sub(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
 	}
 	
 	private void mul(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
-		mulOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		mulOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void mul(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
 	}
 	
 	private void div(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
-		divOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		divOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void div(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
 	}
 	
 	private void mod(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
-		modOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		modOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void mod(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
 	}
 	
 	private void shl(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
-		shlOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		shlOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void shl(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
 	}
 	
 	private void shr(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
-		shrOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		shrOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void shr(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
 	}
 	
 	private void ushr(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
-		ushrOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		ushrOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void ushr(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
 	}
 	
 	private void or(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
-		orOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		orOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void or(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		orOp(definition, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		orOp(definition, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private OperatorMember andOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void and(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
-		andOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		andOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void and(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
 	}
 	
 	private void xor(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
-		xorOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		xorOp(cls, id, operand, result).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void xor(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
 				Modifiers.PUBLIC,
 				OperatorType.INDEXGET,
 				new FunctionHeader(result, new FunctionParameter(operand)),
-				id).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+				id).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void indexSet(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID value) {
 				Modifiers.PUBLIC,
 				OperatorType.INDEXSET,
 				new FunctionHeader(VOID, operand, value),
-				id).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+				id).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private OperatorMember compareOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand) {
 	}
 	
 	private void compare(HighLevelDefinition cls, BuiltinID id, ITypeID operand) {
-		compareOp(cls, id, operand).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		compareOp(cls, id, operand).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void compare(HighLevelDefinition definition, BuiltinID id, ITypeID operand, BuiltinID caster) {
 				Modifiers.PUBLIC,
 				name,
 				type,
-				id).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+				id).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void constant(HighLevelDefinition cls, BuiltinID id, String name, Expression value) {
 				value.type,
 				id);
 		result.value = value;
-		result.registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+		result.registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void constructor(
 				definition,
 				Modifiers.PUBLIC,
 				header,
-				id).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+				id).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void constructor(
 				definition,
 				Modifiers.PUBLIC,
 				new FunctionHeader(VOID, arguments),
-				id).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+				id).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void method(
 				cls,
 				Modifiers.PUBLIC,
 				result,
-				id).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+				id).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void castImplicit(HighLevelDefinition cls, BuiltinID id, ITypeID result) {
 				cls,
 				Modifiers.PUBLIC | Modifiers.IMPLICIT,
 				result,
-				id).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+				id).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private CasterMemberRef castImplicitRef(HighLevelDefinition definition, BuiltinID id, ITypeID result) {
 				Modifiers.PUBLIC,
 				OperatorType.EQUALS,
 				new FunctionHeader(BOOL, new FunctionParameter(type)),
-				id).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+				id).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void same(HighLevelDefinition cls, BuiltinID id, ITypeID type) {
 				Modifiers.PUBLIC,
 				OperatorType.SAME,
 				new FunctionHeader(BOOL, new FunctionParameter(type)),
-				id).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+				id).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void notequals(HighLevelDefinition cls, BuiltinID id, ITypeID type) {
 				Modifiers.PUBLIC,
 				OperatorType.NOTEQUALS,
 				new FunctionHeader(BOOL, new FunctionParameter(type)),
-				id).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+				id).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 	
 	private void notsame(HighLevelDefinition cls, BuiltinID id, ITypeID type) {
 				Modifiers.PUBLIC,
 				OperatorType.NOTSAME,
 				new FunctionHeader(BOOL, new FunctionParameter(type)),
-				id).registerTo(members, TypeMemberPriority.SPECIFIED, emptyMapper);
+				id).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 	}
 }

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

 import java.util.List;
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 	public TypeMemberPreparer getPreparer() {
 		return member -> {};
 	}
+
+	@Override
+	public GenericMapper getLocalTypeParameters() {
+		return GenericMapper.EMPTY;
+	}
 }

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

 				type,
 				member,
 				compiledArguments,
-				member.getHeader().fillGenericArguments(scope.getTypeRegistry(), compiledArguments.typeArguments));
+				member.getHeader().fillGenericArguments(scope.getTypeRegistry(), compiledArguments.typeArguments, scope.getLocalTypeParameters()));
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedCatchClause.java

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 		public TypeMemberPreparer getPreparer() {
 			return outer.getPreparer();
 		}
+
+		@Override
+		public GenericMapper getLocalTypeParameters() {
+			return outer.getLocalTypeParameters();
+		}
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedStatementSwitch.java

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.WhitespaceInfo;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 		public TypeMemberPreparer getPreparer() {
 			return outer.getPreparer();
 		}
+
+		@Override
+		public GenericMapper getLocalTypeParameters() {
+			return outer.getLocalTypeParameters();
+		}
 	}
 }

Validator/src/main/java/org/openzen/zenscript/validator/visitors/DefinitionValidator.java

 import java.util.Map;
 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 static org.openzen.zenscript.codemodel.Modifiers.*;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 		public TypeMemberPreparer getPreparer() {
 			return member -> {};
 		}
+
+		@Override
+		public GenericMapper getLocalTypeParameters() {
+			throw new UnsupportedOperationException();
+		}
 	}
 	
 	private class FunctionStatementScope implements StatementScope {