- Fixed numerous issues with undetermined types, type inference, type aliases, inner types and generic types

- Distinguished between type resolution and code compilation stages, both have a different context now
- Added new concepts: "compiling type" and "compiling package", which is able to precompile correctly now
- Rewrote the way precompilation works; precompilation no longer exists, instead, compilation order of methods is changed. This reduces the amount of code needed and improves quality of the system.
- Fixed members of base interfaces not being available to implementation code
- Changed the way type modifiers are coded

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

 import org.openzen.zenscript.codemodel.type.ITypeVisitor;
 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
-import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import stdlib.Chars;
 
 /**
 	@Override
 	public String visitModified(ModifiedTypeID type) {
 		StringBuilder result = new StringBuilder();
-		if ((type.modifiers & TypeMembers.MODIFIER_CONST) > 0)
+		if (type.isConst())
 			result.append("const ");
-		if ((type.modifiers & TypeMembers.MODIFIER_IMMUTABLE) > 0)
+		if (type.isImmutable())
 			result.append("immutable ");
 		result.append(type.accept(this));
-		if ((type.modifiers & TypeMembers.MODIFIER_OPTIONAL) > 0)
+		if (type.isOptional())
 			result.append("?");
 		
 		return result.toString();

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

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

 	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) {

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

  */
 package org.openzen.zenscript.codemodel;
 
+import java.util.Collections;
 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;
 	

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

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

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

 	}
 	
 	public void setType(ITypeID type) {
+		if (type == null)
+			throw new NullPointerException("type cannot be null!");
+		
 		this.type = type;
 	}
 

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

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

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

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

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

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

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

 		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));
+				compiledArguments.getNumberOfTypeArguments() == 0 ? member.getHeader() : member.getHeader().fillGenericArguments(scope.getTypeRegistry(), compiledArguments.typeArguments));
 	}
 	
 	public Expression not(Expression value) {

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;

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

 	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

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

 	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;

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

 			FunctionalMemberRef constructor,
 			CallArguments arguments)
 	{
-		this(position, type, constructor, arguments, constructor.header);
+		this(position, type, constructor, arguments, constructor.getHeader());
 	}
 	
 	public NewExpression(
 			CallArguments arguments,
 			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 = arguments;

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

 	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;

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

 	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;

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

 	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;

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

 	public final GetterMemberRef getter;
 	
 	public StaticGetterExpression(CodePosition position, GetterMemberRef getter) {
-		super(position, getter.type, null);
+		super(position, getter.getType(), null);
 		
 		this.getter = getter;
 	}

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

 	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;

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

  *
  * @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, type, mapper));
+		members.addConst(new ConstMemberRef(this, mapper));
 	}
 
 	@Override

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.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;
 			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) {
 		
 		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, thisType))));
+			this.autoGetter.setBody(new ReturnStatement(position, new GetFieldExpression(position, new ThisExpression(position, thisType), new FieldMemberRef(this, GenericMapper.EMPTY))));
 		} else {
 			this.autoGetter = null;
 		}
 			this.autoSetter.setBody(new ExpressionStatement(position, new SetFieldExpression(
 					position,
 					new ThisExpression(position, thisType),
-					new FieldMemberRef(this, thisType),
+					new FieldMemberRef(this, GenericMapper.EMPTY),
 					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

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

 	public abstract FunctionalKind getKind();
 	
 	public FunctionalMemberRef ref(GenericMapper mapper) {
-		return new FunctionalMemberRef(this, mapper.map(header));
+		return new FunctionalMemberRef(this, mapper);
 	}
 	
 	@Override

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/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();
+}

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;

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

 	
 	public void setOverrides(GlobalTypeRegistry registry, FunctionalMemberRef overrides) {
 		this.overrides = overrides;
-		header = header.inferFromOverride(registry, overrides.header);
+		header = header.inferFromOverride(registry, overrides.getHeader());
 		
 		if (overrides.getTarget().isPublic())
 			modifiers |= Modifiers.PUBLIC;

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

 	
 	public void setOverrides(GlobalTypeRegistry registry, FunctionalMemberRef overrides) {
 		this.overrides = overrides;
-		header = header.inferFromOverride(registry, overrides.header);
+		header = header.inferFromOverride(registry, overrides.getHeader());
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/PropertyMember.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.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.BuiltinID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public abstract class PropertyMember extends DefinitionMember implements IPropertyMember {
+	public ITypeID type;
+	public final BuiltinID builtin;
+	
+	public PropertyMember(CodePosition position, HighLevelDefinition definition, int modifiers, ITypeID type, BuiltinID builtin) {
+		super(position, definition, modifiers);
+		
+		this.type = type;
+		this.builtin = builtin;
+	}
+	
+	@Override
+	public ITypeID getType() {
+		return type;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/SetterMember.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.FunctionParameter;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
  *
  * @author Hoofdgebruiker
  */
-public class SetterMember extends FunctionalMember {
+public class SetterMember extends FunctionalMember implements IPropertyMember {
 	public ITypeID type;
 	public final String name;
 	private SetterMemberRef overrides;
 		this.name = name;
 	}
 	
+	@Override
+	public ITypeID getType() {
+		return type;
+	}
+	
 	@Override
 	public String getCanonicalName() {
 		return definition.getFullName() + ":setter:" + name;
 
 	@Override
 	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
-		members.addSetter(new SetterMemberRef(this, mapper.map(type)), priority);
+		members.addSetter(new SetterMemberRef(this, mapper), priority);
 	}
 
 	@Override
 	public SetterMemberRef getOverrides() {
 		return overrides;
 	}
+
+	@Override
+	public void normalize(TypeScope scope) {
+		if (body != null)
+			body = body.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class));
+	}
 	
 	public void setOverrides(SetterMemberRef overrides) {
 		this.overrides = overrides;
 		
 		if (type == BasicTypeID.UNDETERMINED)
-			type = overrides.type;
+			type = overrides.getType();
 	}
 }

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

  */
 package org.openzen.zenscript.codemodel.member.ref;
 
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
-import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.member.ConstMember;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class ConstMemberRef implements DefinitionMemberRef {
+public class ConstMemberRef extends PropertyRef {
 	public final ConstMember member;
-	private ITypeID type;
-	private ITypeID originalType;
-	private final GenericMapper mapper;
 	
-	public ConstMemberRef(ConstMember member, ITypeID originalType, GenericMapper mapper) {
+	public ConstMemberRef(ConstMember member, GenericMapper mapper) {
+		super(member, mapper);
 		this.member = member;
-		this.type = originalType.instance(mapper);
-		this.originalType = originalType;
-		this.mapper = mapper;
-	}
-	
-	public ITypeID getType() {
-		if (originalType != member.type) {
-			originalType = member.type;
-			type = originalType.instance(mapper);
-		}
-		return type;
-	}
-
-	@Override
-	public CodePosition getPosition() {
-		return member.position;
-	}
-
-	@Override
-	public String describe() {
-		return member.describe();
-	}
-
-	@Override
-	public <T> T getTag(Class<T> type) {
-		return member.getTag(type);
 	}
 
 	@Override
 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
-
-	@Override
-	public FunctionHeader getHeader() {
-		return null;
-	}
-
-	@Override
-	public MemberAnnotation[] getAnnotations() {
-		return member.annotations;
-	}
 }

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

  */
 package org.openzen.zenscript.codemodel.member.ref;
 
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.member.FieldMember;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class FieldMemberRef implements DefinitionMemberRef {
+public class FieldMemberRef extends PropertyRef {
 	public final FieldMember member;
-	public final ITypeID type;
 	
-	public FieldMemberRef(FieldMember member, ITypeID type) {
+	public FieldMemberRef(FieldMember member, GenericMapper mapper) {
+		super(member, mapper);
 		this.member = member;
-		this.type = type;
-	}
-
-	@Override
-	public CodePosition getPosition() {
-		return member.position;
-	}
-
-	@Override
-	public String describe() {
-		return member.describe();
-	}
-
-	@Override
-	public <T> T getTag(Class<T> type) {
-		return member.getTag(type);
-	}
-	
-	public boolean isStatic() {
-		return member.isStatic();
-	}
-	
-	public boolean isFinal() {
-		return member.isFinal();
 	}
 
 	@Override
 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
-
-	@Override
-	public FunctionHeader getHeader() {
-		return null;
-	}
-
-	@Override
-	public MemberAnnotation[] getAnnotations() {
-		return member.annotations;
-	}
 }

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
  */
 public class FunctionalMemberRef implements DefinitionMemberRef {
 	private final FunctionalMember target;
-	public final FunctionHeader header;
 	
-	public FunctionalMemberRef(FunctionalMember target, FunctionHeader header) {
+	private FunctionHeader header;
+	private GenericMapper mapper;
+	
+	public FunctionalMemberRef(FunctionalMember target, GenericMapper mapper) {
 		this.target = target;
-		this.header = header;
+		
+		if (target.header.hasUnknowns) {
+			header = null;
+			this.mapper = mapper;
+		} else {
+			header = mapper.map(target.header);
+			this.mapper = null;
+		}
+	}
+	
+	public boolean accepts(int arguments) {
+		return arguments >= target.header.minParameters && arguments <= target.header.maxParameters;
+	}
+	
+	@Override
+	public FunctionHeader getHeader() {
+		if (header == null) {
+			if (target.header.hasUnknowns)
+				throw new IllegalStateException("member is not yet resolved!");
+			
+			header = mapper.map(target.header);
+			this.mapper = null;
+		}
+		
+		return header;
 	}
 	
 	@Override
 	public DefinitionMemberRef getOverrides() {
 		return target.getOverrides();
 	}
-
-	@Override
-	public FunctionHeader getHeader() {
-		return header;
-	}
 	
 	public BuiltinID getBuiltin() {
 		return target.builtin;

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

 
 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;
 import org.openzen.zenscript.codemodel.member.GetterMember;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class GetterMemberRef implements DefinitionMemberRef {
+public class GetterMemberRef extends PropertyRef {
 	public final GetterMember member;
-	public final ITypeID type;
 	
-	public GetterMemberRef(GetterMember member, ITypeID type) {
+	public GetterMemberRef(GetterMember member, GenericMapper mapper) {
+		super(member, mapper);
+		
 		this.member = member;
-		this.type = type;
-	}
-
-	@Override
-	public CodePosition getPosition() {
-		return member.position;
-	}
-
-	@Override
-	public String describe() {
-		return member.describe();
-	}
-
-	@Override
-	public <T> T getTag(Class<T> type) {
-		return member.getTag(type);
-	}
-	
-	public boolean isStatic() {
-		return member.isStatic();
 	}
 	
 	public Expression get(CodePosition position, Expression target) {
 	public DefinitionMemberRef getOverrides() {
 		return member.getOverrides();
 	}
-
-	@Override
-	public FunctionHeader getHeader() {
-		return member.header;
-	}
-
-	@Override
-	public MemberAnnotation[] getAnnotations() {
-		return member.annotations;
-	}
 }

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.member.ref;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
+import org.openzen.zenscript.codemodel.member.IPropertyMember;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public abstract class PropertyRef implements DefinitionMemberRef {
+	private final IPropertyMember member;
+	
+	private ITypeID type;
+	private GenericMapper mapper;
+	
+	public PropertyRef(IPropertyMember member, GenericMapper mapper) {
+		this.member = member;
+		
+		if (member.getType() == BasicTypeID.UNDETERMINED) {
+			type = null;
+			this.mapper = mapper;
+		} else {
+			type = member.getType().instance(mapper);
+			this.mapper = null;
+		}
+	}
+	
+	public final ITypeID getType() {
+		if (type == null) {
+			if (member.getType() == BasicTypeID.UNDETERMINED)
+				throw new IllegalStateException("Property is not yet resolved!");
+			
+			type = member.getType().instance(mapper);
+			mapper = null;
+		}
+		
+		return type;
+	}
+
+	@Override
+	public final CodePosition getPosition() {
+		return member.getPosition();
+	}
+
+	@Override
+	public final String describe() {
+		return member.describe();
+	}
+
+	@Override
+	public final <T> T getTag(Class<T> type) {
+		return member.getTag(type);
+	}
+	
+	public final boolean isStatic() {
+		return member.isStatic();
+	}
+	
+	public final boolean isFinal() {
+		return member.isFinal();
+	}
+
+	@Override
+	public final FunctionHeader getHeader() {
+		return null;
+	}
+
+	@Override
+	public final MemberAnnotation[] getAnnotations() {
+		return member.getAnnotations();
+	}
+}

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

  */
 package org.openzen.zenscript.codemodel.member.ref;
 
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.member.SetterMember;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class SetterMemberRef implements DefinitionMemberRef {
+public class SetterMemberRef extends PropertyRef {
 	public final SetterMember member;
-	public final ITypeID type;
 	
-	public SetterMemberRef(SetterMember member, ITypeID type) {
+	public SetterMemberRef(SetterMember member, GenericMapper mapper) {
+		super(member, mapper);
+		
 		this.member = member;
-		this.type = type;
-	}
-
-	@Override
-	public CodePosition getPosition() {
-		return member.position;
-	}
-
-	@Override
-	public String describe() {
-		return member.describe();
-	}
-
-	@Override
-	public <T> T getTag(Class<T> type) {
-		return member.getTag(type);
-	}
-	
-	public boolean isStatic() {
-		return member.isStatic();
 	}
 
 	@Override
 	public DefinitionMemberRef getOverrides() {
 		return member.getOverrides();
 	}
-
-	@Override
-	public FunctionHeader getHeader() {
-		return member.header;
-	}
-
-	@Override
-	public MemberAnnotation[] getAnnotations() {
-		return member.annotations;
-	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.CallTranslator;
 import org.openzen.zenscript.codemodel.expression.Expression;
 public class TranslatedOperatorMemberRef extends FunctionalMemberRef {
 	private final CallTranslator translator;
 	
-	public TranslatedOperatorMemberRef(OperatorMember member, FunctionHeader header, CallTranslator translator) {
-		super(member, header);
+	public TranslatedOperatorMemberRef(OperatorMember member, GenericMapper mapper, CallTranslator translator) {
+		super(member, mapper);
 		
 		this.translator = translator;
 	}

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

 	private final DefinitionMemberGroup group;
 	private final ITypeID[] typeArguments;
 	private final boolean allowStaticUsage;
+	private final TypeScope scope;
 	
-	public PartialMemberGroupExpression(CodePosition position, Expression target, DefinitionMemberGroup group, ITypeID[] typeArguments, boolean allowStaticMembers) {
+	public PartialMemberGroupExpression(
+			CodePosition position,
+			TypeScope scope,
+			Expression target,
+			DefinitionMemberGroup group,
+			ITypeID[] typeArguments,
+			boolean allowStaticMembers)
+	{
 		this.position = position;
+		this.scope = scope;
 		this.target = target;
 		this.group = group;
 		this.typeArguments = typeArguments;
 		this.allowStaticUsage = allowStaticMembers;
 	}
 	
-	public PartialMemberGroupExpression(CodePosition position, Expression target, String name, FunctionalMemberRef member, ITypeID[] typeArguments, boolean allowStaticMembers) {
+	public PartialMemberGroupExpression(
+			CodePosition position,
+			TypeScope scope,
+			Expression target,
+			String name,
+			FunctionalMemberRef member,
+			ITypeID[] typeArguments,
+			boolean allowStaticMembers)
+	{
 		this.position = position;
+		this.scope = scope;
 		this.target = target;
 		this.group = DefinitionMemberGroup.forMethod(name, member);
 		this.typeArguments = typeArguments;
 
 	@Override
 	public Expression eval() {
-		return group.getter(position, target, allowStaticUsage);
+		return group.getter(position, scope, target, allowStaticUsage);
 	}
 	
 	@Override
 	public List<ITypeID> getAssignHints() {
 		if (group.getSetter() != null)
-			return Collections.singletonList(group.getSetter().type);
+			return Collections.singletonList(group.getSetter().getType());
 		if (group.getField() != null)
-			return Collections.singletonList(group.getField().type);
+			return Collections.singletonList(group.getField().getType());
 		
 		return Collections.emptyList();
 	}
 	@Override
 	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<ITypeID> hints, int arguments) {
 		List<FunctionHeader> results = group.getMethodMembers().stream()
-				.filter(method -> method.member.header.parameters.length == arguments && !method.member.isStatic())
-				.map(method -> method.member.header)
+				.filter(method -> method.member.accepts(arguments) && !method.member.isStatic())
+				.map(method -> {
+					scope.getPreparer().prepare(method.member.getTarget());
+					return method.member.getHeader();
+				})
 				.collect(Collectors.toList());
 		if (results.isEmpty())
 			System.out.println("!");
 	
 	@Override
 	public IPartialExpression capture(CodePosition position, LambdaClosure closure) {
-		return new PartialMemberGroupExpression(position, target.capture(position, closure).eval(), group, typeArguments, allowStaticUsage);
+		return new PartialMemberGroupExpression(position, scope, target.capture(position, closure).eval(), group, typeArguments, allowStaticUsage);
 	}
 
 	@Override

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

  * @author Hoofdgebruiker
  */
 public class PartialStaticMemberGroupExpression implements IPartialExpression {
-	public static PartialStaticMemberGroupExpression forMethod(CodePosition position, String name, ITypeID target, FunctionalMemberRef method, ITypeID[] typeArguments) {
+	public static PartialStaticMemberGroupExpression forMethod(CodePosition position, TypeScope scope, String name, ITypeID target, FunctionalMemberRef method, ITypeID[] typeArguments) {
 		DefinitionMemberGroup group = new DefinitionMemberGroup(true, name);
 		group.addMethod(method, TypeMemberPriority.SPECIFIED);
-		return new PartialStaticMemberGroupExpression(position, target, group, typeArguments);
+		return new PartialStaticMemberGroupExpression(position, scope, target, group, typeArguments);
 	}
 	
 	private final CodePosition position;
+	private final TypeScope scope;
 	private final ITypeID target;
 	private final DefinitionMemberGroup group;
 	private final ITypeID[] typeArguments;
 	
-	public PartialStaticMemberGroupExpression(CodePosition position, ITypeID target, DefinitionMemberGroup group, ITypeID[] typeArguments) {
+	public PartialStaticMemberGroupExpression(CodePosition position, TypeScope scope, ITypeID target, DefinitionMemberGroup group, ITypeID[] typeArguments) {
 		this.position = position;
+		this.scope = scope;
 		this.group = group;
 		this.target = target;
 		this.typeArguments = typeArguments;
 	
 	@Override
 	public Expression eval() {
-		return group.staticGetter(position);
+		return group.staticGetter(position, scope);
 	}
 
 	@Override
 	@Override
 	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<ITypeID> hints, int arguments) {
 		return group.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 List<ITypeID> getAssignHints() {
 		if (group.getSetter() != null)
-			return Collections.singletonList(group.getSetter().type);
+			return Collections.singletonList(group.getSetter().getType());
 		if (group.getField() != null)
-			return Collections.singletonList(group.getField().type);
+			return Collections.singletonList(group.getField().getType());
 		
 		return Collections.emptyList();
 	}

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

 		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) {
-		return scope.getTypeMembers(type).getStaticMemberExpression(position, name);
+		return scope.getTypeMembers(type).getStaticMemberExpression(position, scope, name);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
 public abstract class BaseScope implements TypeScope {
 	public abstract IPartialExpression get(CodePosition position, GenericName name);
 	
-	public abstract ITypeID getType(CodePosition position, List<GenericName> name);
-	
 	public abstract LoopStatement getLoop(String name);
 	
 	public abstract FunctionHeader getFunctionHeader();
 	
-	public abstract ITypeID getThisType();
-	
 	@Override
 	public TypeMembers getTypeMembers(ITypeID type) {
 		return getMemberCache().get(type);

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 
 /**
  *
 	public AnnotationDefinition getAnnotation(String name) {
 		return parent.getAnnotation(name);
 	}
+
+	@Override
+	public TypeMemberPreparer getPreparer() {
+		return parent.getPreparer();
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/CompileTypeScope.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.scope;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.partial.IPartialExpression;
+import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
+import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class CompileTypeScope extends BaseScope {
+	private final BaseScope outer;
+	private final Map<String, TypeParameter> typeParameters = new HashMap<>();
+
+	public CompileTypeScope(BaseScope outer, TypeParameter[] parameters) {
+		this.outer = outer;
+
+		if (parameters != null)
+			for (TypeParameter parameter : parameters)
+				typeParameters.put(parameter.name, parameter);
+	}
+
+	@Override
+	public LocalMemberCache getMemberCache() {
+		return outer.getMemberCache();
+	}
+
+	@Override
+	public IPartialExpression get(CodePosition position, GenericName name) {
+		if (typeParameters.containsKey(name.name) && !name.hasArguments())
+			return new PartialTypeExpression(position, getTypeRegistry().getGeneric(typeParameters.get(name.name)), name.arguments);
+
+		return outer.get(position, name);
+	}
+
+	@Override
+	public ITypeID getType(CodePosition position, List<GenericName> name) {
+		if (typeParameters.containsKey(name.get(0).name) && name.size() == 1 && !name.get(0).hasArguments()) {
+			return getTypeRegistry().getGeneric(typeParameters.get(name.get(0).name));
+		}
+
+		return outer.getType(position, name);
+	}
+
+	@Override
+	public LoopStatement getLoop(String name) {
+		return null;
+	}
+
+	@Override
+	public FunctionHeader getFunctionHeader() {
+		return null;
+	}
+
+	@Override
+	public ITypeID getThisType() {
+		throw new UnsupportedOperationException("Not available at this stage");
+	}
+
+	@Override
+	public Function<CodePosition, Expression> getDollar() {
+		return outer.getDollar();
+	}
+
+	@Override
+	public IPartialExpression getOuterInstance(CodePosition position) {
+		return null;
+	}
+
+	@Override
+	public AnnotationDefinition getAnnotation(String name) {
+		return outer.getAnnotation(name);
+	}
+
+	@Override
+	public TypeMemberPreparer getPreparer() {
+		return outer.getPreparer();
+	}
+}

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 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.TypeMembers;
 
 /**
 			if (members.hasInnerType(name.name))
 				return new PartialTypeExpression(position, members.getInnerType(position, name), name.arguments);
 			if (members.hasMember(name.name) && !name.hasArguments())
-				return members.getMemberExpression(position, new ThisExpression(position, type), name, true);
+				return members.getMemberExpression(position, this, new ThisExpression(position, type), name, true);
 		} else if (innerTypes.containsKey(name.name)) {
 			return new PartialTypeExpression(position, getTypeRegistry().getForDefinition(innerTypes.get(name).get(), name.arguments), name.arguments);
 		}
 	public AnnotationDefinition getAnnotation(String name) {
 		return outer.getAnnotation(name);
 	}
+
+	@Override
+	public TypeMemberPreparer getPreparer() {
+		return outer.getPreparer();
+	}
 }

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 
 /**
  *
 	public AnnotationDefinition getAnnotation(String name) {
 		return outer.getAnnotation(name);
 	}
+
+	@Override
+	public TypeMemberPreparer getPreparer() {
+		return outer.getPreparer();
+	}
 }

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

  */
 package org.openzen.zenscript.codemodel.scope;
 
-import java.util.HashMap;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.PackageDefinitions;
+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.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialGlobalExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
-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.ISymbol;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class FileScope extends BaseScope {
+	private final TypeResolutionContext context;
 	private final LocalMemberCache memberCache;
-	private final ZSPackage rootPackage;
-	private final PackageDefinitions packageDefinitions;
-	private final GlobalTypeRegistry globalRegistry;
-	private final Map<String, HighLevelDefinition> importedTypes = new HashMap<>();
-	private final Map<String, ISymbol> globalSymbols;
-	private final Map<String, AnnotationDefinition> annotations = new HashMap<>();
+	private final Map<String, ISymbol> globals;
+	private final TypeMemberPreparer preparer;
 	
 	public FileScope(
-			ZSPackage rootPackage,
-			PackageDefinitions packageDefinitions,
-			GlobalTypeRegistry globalRegistry,
+			TypeResolutionContext context,
 			List<ExpansionDefinition> expansions,
-			Map<String, ISymbol> globalSymbols,
-			List<AnnotationDefinition> annotations) {
-		this.rootPackage = rootPackage;
-		this.packageDefinitions = packageDefinitions;
-		this.globalRegistry = globalRegistry;
-		this.globalSymbols = globalSymbols;
+			Map<String, ISymbol> globals,
+			TypeMemberPreparer preparer) {
+		this.context = context;
+		this.globals = globals;
+		this.preparer = preparer;
 		
-		memberCache = new LocalMemberCache(globalRegistry, expansions);
-		
-		for (AnnotationDefinition annotation : annotations) {
-			this.annotations.put(annotation.getAnnotationName(), annotation);
-		}
+		memberCache = new LocalMemberCache(context.getTypeRegistry(), expansions);
 	}
 	
 	@Override
 	public LocalMemberCache getMemberCache() {
 		return memberCache;
 	}
-	
-	public void register(String name, HighLevelDefinition type) {
-		importedTypes.put(name, type);
-	}
 
 	@Override
 	public IPartialExpression get(CodePosition position, GenericName name) {
-		if (importedTypes.containsKey(name.name))
-			return new PartialTypeExpression(position, getTypeRegistry().getForDefinition(importedTypes.get(name.name), name.arguments), name.arguments);
-		
-		HighLevelDefinition localDefinition = packageDefinitions.getDefinition(name.name);
-		if (localDefinition != null)
-			return new PartialTypeExpression(position, globalRegistry.getForDefinition(localDefinition, name.arguments), name.arguments);
+		ITypeID type = context.getType(position, Collections.singletonList(name));
+		if (type != null)
+			return new PartialTypeExpression(position, type, name.arguments);
 		
-		if (globalSymbols.containsKey(name.name)) {
-			IPartialExpression resolution = globalSymbols.get(name.name).getExpression(position, globalRegistry, name.arguments);
+		if (globals.containsKey(name.name)) {
+			IPartialExpression resolution = globals.get(name.name).getExpression(position, this, name.arguments);
 			return new PartialGlobalExpression(position, name.name, resolution, name.arguments);
 		}
 		
-		return rootPackage.getMember(position, globalRegistry, name);
+		return null;
 	}
 
 	@Override
 	public ITypeID getType(CodePosition position, List<GenericName> name) {
-		if (importedTypes.containsKey(name.get(0).name)) {
-			HighLevelDefinition definition = importedTypes.get(name.get(0).name);
-			ITypeID type = getTypeRegistry().getForDefinition(definition, name.get(0).arguments);
-			for (int i = 1; i < name.size(); i++)
-				type = getTypeMembers(type).getInnerType(position, name.get(i));
+		ITypeID type = context.getType(position, name);
+		if (type != null)
 			return type;
-		}
 		
-		HighLevelDefinition localDefinition = packageDefinitions.getDefinition(name.get(0).name);
-		if (localDefinition != null) {
-			DefinitionTypeID type = globalRegistry.getForDefinition(localDefinition, name.get(0).arguments);
-			for (int i = 1; i < name.size(); i++) {
-				type = getTypeMembers(type).getInnerType(position, name.get(i));
-				if (type == null)
-					break;
-			}
-			
-			// TODO: take care of non-static inner classes in generic classes!
-			if (type != null && name.get(name.size() - 1).getNumberOfArguments() != type.definition.getNumberOfGenericParameters())
-				throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_INVALID_NUMBER, "Invalid number of type arguments");
-			
-			if (type != null)
-				return type;
-		} else if (globalSymbols.containsKey(name.get(0).name)) {
-			ITypeID type = globalSymbols.get(name.get(0).name).getType(position, globalRegistry, name.get(0).arguments);
+		if (globals.containsKey(name.get(0).name)) {
+			type = globals.get(name.get(0).name).getType(position, context, name.get(0).arguments);
 			for (int i = 1; i < name.size(); i++) {
 				type = getTypeMembers(type).getInnerType(position, name.get(i));
 				if (type == null)
 				return type;
 		}
 		
-		return rootPackage.getType(position, this, name);
+		return null;
 	}
 
 	@Override
 
 	@Override
 	public AnnotationDefinition getAnnotation(String name) {
-		return annotations.get(name);
+		return context.getAnnotation(name);
+	}
+
+	@Override
+	public TypeMemberPreparer getPreparer() {
+		return preparer;
 	}
 }

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 
 /**
  *
 	public AnnotationDefinition getAnnotation(String name) {
 		return outer.getAnnotation(name);
 	}
+
+	@Override
+	public TypeMemberPreparer getPreparer() {
+		return outer.getPreparer();
+	}
 }

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 
 /**
  *
 	public AnnotationDefinition getAnnotation(String name) {
 		return outer.getAnnotation(name);
 	}
+
+	@Override
+	public TypeMemberPreparer getPreparer() {
+		return outer.getPreparer();
+	}
 }

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 
 /**
  *
 	public AnnotationDefinition getAnnotation(String name) {
 		return outer.getAnnotation(name);
 	}
+
+	@Override
+	public TypeMemberPreparer getPreparer() {
+		return outer.getPreparer();
+	}
 }

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 
 /**
  *
 	public AnnotationDefinition getAnnotation(String name) {
 		return file.getAnnotation(name);
 	}
+
+	@Override
+	public TypeMemberPreparer getPreparer() {
+		return file.getPreparer();
+	}
 }

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 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.outer = outer;
 		this.implementation = implementation;
 		
-		TypeMembers interfaceMembers = outer.getMemberCache().get(implementation.type);
-		members = new TypeMembers(outer.getMemberCache(), implementation.type);
+		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
 		if (members.hasInnerType(name.name))
 			return new PartialTypeExpression(position, members.getInnerType(position, name), name.arguments);
 		if (members.hasMember(name.name))
-			return members.getMemberExpression(position, new ThisExpression(position, outer.getThisType()), name, true);
+			return members.getMemberExpression(position, this, new ThisExpression(position, outer.getThisType()), name, true);
 		
 		return outer.get(position, name);
 	}
 	public AnnotationDefinition getAnnotation(String name) {
 		return outer.getAnnotation(name);
 	}
+
+	@Override
+	public TypeMemberPreparer getPreparer() {
+		return outer.getPreparer();
+	}
 }

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 
 /**
  *
 	public AnnotationDefinition getAnnotation(String name) {
 		return outer.getAnnotation(name);
 	}
+
+	@Override
+	public TypeMemberPreparer getPreparer() {
+		return outer.getPreparer();
+	}
 }

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

 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 
 /**
  *
 	public AnnotationDefinition getAnnotation(String name) {
 		return outer.getAnnotation(name);
 	}
+
+	@Override
+	public TypeMemberPreparer getPreparer() {
+		return outer.getPreparer();
+	}
 }

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

 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 
 /**
  *

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

  */
 package org.openzen.zenscript.codemodel.scope;
 
-import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
+import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public interface TypeScope {
+public interface TypeScope extends TypeResolutionContext {
 	public LocalMemberCache getMemberCache();
 	
 	default TypeMembers getTypeMembers(ITypeID type) {
 		return getMemberCache().get(type);
 	}
 	
+	@Override
 	default GlobalTypeRegistry getTypeRegistry() {
 		return getMemberCache().getRegistry();
 	}
 	
-	public AnnotationDefinition getAnnotation(String name);
+	TypeMemberPreparer getPreparer();
 }

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

  */
 public class DefinitionTypeID implements ITypeID {
 	public static DefinitionTypeID forType(HighLevelDefinition definition) {
-		if (definition.genericParameters != null)
+		if (definition.genericParameters != null && definition.genericParameters.length > 0)
 			throw new IllegalArgumentException("Definition has type arguments!");
 		
 		return new DefinitionTypeID(null, definition, ITypeID.NONE);
 	}
 	
-	private static final OuterTypeEntry[] NO_OUTER_ENTRIES = new OuterTypeEntry[0];
-	
 	public final HighLevelDefinition definition;
 	public final ITypeID[] typeParameters;
 	public final DefinitionTypeID outer;
 			throw new NullPointerException("typeParameters cannot be null");
 		if (typeParameters.length != definition.getNumberOfGenericParameters())
 			throw new IllegalArgumentException("Wrong number of type parameters!");
+		if (definition.isInnerDefinition() && !definition.isStatic() && outer == null)
+			throw new IllegalArgumentException("Inner definition requires outer instance");
+		if ((!definition.isInnerDefinition() || definition.isStatic()) && outer != null)
+			throw new IllegalArgumentException("Static inner definition must not have outer instance");
 		
 		this.definition = definition;
 		this.typeParameters = typeParameters;
 	public DefinitionTypeID instance(GenericMapper mapper) {
 		if (!hasTypeParameters() && outer == null)
 			return this;
+		if (mapper.getMapping().isEmpty())
+			return this;
 		
 		ITypeID[] instancedArguments = ITypeID.NONE;
 		if (hasTypeParameters()) {
 		final DefinitionTypeID other = (DefinitionTypeID) obj;
 		return this.definition == other.definition
 				&& Arrays.deepEquals(this.typeParameters, other.typeParameters)
-				&& outer == this.outer;
+				&& Objects.equals(outer, this.outer);
 	}
 	
 	@Override
 	public String toString() {
-		if (!hasTypeParameters()) {
+		if (!hasTypeParameters() && outer == null)
 			return definition.name;
-		} else {
-			StringBuilder result = new StringBuilder();
-			result.append(definition.name);
-			result.append('<');
-			for (int i = 0; i < typeParameters.length; i++) { 
-				if (i > 0)
-					result.append(", ");
-				result.append(typeParameters[i].toString());
-			}
-			result.append('>');
-			return result.toString();
+		
+		StringBuilder result = new StringBuilder();
+		if (outer != null)
+			result.append(outer.toString()).append('.');
+		
+		result.append(definition.name);
+		result.append('<');
+		for (int i = 0; i < typeParameters.length; i++) { 
+			if (i > 0)
+				result.append(", ");
+			result.append(typeParameters[i].toString());
 		}
+		result.append('>');
+		return result.toString();
 	}
 
 	@Override
 	public boolean isDestructible() {
 		return definition.isDestructible();
 	}
-	
-	private class OuterTypeEntry {
-		private final TypeParameter parameter;
-		private final ITypeID type;
-		
-		public OuterTypeEntry(TypeParameter parameter, ITypeID type) {
-			this.parameter = parameter;
-			this.type = type;
-		}
 
-		@Override
-		public int hashCode() {
-			int hash = 3;
-			hash = 11 * hash + Objects.hashCode(this.parameter);
-			hash = 11 * hash + Objects.hashCode(this.type);
-			return hash;
-		}
-
-		@Override
-		public boolean equals(Object obj) {
-			if (this == obj) {
-				return true;
-			}
-			if (obj == null) {
-				return false;
-			}
-			if (getClass() != obj.getClass()) {
-				return false;
-			}
-			final OuterTypeEntry other = (OuterTypeEntry) obj;
-			if (!Objects.equals(this.parameter, other.parameter)) {
-				return false;
-			}
-			if (!Objects.equals(this.type, other.type)) {
-				return false;
-			}
-			return true;
-		}
+	public DefinitionTypeID getInnerType(GenericName name, GlobalTypeRegistry registry) {
+		HighLevelDefinition type = definition.getInnerType(name.name);
+		return registry.getForDefinition(type, name.arguments, this);
 	}
 }

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

  */
 package org.openzen.zenscript.codemodel.type;
 
+import java.util.List;
+
 /**
  *
  * @author Hoofdgebruiker
 		return arguments.length == 0;
 	}
 	
+	public static ITypeID getInnerType(GlobalTypeRegistry registry, DefinitionTypeID type, List<GenericName> name, int index) {
+		while (index < name.size()) {
+			GenericName innerName = name.get(index++);
+			type = type.getInnerType(innerName, registry);
+			if (type == null)
+				return null;
+		}
+
+		return type;
+	}
+	
 	@Override
 	public String toString() {
 		StringBuilder result = new StringBuilder(name);

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

  */
 package org.openzen.zenscript.codemodel.type;
 
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
  *
 	}
 	
 	public ITypeID getOptional(ITypeID original) {
-		return getModified(TypeMembers.MODIFIER_OPTIONAL, original);
+		return getModified(ModifiedTypeID.MODIFIER_OPTIONAL, original);
 	}
 	
 	public ITypeID getModified(int modifiers, ITypeID type) {

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

 package org.openzen.zenscript.codemodel.type;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public interface ISymbol {
-	public IPartialExpression getExpression(CodePosition position, GlobalTypeRegistry types, ITypeID[] typeArguments);
+	public IPartialExpression getExpression(CodePosition position, BaseScope scope, ITypeID[] typeArguments);
 	
-	public ITypeID getType(CodePosition position, GlobalTypeRegistry types, ITypeID[] typeArguments);
+	public ITypeID getType(CodePosition position, TypeResolutionContext context, ITypeID[] typeArguments);
 }

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

 		return null;
 	}
 	
-	public boolean isOptional();
+	public default boolean isOptional() {
+		return false;
+	}
 	
-	public default ITypeID getOptionalBase() {
-		return this;
+	public default boolean isConst() {
+		return false;
 	}
 	
-	public boolean isConst();
+	public default boolean isImmutable() {
+		return false;
+	}
+	
+	public default ITypeID withoutOptional() {
+		throw new UnsupportedOperationException("Not an optional type");
+	}
+	
+	public default ITypeID withoutConst() {
+		throw new UnsupportedOperationException("Not a const type");
+	}
 	
-	public default ITypeID unwrap() {
-		return this;
+	public default ITypeID withoutImmutable() {
+		throw new UnsupportedOperationException("Not an immutable type");
 	}
 	
 	public boolean hasDefaultValue();

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ModifiedTypeID implements ITypeID {
+	public static final int MODIFIER_OPTIONAL = 1;
+	public static final int MODIFIER_CONST = 2;
+	public static final int MODIFIER_IMMUTABLE = 4;
+	
 	public final int modifiers;
 	public final ITypeID baseType;
 	private final ITypeID normalized;
+	private final GlobalTypeRegistry registry;
 	
 	public ModifiedTypeID(GlobalTypeRegistry registry, int modifiers, ITypeID baseType) {
 		this.modifiers = modifiers;
 		this.baseType = baseType;
+		this.registry = registry;
 		
 		normalized = baseType.getNormalized() == baseType ? this : registry.getModified(modifiers, baseType.getNormalized());
 	}
 
 	@Override
 	public boolean isOptional() {
-		return (modifiers & TypeMembers.MODIFIER_OPTIONAL) > 0;
+		return (modifiers & MODIFIER_OPTIONAL) > 0;
 	}
 	
+	@Override
 	public boolean isImmutable() {
-		return (modifiers & TypeMembers.MODIFIER_IMMUTABLE) > 0;
+		return (modifiers & MODIFIER_IMMUTABLE) > 0;
 	}
 
 	@Override
 	public boolean isConst() {
-		return (modifiers & TypeMembers.MODIFIER_CONST) > 0;
+		return (modifiers & MODIFIER_CONST) > 0;
+	}
+	
+	@Override
+	public ITypeID withoutOptional() {
+		return without(MODIFIER_OPTIONAL);
+	}
+	
+	@Override
+	public ITypeID withoutImmutable() {
+		return without(MODIFIER_IMMUTABLE);
+	}
+	
+	@Override
+	public ITypeID withoutConst() {
+		return without(MODIFIER_CONST);
 	}
 	
 	@Override
 		return baseType.isDefinition(definition);
 	}
 	
-	@Override
-	public ITypeID unwrap() {
-		return baseType;
+	private ITypeID without(int modifiers) {
+		int newModifiers = this.modifiers & ~modifiers;
+		return newModifiers == 0 ? baseType : registry.getModified(newModifiers, baseType);
 	}
 
 	@Override
 
 	@Override
 	public boolean hasDefaultValue() {
-		return baseType.hasDefaultValue();
+		return isOptional() || baseType.hasDefaultValue();
 	}
 
 	@Override
 	
 	@Override
 	public String toString() {
-		return "const " + baseType.toString();
+		StringBuilder result = new StringBuilder();
+		if ((modifiers & MODIFIER_IMMUTABLE) > 0)
+			result.append("immutable ");
+		if ((modifiers & MODIFIER_CONST) > 0)
+			result.append("const ");
+		result.append(baseType.toString());
+		if ((modifiers & MODIFIER_OPTIONAL) > 0)
+			result.append("?");
+		return result.toString();
 	}
 }

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

 
 import org.openzen.zencode.shared.CodePosition;
 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.PartialTypeExpression;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
 
 /**
  *
 	}
 	
 	@Override
-	public IPartialExpression getExpression(CodePosition position, GlobalTypeRegistry types, ITypeID[] typeArguments) {
-		return new PartialTypeExpression(position, types.getForDefinition(definition, typeArguments), typeArguments);
+	public IPartialExpression getExpression(CodePosition position, BaseScope scope, ITypeID[] typeArguments) {
+		return new PartialTypeExpression(position, scope.getTypeRegistry().getForDefinition(definition, typeArguments), typeArguments);
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, GlobalTypeRegistry types, ITypeID[] typeArguments) {
-		return types.getForDefinition(definition, typeArguments);
+	public ITypeID getType(CodePosition position, TypeResolutionContext context, ITypeID[] typeArguments) {
+		return context.getTypeRegistry().getForDefinition(definition, typeArguments);
 	}
 }

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

 	
 	public FunctionalMemberRef getUnaryMethod() {
 		for (TypeMember<FunctionalMemberRef> method : methods)
-			if (method.member.header.parameters.length == 0)
+			if (method.member.getHeader().parameters.length == 0)
 				return method.member;
 		
 		return null;
 	
 	public boolean hasMethod(FunctionHeader header) {
 		for (TypeMember<FunctionalMemberRef> method : methods) {
-			if (method.member.header.isEquivalentTo(header))
+			if (method.member.getHeader().isEquivalentTo(header))
 				return true;
 		}
 		
 	}
 	
 	public void addMethod(FunctionalMemberRef method, TypeMemberPriority priority) {
-		for (int i = 0; i < methods.size(); i++) {
-			if (methods.get(i).member.header.isEquivalentTo(method.header)) {
+		/*for (int i = 0; i < methods.size(); i++) {
+			if (methods.get(i).member.getHeader().isEquivalentTo(method.getHeader())) {
 				methods.set(i, methods.get(i).resolve(new TypeMember<>(priority, method)));
 				return;
 			}
-		}
+		}*/
 		
 		methods.add(new TypeMember<>(priority, method));
 	}
 	
-	public Expression getter(CodePosition position, Expression target, boolean allowStaticUsage) {
+	public Expression getter(CodePosition position, TypeScope scope, Expression target, boolean allowStaticUsage) {
 		if (getter != null) {
 			if (getter.member.isStatic()) {
 				if (!allowStaticUsage)
 				return getter.member.getStatic(position);
 			}
 			
+			scope.getPreparer().prepare(getter.member.member);
 			return getter.member.get(position, target);
 		} else if (field != null) {
 			if (field.member.isStatic()) {
 				return new GetStaticFieldExpression(position, field.member);
 			}
 			
+			scope.getPreparer().prepare(field.member.member);
 			return new GetFieldExpression(position, target, field.member);
 		} else {
 			throw new CompileException(position, CompileExceptionCode.MEMBER_NO_GETTER, "Value is not a property");
 				if (!allowStaticUsage)
 					throw new CompileException(position, CompileExceptionCode.USING_STATIC_ON_INSTANCE, "This field is static");
 				
-				return new StaticSetterExpression(position, setter.member, value.castImplicit(position, scope, setter.member.type));
+				scope.getPreparer().prepare(setter.member.member);
+				return new StaticSetterExpression(position, setter.member, value.castImplicit(position, scope, setter.member.getType()));
 			}
 			
-			return new SetterExpression(position, target, setter.member, value.castImplicit(position, scope, setter.member.type));
+			scope.getPreparer().prepare(setter.member.member);
+			return new SetterExpression(position, target, setter.member, value.castImplicit(position, scope, setter.member.getType()));
 		} else if (field != null) {
 			// TODO: perform proper checks on val fields
 			//if (field.isFinal)
 				if (!allowStaticUsage)
 					throw new CompileException(position, CompileExceptionCode.USING_STATIC_ON_INSTANCE, "This field is static");
 				
-				return new SetStaticFieldExpression(position, field.member, value.castImplicit(position, scope, field.member.type));
+				scope.getPreparer().prepare(field.member.member);
+				return new SetStaticFieldExpression(position, field.member, value.castImplicit(position, scope, field.member.getType()));
 			}
 			
-			return new SetFieldExpression(position, target, field.member, value.castImplicit(position, scope, field.member.type));
+			scope.getPreparer().prepare(field.member.member);
+			return new SetFieldExpression(position, target, field.member, value.castImplicit(position, scope, field.member.getType()));
 		} else {
 			throw new CompileException(position, CompileExceptionCode.MEMBER_NO_SETTER, "Value is not settable");
 		}
 	}
 	
-	public Expression staticGetter(CodePosition position) {
+	public Expression staticGetter(CodePosition position, TypeScope scope) {
 		if (constant != null) {
 			return new ConstExpression(position, constant.member);
 		} else if (getter != null) {
 			if (!getter.member.isStatic())
 				throw new CompileException(position, CompileExceptionCode.MEMBER_NOT_STATIC, "This getter is not static");
 			
+			scope.getPreparer().prepare(getter.member.member);
 			return getter.member.getStatic(position);
 		} else if (field != null) {
 			if (!field.member.isStatic())
 				throw new CompileException(position, CompileExceptionCode.MEMBER_NOT_STATIC, "This field is not static");
 			
+			scope.getPreparer().prepare(field.member.member);
 			return new GetStaticFieldExpression(position, field.member);
 		} else {
 			throw new CompileException(position, CompileExceptionCode.MEMBER_NO_GETTER, "Member is not gettable");
 			if (!getter.member.isStatic())
 				throw new CompileException(position, CompileExceptionCode.MEMBER_NOT_STATIC, "This getter is not static");
 			
-			return new StaticSetterExpression(position, setter.member, value.castImplicit(position, scope, setter.member.type));
+			scope.getPreparer().prepare(setter.member.member);
+			return new StaticSetterExpression(position, setter.member, value.castImplicit(position, scope, setter.member.getType()));
 		} else if (field != null) {
 			//if (field.member.isFinal)
 			//	throw new CompileException(position, CompileExceptionCode.MEMBER_IS_FINAL, "This field cannot be modified");
 			if (!field.member.isStatic())
 				throw new CompileException(position, CompileExceptionCode.MEMBER_NOT_STATIC, "This field is not static");
 			
-			return new SetStaticFieldExpression(position, field.member, value.castImplicit(position, scope, field.member.type));
+			scope.getPreparer().prepare(field.member.member);
+			return new SetStaticFieldExpression(position, field.member, value.castImplicit(position, scope, field.member.getType()));
 		} else {
 			throw new CompileException(position, CompileExceptionCode.MEMBER_NO_SETTER, "Member is not settable");
 		}
 			result[i] = new ArrayList<>();
 		
 		for (TypeMember<FunctionalMemberRef> method : methods) {
-			FunctionHeader header = method.member.header;
+			FunctionHeader header = method.member.getHeader();
 			if (header.parameters.length != arguments)
 				continue;
 			
 	
 	public Expression call(CodePosition position, TypeScope scope, Expression target, CallArguments arguments, boolean allowStaticUsage) {
 		FunctionalMemberRef method = selectMethod(position, scope, arguments, true, allowStaticUsage);
-		FunctionHeader instancedHeader = method.header.fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
 		for (int i = 0; i < arguments.arguments.length; i++) {
 			arguments.arguments[i] = arguments.arguments[i].castImplicit(position, scope, instancedHeader.parameters[i].type);
 		}
 		
+		scope.getPreparer().prepare(method.getTarget());
 		return method.call(position, target, instancedHeader, arguments, scope);
 	}
 	
 		if (!method.isOperator()) {
 			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Member is not an operator");
 		}
-		return new PostCallExpression(position, target, method, method.header);
+		scope.getPreparer().prepare(method.getTarget());
+		return new PostCallExpression(position, target, method, method.getHeader());
 	}
 	
 	public Expression callWithComparator(
 			CallArguments arguments,
 			CompareType compareType) {
 		FunctionalMemberRef method = selectMethod(position, scope, arguments, true, false);
-		FunctionHeader instancedHeader = method.header.fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
 		return method.callWithComparator(position, compareType, target, instancedHeader, arguments, scope);
 	}
 	
 	public Expression callStatic(CodePosition position, ITypeID target, TypeScope scope, CallArguments arguments) {
 		FunctionalMemberRef method = selectMethod(position, scope, arguments, false, true);
-		FunctionHeader instancedHeader = method.header.fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
 		return method.callStatic(position, target, instancedHeader, arguments, scope);
 	}
 	
 			if (!(method.member.isStatic() ? allowStatic : allowNonStatic))
 				continue;
 			
-			FunctionHeader header = method.member.header;
+			FunctionHeader header = method.member.getHeader();
 			if (header.matchesExactly(arguments, scope))
 				return method.member;
 		}
 		for (TypeMember<FunctionalMemberRef> method : methods) {
 			if (!(method.member.isStatic() ? allowStatic : allowNonStatic))
 				continue;
+			if (arguments.arguments.length < method.member.getHeader().minParameters || arguments.arguments.length > method.member.getHeader().maxParameters)
+				continue;
+			
+			scope.getPreparer().prepare(method.member.getTarget());
 			
-			FunctionHeader header = method.member.header;
+			FunctionHeader header = method.member.getHeader();
 			if (!header.matchesImplicitly(arguments, scope))
 				continue;
 			
 			if (selected != null) {
 				StringBuilder explanation = new StringBuilder();
-				explanation.append("Function A: ").append(selected.header.toString()).append("\n");
-				explanation.append("Function B: ").append(method.member.header.toString());
+				explanation.append("Function A: ").append(selected.getHeader().toString()).append("\n");
+				explanation.append("Function B: ").append(method.member.getHeader().toString());
 				throw new CompileException(position, CompileExceptionCode.CALL_AMBIGUOUS, "Ambiguous call; multiple methods match:\n" + explanation.toString());
 			}
 			
 					continue;
 				}
 				
-				message.append(method.member.header.explainWhyIncompatible(scope, arguments)).append("\n");
+				message.append(method.member.getHeader().explainWhyIncompatible(scope, arguments)).append("\n");
 			}
 			
 			throw new CompileException(position, CompileExceptionCode.CALL_NO_VALID_METHOD, "No matching method found for " + name + ":\n" + message.toString());
 	public FunctionalMemberRef getOverride(CodePosition position, TypeScope scope, FunctionalMember member) {
 		List<FunctionalMemberRef> candidates = new ArrayList<>();
 		for (TypeMember<FunctionalMemberRef> method : methods) {
-			if (member.header.canOverride(scope, method.member.header))
+			if (member.header.canOverride(scope, method.member.getHeader()))
 				candidates.add(method.member);
 		}
 		

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

 import static org.openzen.zencode.shared.CodePosition.BUILTIN;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 
 /**
  *
 			DefinitionMemberGroup group = members.getOrCreateGroup(OperatorType.EQUALS);
 			DefinitionMemberGroup inverse = members.getOrCreateGroup(OperatorType.NOTEQUALS);
 			for (TypeMember<FunctionalMemberRef> method : group.getMethodMembers()) {
-				if (!inverse.hasMethod(method.member.header)) {
-					notequals(definition, BuiltinID.AUTOOP_NOTEQUALS, method.member.header.parameters[0].type);
+				if (!inverse.hasMethod(method.member.getHeader())) {
+					notequals(definition, BuiltinID.AUTOOP_NOTEQUALS, method.member.getHeader().parameters[0].type);
 				}
 			}
 		}
 			}
 		}
 		
+		if (definition instanceof InterfaceDefinition) {
+			InterfaceDefinition interfaceDefinition = (InterfaceDefinition)definition;
+			for (ITypeID baseType : interfaceDefinition.baseInterfaces)
+				cache.get(baseType.instance(mapper)).copyMembersTo(type.definition.position, members, TypeMemberPriority.INHERITED);
+		}
+		
 		if (type.superType != null) {
-			cache.get(type.superType).copyMembersTo(type.definition.position, members, TypeMemberPriority.INHERITED);
+			cache.get(type.superType.instance(mapper)).copyMembersTo(type.definition.position, members, TypeMemberPriority.INHERITED);
 		} else {
 			getter(definition, OBJECT_HASHCODE, "objectHashCode", BasicTypeID.INT);
 		}
 	
 	private void castedTargetCall(OperatorMember member, BuiltinID casterBuiltin) {
 		CasterMemberRef caster = castImplicitRef(member.definition, casterBuiltin, member.header.parameters[0].type);
-		TranslatedOperatorMemberRef method = new TranslatedOperatorMemberRef(member, member.header, 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(emptyMapper).call(call.position, caster.cast(call.position, call.target, true), call.arguments, call.scope));
 		members.getOrCreateGroup(member.operator).addMethod(method, TypeMemberPriority.SPECIFIED);
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/TypeMemberPreparer.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.member;
+
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface TypeMemberPreparer {
+	void prepare(IDefinitionMember member);
+}

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

 import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
-import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.member.InnerDefinition;
-import org.openzen.zenscript.codemodel.member.MethodMember;
-import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.codemodel.member.ref.CasterMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
  * @author Hoofdgebruiker
  */
 public final class TypeMembers {
-	public static final int MODIFIER_OPTIONAL = 1;
-	public static final int MODIFIER_CONST = 2;
-	public static final int MODIFIER_IMMUTABLE = 4;
-	
 	private final LocalMemberCache cache;
 	public final ITypeID type;
 	
 	public TypeMembers(LocalMemberCache cache, ITypeID type) {
 		if (type == null)
 			throw new NullPointerException("Type must not be null!");
+		if (type == BasicTypeID.UNDETERMINED)
+			throw new IllegalArgumentException("Cannot retrieve members of undetermined type");
 		
 		this.cache = cache;
 		this.type = type;
 		if (operator == CompareType.EQ) {
 			DefinitionMemberGroup equal = getOrCreateGroup(OperatorType.EQUALS);
 			for (TypeMember<FunctionalMemberRef> member : equal.getMethodMembers()) {
-				if (member.member.header.accepts(scope, right))
+				if (member.member.getHeader().accepts(scope, right))
 					return equal.call(position, scope, left, new CallArguments(right), false);
 			}
 		} else if (operator == CompareType.NE) {
 			DefinitionMemberGroup equal = getOrCreateGroup(OperatorType.NOTEQUALS);
 			for (TypeMember<FunctionalMemberRef> member : equal.getMethodMembers()) {
-				if (member.member.header.accepts(scope, right)) {
+				if (member.member.getHeader().accepts(scope, right)) {
 					return equal.call(position, scope, left, new CallArguments(right), false);
 				}
 			}
 		return members.call(position, scope, value, new CallArguments(Expression.NONE), false);
 	}
 	
-	public Expression ternary(CodePosition position, TypeScope scope, OperatorType operator, Expression a, Expression b, Expression c) {
-		DefinitionMemberGroup members = getOrCreateGroup(operator);
-		return members.call(position, scope, a, new CallArguments(b, c), false);
-	}
-	
 	public IteratorMemberRef getIterator(int variables) {
 		for (TypeMember<IteratorMemberRef> iterator : iterators)
 			if (iterator.member.getLoopVariableCount() == variables)
 			return true;
 		if (toType == null)
 			throw new NullPointerException();
+		if (toType == BasicTypeID.UNDETERMINED)
+			throw new IllegalArgumentException("Cannot cast to undetermined type!");
 		
 		if (type == BasicTypeID.NULL && toType.isOptional())
 			return true;
-		if (toType.isOptional() && canCastImplicit(toType.unwrap()))
+		if (toType.isOptional() && canCastImplicit(toType.withoutOptional()))
 			return true;
-		if (toType.isConst() && canCastImplicit(toType.unwrap()))
+		if (toType.isConst() && canCastImplicit(toType.withoutConst()))
 			return true;
-		if (type.isOptional() && type.unwrap() == toType)
+		if (type.isOptional() && type.withoutOptional() == toType)
 			return true;
 		
 		return getImplicitCaster(toType) != null || extendsOrImplements(toType);
 		
 		if (type == BasicTypeID.NULL && toType.isOptional())
 			return new NullExpression(position, toType);
-		if (toType.isOptional() && canCastImplicit(toType.unwrap()))
-			return new WrapOptionalExpression(position, castImplicit(position, value, toType.unwrap(), implicit), toType);
-		if (toType.isConst() && canCastImplicit(toType.unwrap()))
-			return new MakeConstExpression(position, castImplicit(position, value, toType.unwrap(), implicit), toType);
-		if (type.isOptional() && type.unwrap() == toType)
+		if (toType.isOptional() && canCastImplicit(toType.withoutOptional()))
+			return new WrapOptionalExpression(position, castImplicit(position, value, toType.withoutOptional(), implicit), toType);
+		if (toType.isConst() && canCastImplicit(toType.withoutConst()))
+			return new MakeConstExpression(position, castImplicit(position, value, toType.withoutConst(), implicit), toType);
+		if (type.isOptional() && type.withoutOptional() == toType)
 			return new CheckNullExpression(position, value);
 		
 		for (TypeMember<CasterMemberRef> caster : casters) {
 		return members.containsKey(name);
 	}
 	
-	public IPartialExpression getMemberExpression(CodePosition position, Expression target, GenericName name, boolean allowStatic) {
+	public IPartialExpression getMemberExpression(CodePosition position, TypeScope scope, Expression target, GenericName name, boolean allowStatic) {
 		if (members.containsKey(name.name)) {
 			DefinitionMemberGroup group = members.get(name.name);
 			
 			if (group.isStatic)
-				return new PartialStaticMemberGroupExpression(position, type, group, name.arguments);
+				return new PartialStaticMemberGroupExpression(position, scope, type, group, name.arguments);
 			else
-				return new PartialMemberGroupExpression(position, target, group, name.arguments, allowStatic);
+				return new PartialMemberGroupExpression(position, scope, target, group, name.arguments, allowStatic);
 		}
 		
 		return null;
 	}
 	
-	public IPartialExpression getStaticMemberExpression(CodePosition position, GenericName name) {
+	public IPartialExpression getStaticMemberExpression(CodePosition position, TypeScope scope, GenericName name) {
 		if (members.containsKey(name.name))
-			return new PartialStaticMemberGroupExpression(position, type, members.get(name.name), name.arguments);
+			return new PartialStaticMemberGroupExpression(position, scope, type, members.get(name.name), name.arguments);
 		if (innerTypes.containsKey(name.name))
 			return new PartialTypeExpression(position, innerTypes.get(name.name).instance(cache.getRegistry(), name.arguments, (DefinitionTypeID)type), name.arguments);
 		

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

 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.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
 	private final LocalMemberCache cache;
 	private final Map<String, AnnotationDefinition> annotations = new HashMap<>();
 	
-	public CompileScope(GlobalTypeRegistry globalRegistry, List<ExpansionDefinition> expansions, List<AnnotationDefinition> annotations) {
+	public CompileScope(GlobalTypeRegistry globalRegistry, List<ExpansionDefinition> expansions, AnnotationDefinition[] annotations) {
 		this.globalRegistry = globalRegistry;
 		this.expansions = expansions;
 		this.cache = new LocalMemberCache(globalRegistry, expansions);
 	public AnnotationDefinition getAnnotation(String name) {
 		return annotations.get(name);
 	}
+
+	@Override
+	public ITypeID getType(CodePosition position, List<GenericName> name) {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+	
+	@Override
+	public ITypeID getThisType() {
+		return null;
+	}
+
+	@Override
+	public TypeMemberPreparer getPreparer() {
+		return member -> {};
+	}
 }

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

 import org.openzen.zenscript.codemodel.PackageDefinitions;
 import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.annotations.AnnotationProcessor;
+import org.openzen.zenscript.codemodel.context.ModuleTypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.scope.FileScope;
 	
 	public final CompilationUnit compilationUnit;
 	public final List<ExpansionDefinition> expansions;
-	public final List<AnnotationDefinition> annotations;
+	public final AnnotationDefinition[] annotations;
 	
 	public SemanticModule(
 			String name,
 			List<ScriptBlock> scripts,
 			CompilationUnit compilationUnit,
 			List<ExpansionDefinition> expansions,
-			List<AnnotationDefinition> annotations)
+			AnnotationDefinition[] annotations)
 	{
 		this.name = name;
 		this.dependencies = dependencies;
 		if (state != State.ASSEMBLED)
 			throw new IllegalStateException("Module is invalid");
 		
-		AnnotationProcessor annotationProcessor = new AnnotationProcessor(rootPackage, definitions, compilationUnit.globalTypeRegistry, expansions, annotations);
+		ModuleTypeResolutionContext context = new ModuleTypeResolutionContext(compilationUnit.globalTypeRegistry, annotations, rootPackage, null, globals);
+		AnnotationProcessor annotationProcessor = new AnnotationProcessor(context, expansions);
 		List<ScriptBlock> processedScripts = new ArrayList<>();
 		for (ScriptBlock block : scripts)
 			processedScripts.add(annotationProcessor.process(block));
 		for (HighLevelDefinition definition : definitions.getAll()) {
 			annotationProcessor.process(definition);
 			
-			FileScope fileScope = new FileScope(rootPackage, definitions, compilationUnit.globalTypeRegistry, expansions, new HashMap<>(), annotations);
+			FileScope fileScope = new FileScope(context, expansions, globals, member -> {});
 			definition.normalize(fileScope);
 		}
 		

Constructor/src/main/java/org/openzen/zenscript/constructor/Module.java

 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.PackageDefinitions;
 import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
+import org.openzen.zenscript.codemodel.context.ModuleTypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.constructor.module.ModuleSpace;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.parser.BracketExpressionParser;
 import org.openzen.zenscript.parser.ParsedFile;
+import org.openzen.zenscript.parser.PrecompilationState;
 
 /**
  *
 	public final String[] dependencies;
 	public final File sourceDirectory;
 	public final String packageName;
+	public final String javaPackageName;
 	public final String host;
 	private final Consumer<CompileException> exceptionLogger;
 	
 		BufferedInputStream input = new BufferedInputStream(new FileInputStream(moduleFile));
 		JSONObject json = new JSONObject(new JSONTokener(input));
 		packageName = json.getString("package");
+		javaPackageName = json.optString("javaPackageName", packageName);
 		host = json.getString("host");
 		JSONArray dependencies = json.optJSONArray("dependencies");
 		if (dependencies == null) {
 		}
 	}
 	
-	public ParsedFile[] parse(ZSPackage pkg) throws IOException {
+	public ParsedFile[] parse(ZSPackage pkg, CompilingPackage compilingPackage) throws IOException {
 		// TODO: load bracket parsers from host plugins
 		List<ParsedFile> files = new ArrayList<>();
-		parse(files, pkg, null, sourceDirectory);
+		parse(files, pkg, compilingPackage, null, sourceDirectory);
 		return files.toArray(new ParsedFile[files.size()]);
 	}
 	
-	private void parse(List<ParsedFile> files, ZSPackage pkg, BracketExpressionParser bracketParser, File directory) throws IOException {
+	private void parse(List<ParsedFile> files, ZSPackage pkg, CompilingPackage compilingPackage, BracketExpressionParser bracketParser, File directory) throws IOException {
 		for (File file : directory.listFiles()) {
 			if (file.getName().endsWith(".zs")) {
 				try {
-					files.add(ParsedFile.parse(pkg, bracketParser, file));
+					files.add(ParsedFile.parse(pkg, compilingPackage, bracketParser, file));
 				} catch (CompileException ex) {
 					exceptionLogger.accept(ex);
 				}
 			} else if (file.isDirectory()) {
-				parse(files, pkg.getOrCreatePackage(file.getName()), bracketParser, file);
+				CompilingPackage innerPackage = new CompilingPackage();
+				compilingPackage.addPackage(file.getName(), innerPackage);
+				parse(files, pkg.getOrCreatePackage(file.getName()), innerPackage, bracketParser, file);
 			}
 		}
 	}
 			String name,
 			String[] dependencies,
 			ZSPackage pkg,
+			CompilingPackage compilingPkg,
 			ParsedFile[] files,
 			ModuleSpace registry,
 			Consumer<CompileException> exceptionLogger) {
 		Map<String, ISymbol> globals = registry.collectGlobals();
 		boolean failed = false;
 		
+		ModuleTypeResolutionContext moduleContext = new ModuleTypeResolutionContext(
+				registry.compilationUnit.globalTypeRegistry,
+				registry.getAnnotations(),
+				rootPackage,
+				compilingPkg,
+				globals);
+		
 		for (ParsedFile file : files) {
 			// compileMembers will register all definition members to their
 			// respective definitions, such as fields, constructors, methods...
 			// It doesn't yet compile the method contents.
 			try {
-				file.compileTypes(rootPackage, pkg, definitions, registry.compilationUnit.globalTypeRegistry, expansions, globals, registry.getAnnotations());
+				file.compileTypes(moduleContext, rootPackage, compilingPkg);
 			} catch (CompileException ex) {
 				exceptionLogger.accept(ex);
 				failed = true;
 		if (failed)
 			return new SemanticModule(name, dependencies, SemanticModule.State.INVALID, rootPackage, pkg, definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations());
 		
+		// scripts will store all the script blocks encountered in the files
+		PrecompilationState precompiler = new PrecompilationState();
 		for (ParsedFile file : files) {
-			// compileMembers will register all definition members to their
-			// respective definitions, such as fields, constructors, methods...
-			// It doesn't yet compile the method contents.
-			try {
-				file.compileMembers(rootPackage, pkg, definitions, registry.compilationUnit.globalTypeRegistry, expansions, globals, registry.getAnnotations());
-			} catch (CompileException ex) {
-				exceptionLogger.accept(ex);
-				failed = true;
-			}
+			file.registerMembers(moduleContext, precompiler, rootPackage, compilingPkg, expansions, globals);
 		}
 		
-		if (failed)
-			return new SemanticModule(name, dependencies, SemanticModule.State.INVALID, rootPackage, pkg, definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations());
-		
-		if (failed)
-			return new SemanticModule(name, dependencies, SemanticModule.State.INVALID, rootPackage, pkg, definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations());
-		
-		// scripts will store all the script blocks encountered in the files
 		List<ScriptBlock> scripts = new ArrayList<>();
 		for (ParsedFile file : files) {
 			// compileCode will convert the parsed statements and expressions
 			// into semantic code. This semantic code can then be compiled
 			// to various targets.
 			try {
-				file.compileCode(rootPackage, pkg, definitions, registry.compilationUnit.globalTypeRegistry, expansions, scripts, globals, registry.getAnnotations());
+				file.compileCode(moduleContext, precompiler, rootPackage, compilingPkg, expansions, scripts, globals);
 			} catch (CompileException ex) {
 				exceptionLogger.accept(ex);
 				failed = true;
 			}
 		}
 		
-		return new SemanticModule(name, dependencies, SemanticModule.State.ASSEMBLED, rootPackage, pkg, definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations());
+		return new SemanticModule(name, dependencies, SemanticModule.State.ASSEMBLED, rootPackage, pkg, definitions, scripts, registry.compilationUnit, expansions, registry.getAnnotations());
 	}
 }

Constructor/src/main/java/org/openzen/zenscript/constructor/module/DirectoryModuleReference.java

 import org.json.JSONObject;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.FileSourceFile;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.compiler.CompilationUnit;
 import org.openzen.zenscript.constructor.ConstructorException;
 				}
 			}
 
-			ModuleSpace space = new ModuleSpace(unit);
+			// TODO: annotation type registration
+			ModuleSpace space = new ModuleSpace(unit, new ArrayList<>());
 			for (String dependencyName : dependencyNames)
 				space.addModule(dependencyName, loader.getModule(dependencyName));
 
 			Module module = new Module(moduleName, directory, jsonFile, exceptionLogger);
 			ZSPackage pkg = isStdlib ? unit.globalTypeRegistry.stdlib : new ZSPackage(null, module.packageName);
-
-			ParsedFile[] parsedFiles = module.parse(pkg);
-			SemanticModule result = Module.compileSyntaxToSemantic(module.name, module.dependencies, pkg, parsedFiles, space, exceptionLogger);
+			CompilingPackage compilingPackage = new CompilingPackage();
+			
+			ParsedFile[] parsedFiles = module.parse(pkg, compilingPackage);
+			SemanticModule result = Module.compileSyntaxToSemantic(module.name, module.dependencies, pkg, compilingPackage, parsedFiles, space, exceptionLogger);
 			
 			JSONObject globals = json.optJSONObject("globals");
 			if (globals != null) {

Constructor/src/main/java/org/openzen/zenscript/constructor/module/ModuleSpace.java

 	public final ZSPackage globalsPackage = new ZSPackage(null, "");
 	private final List<ExpansionDefinition> expansions = new ArrayList<>();
 	private final Map<String, ISymbol> globals = new HashMap<>();
-	private final List<AnnotationDefinition> annotations = new ArrayList<>();
+	private final AnnotationDefinition[] annotations;
 	
-	public ModuleSpace(CompilationUnit compilationUnit) {
+	public ModuleSpace(CompilationUnit compilationUnit, List<AnnotationDefinition> annotations) {
 		this.compilationUnit = compilationUnit;
 		
-		addAnnotation(NativeAnnotationDefinition.INSTANCE);
-		addAnnotation(PreconditionAnnotationDefinition.INSTANCE);
-	}
-	
-	public void addAnnotation(AnnotationDefinition annotation) {
-		annotations.add(annotation);
+		annotations.add(NativeAnnotationDefinition.INSTANCE);
+		annotations.add(PreconditionAnnotationDefinition.INSTANCE);
+		this.annotations = annotations.toArray(new AnnotationDefinition[annotations.size()]);
 	}
 	
 	public void addModule(String name, SemanticModule dependency) {
 		}
 	}
 	
+	public void addGlobal(String name, ISymbol global) {
+		globals.put(name, global);
+	}
+	
 	public ZSPackage collectPackages() {
 		return rootPackage;
 	}
 		return globals;
 	}
 	
-	public List<AnnotationDefinition> getAnnotations() {
+	public AnnotationDefinition[] getAnnotations() {
 		return annotations;
 	}
 }

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

 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.CompareType;
-import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 
 import java.io.FileOutputStream;
 import java.io.IOException;
-import java.util.*;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 	private static final int PUBLIC = Opcodes.ACC_PUBLIC;
     @Override
     public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
         Type type = expression.objectType.accept(JavaTypeVisitor.INSTANCE);
+		try {
+			type.getInternalName();
+		} catch (NullPointerException ex) {
+			ex.printStackTrace();
+		}
 
         javaWriter.loadObject(0);
         if (javaWriter.method.javaClass.isEnum) {
         for (Expression argument : expression.arguments.arguments) {
             argument.accept(this);
         }
-        javaWriter.invokeSpecial(type.getInternalName(), "<init>", CompilerUtils.calcDesc(expression.constructor.header, javaWriter.method.javaClass.isEnum));
+		String internalName = type.getInternalName();
+        javaWriter.invokeSpecial(internalName, "<init>", CompilerUtils.calcDesc(expression.constructor.getHeader(), javaWriter.method.javaClass.isEnum));
         return null;
     }
 
             argument.accept(this);
         }
         //No super calls in enums possible, and that's already handled in the enum constructor itself.
-        javaWriter.invokeSpecial(expression.objectType.accept(JavaTypeClassVisitor.INSTANCE), "<init>", CompilerUtils.calcDesc(expression.constructor.header, false));
+        javaWriter.invokeSpecial(expression.objectType.accept(JavaTypeClassVisitor.INSTANCE), "<init>", CompilerUtils.calcDesc(expression.constructor.getHeader(), false));
 
         CompilerUtils.writeDefaultFieldInitializers(javaWriter, javaWriter.forDefinition, false);
         return null;

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaMemberVisitor.java

 					argument.accept(clinitStatementVisitor.expressionVisitor);
 				}
 
-				clinitWriter.invokeSpecial(internalName, "<init>", CompilerUtils.calcDesc(constant.constructor.constructor.header, true));
+				clinitWriter.invokeSpecial(internalName, "<init>", CompilerUtils.calcDesc(constant.constructor.constructor.getHeader(), true));
 				clinitWriter.putStaticField(internalName, constant.name, "L" + internalName + ";");
 				
 				enumDefinition = (EnumDefinition) constant.definition;

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

 	K_IMPLICIT(true, "implicit"),
 	K_VIRTUAL(true, "virtual"),
 	K_EXTERN(true, "extern"),
+	K_IMMUTABLE(true, "immutable"),
 	
 	K_VAL(true, "val"),
 	K_VAR(true, "var"),

Parser/src/main/java/org/openzen/zenscript/parser/ParsedDefinition.java

  */
 package org.openzen.zenscript.parser;
 
+import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingType;
+import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import static org.openzen.zenscript.lexer.ZSTokenType.*;
  *
  * @author Hoofdgebruiker
  */
-public abstract class ParsedDefinition {
+public abstract class ParsedDefinition implements CompilingType {
 	public static ParsedDefinition parse(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
 		if (tokens.optional(K_CLASS) != null) {
 			return ParsedClass.parseClass(pkg, position, modifiers, annotations, tokens, outerDefinition);
 		this.annotations = annotations;
 	}
 	
+	public String getName() {
+		return getCompiled().name;
+	}
+	
 	public final CodePosition getPosition() {
 		return position;
 	}
 	
 	public abstract HighLevelDefinition getCompiled();
 	
-	public abstract void linkInnerTypes();
-	
-	public void compileTypes(BaseScope scope) {
-		
-	}
-	
-	public abstract void compileMembers(BaseScope scope);
-	
-	public abstract void listMembers(BaseScope scope, PrecompilationState state);
+	public abstract void linkTypes(TypeResolutionContext context);
 	
-	public abstract void precompile(BaseScope scope, PrecompilationState state);
+	public abstract void registerMembers(BaseScope scope, PrecompilationState state);
 	
-	public abstract void compileCode(BaseScope scope, PrecompilationState state);
+	public abstract void compile(BaseScope scope);
 }

Parser/src/main/java/org/openzen/zenscript/parser/ParsedFile.java

 import org.openzen.zenscript.codemodel.PackageDefinitions;
 import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.WhitespacePostComment;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
+import org.openzen.zenscript.codemodel.context.FileResolutionContext;
+import org.openzen.zenscript.codemodel.context.ModuleTypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.lexer.ZSToken;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import static org.openzen.zenscript.lexer.ZSTokenType.*;
 import org.openzen.zenscript.codemodel.scope.FileScope;
  * @author Hoofdgebruiker
  */
 public class ParsedFile {
-	public static ParsedFile parse(ZSPackage pkg, BracketExpressionParser bracketParser, File file) throws IOException {
-		return parse(pkg, bracketParser, new FileSourceFile(file.getName(), file));
+	public static ParsedFile parse(ZSPackage pkg, CompilingPackage compilingPackage, BracketExpressionParser bracketParser, File file) throws IOException {
+		return parse(pkg, compilingPackage, bracketParser, new FileSourceFile(file.getName(), file));
 	}
 	
-	public static ParsedFile parse(ZSPackage pkg, BracketExpressionParser bracketParser, String filename, String content) {
+	public static ParsedFile parse(ZSPackage pkg, CompilingPackage compilingPackage, BracketExpressionParser bracketParser, String filename, String content) {
 		try {
-			return parse(pkg, bracketParser, new LiteralSourceFile(filename, content));
+			return parse(pkg, compilingPackage, bracketParser, new LiteralSourceFile(filename, content));
 		} catch (IOException ex) {
 			throw new AssertionError(); // shouldn't happen
 		}
 	}
 	
-	public static ParsedFile parse(ZSPackage pkg, BracketExpressionParser bracketParser, SourceFile file) throws IOException {
+	public static ParsedFile parse(ZSPackage pkg, CompilingPackage compilingPackage, BracketExpressionParser bracketParser, SourceFile file) throws IOException {
 		ZSTokenParser tokens = ZSTokenParser.create(file, bracketParser, 4);
-		return parse(pkg, tokens);
+		return parse(pkg, compilingPackage, tokens);
 	}
 	
-	public static ParsedFile parse(ZSPackage pkg, ZSTokenParser tokens) {
+	public static ParsedFile parse(ZSPackage pkg, CompilingPackage compilingPackage, ZSTokenParser tokens) {
 		ParsedFile result = new ParsedFile(tokens.getFile());
 
 		while (true) {
 					result.statements.add(ParsedStatement.parse(tokens, annotations));
 				} else {
 					result.definitions.add(definition);
+					definition.getCompiled().setTag(SourceFile.class, tokens.getFile());
+					
+					if (definition.getName() != null)
+						compilingPackage.addType(definition.getName(), definition);
 				}
 			}
 		}
 	
 	public void listDefinitions(PackageDefinitions definitions) {
 		for (ParsedDefinition definition : this.definitions) {
-			definition.getCompiled().setTag(SourceFile.class, file);
 			definitions.add(definition.getCompiled());
-			definition.linkInnerTypes();
 		}
 	}
 	
 	public void compileTypes(
+			ModuleTypeResolutionContext moduleContext,
 			ZSPackage rootPackage,
-			ZSPackage modulePackage,
-			PackageDefinitions packageDefinitions,
-			GlobalTypeRegistry globalRegistry,
-			List<ExpansionDefinition> expansions,
-			Map<String, ISymbol> globalSymbols,
-			List<AnnotationDefinition> annotations) {
-		FileScope scope = new FileScope(rootPackage, packageDefinitions, globalRegistry, expansions, globalSymbols, annotations);
-		loadImports(scope, rootPackage, modulePackage);
+			CompilingPackage modulePackage) {
+		FileResolutionContext context = new FileResolutionContext(moduleContext);
+		loadImports(context, rootPackage, modulePackage);
 		for (ParsedDefinition definition : this.definitions) {
-			definition.compileTypes(scope);
+			definition.linkTypes(context);
 		}
 	}
 	
-	public void compileMembers(
+	public void registerMembers(
+			ModuleTypeResolutionContext moduleContext,
+			PrecompilationState precompiler,
 			ZSPackage rootPackage,
-			ZSPackage modulePackage,
-			PackageDefinitions packageDefinitions,
-			GlobalTypeRegistry globalRegistry,
+			CompilingPackage modulePackage,
 			List<ExpansionDefinition> expansions,
-			Map<String, ISymbol> globalSymbols,
-			List<AnnotationDefinition> annotations) {
-		FileScope scope = new FileScope(rootPackage, packageDefinitions, globalRegistry, expansions, globalSymbols, annotations);
-		loadImports(scope, rootPackage, modulePackage);
+			Map<String, ISymbol> globals) {
+		FileResolutionContext context = new FileResolutionContext(moduleContext);
+		loadImports(context, rootPackage, modulePackage);
+		
+		FileScope scope = new FileScope(context, expansions, globals, precompiler);
 		for (ParsedDefinition definition : this.definitions) {
-			definition.compileMembers(scope);
+			definition.registerMembers(scope, precompiler);
 		}
 	}
 	
 	public void compileCode(
+			ModuleTypeResolutionContext moduleContext,
+			PrecompilationState precompiler,
 			ZSPackage rootPackage,
-			ZSPackage modulePackage,
-			PackageDefinitions packageDefinitions,
-			GlobalTypeRegistry globalRegistry,
+			CompilingPackage modulePackage,
 			List<ExpansionDefinition> expansions,
 			List<ScriptBlock> scripts,
-			Map<String, ISymbol> globalSymbols,
-			List<AnnotationDefinition> annotations) {
-		FileScope scope = new FileScope(rootPackage, packageDefinitions, globalRegistry, expansions, globalSymbols, annotations);
-		loadImports(scope, rootPackage, modulePackage);
+			Map<String, ISymbol> globals) {
+		FileResolutionContext context = new FileResolutionContext(moduleContext);
+		loadImports(context, rootPackage, modulePackage);
 		
-		PrecompilationState state = new PrecompilationState();
-		for (ParsedDefinition definition : this.definitions) {
-			definition.listMembers(scope, state);
-		}
-		for (ParsedDefinition definition : this.definitions) {
-			definition.precompile(scope, state);
-		}
+		FileScope scope = new FileScope(context, expansions, globals, precompiler);
 		for (ParsedDefinition definition : this.definitions) {
-			definition.compileCode(scope, state);
+			definition.compile(scope);
 		}
 		
 		if (!statements.isEmpty() || postComment != null) {
 		}
 	}
 	
-	private void loadImports(FileScope scope, ZSPackage rootPackage, ZSPackage modulePackage) {
+	private void loadImports(FileResolutionContext context, ZSPackage rootPackage, CompilingPackage modulePackage) {
 		for (ParsedImport importEntry : imports) {
 			HighLevelDefinition definition;
 			if (importEntry.isRelative()) {
-				definition = modulePackage.getImport(importEntry.getPath(), 0);
+				definition = modulePackage.getImport(context, importEntry.getPath());
 			} else {
 				definition = rootPackage.getImport(importEntry.getPath(), 0);
 			}
 			if (definition == null)
 				throw new CompileException(importEntry.position, CompileExceptionCode.IMPORT_NOT_FOUND, "Could not find type " + importEntry.toString());
 			
-			scope.register(importEntry.getName(), definition);
+			context.addImport(importEntry.getName(), definition);
 		}
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/PrecompilationState.java

 import java.util.Set;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;
 import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class PrecompilationState {
+public class PrecompilationState implements TypeMemberPreparer {
 	private final Map<IDefinitionMember, CompilableMember> members = new HashMap<>();
 	private final Set<ParsedDefinitionMember> compilingMembers = new HashSet<>();
 	
 			return false;
 		
 		compilingMembers.add(cMember.member);
-		if (!cMember.member.inferHeaders(cMember.definitionScope, this))
-			return false;
-		
+		cMember.member.compile(cMember.definitionScope);
 		compilingMembers.remove(cMember.member);
 		return true;
 	}
 	public void end(ParsedDefinitionMember member) {
 		compilingMembers.remove(member);
 	}
+
+	@Override
+	public void prepare(IDefinitionMember member) {
+		precompile(member);
+	}
 	
 	private class CompilableMember {
 		private final ParsedDefinitionMember member;

Parser/src/main/java/org/openzen/zenscript/parser/SimpleBracketSubParser.java

 	public SimpleBracketSubParser(GlobalTypeRegistry registry, FunctionalMemberRef method) {
 		if (!method.isStatic())
 			throw new IllegalArgumentException("Method must be static");
-		if (method.header.getNumberOfTypeParameters() > 0)
+		if (method.getHeader().getNumberOfTypeParameters() > 0)
 			throw new IllegalArgumentException("Method cannot have type parameters");
 		
 		this.method = method;
 
 		@Override
 		public IPartialExpression compile(ExpressionScope scope) {
-			return new CallStaticExpression(position, targetType, method, method.header, new CallArguments(new ConstantStringExpression(position, value)));
+			return new CallStaticExpression(position, targetType, method, method.getHeader(), new CallArguments(new ConstantStringExpression(position, value)));
 		}
 
 		@Override
 		public boolean hasStrongType() {
 			return true;
 		}
-
-		@Override
-		public ITypeID precompileForType(ExpressionScope scope, PrecompilationState state) {
-			return method.header.returnType;
-		}
 	}
 }

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

 package org.openzen.zenscript.parser.definitions;
 
 import java.util.ArrayList;
+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.context.CompilingType;
+import org.openzen.zenscript.codemodel.context.LocalTypeResolutionContext;
+import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.scope.DefinitionScope;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.ParsedDefinition;
 import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
-import org.openzen.zenscript.parser.member.ParsedInnerDefinition;
 
 /**
  *
 public abstract class BaseParsedDefinition extends ParsedDefinition {
 	protected final List<ParsedDefinitionMember> members = new ArrayList<>();
 	private boolean typesCompiled = false;
+	private final Map<String, CompilingType> innerTypes = new HashMap<>();
+	private boolean isCompiled = false;
 	
 	public BaseParsedDefinition(CodePosition position, int modifiers, ParsedAnnotation[] annotations) {
 		super(position, modifiers, annotations);
 	
 	public void addMember(ParsedDefinitionMember member) {
 		members.add(member);
+		member.registerInnerTypes(innerTypes);
 	}
 	
 	@Override
-	public void compileTypes(BaseScope scope) {
-		DefinitionScope innerScope = new DefinitionScope(scope, getCompiled(), false);
-		for (ParsedDefinitionMember member : members) {
-			if (member instanceof ParsedInnerDefinition) {
-				ParsedInnerDefinition inner = (ParsedInnerDefinition)member;
-				innerScope.addInnerType(inner.getCompiled().innerDefinition.name, () -> loadInnerType(innerScope, inner));
-			}
-		}
-		
-		doCompileTypes(innerScope);
-	}
-	
-	private void doCompileTypes(DefinitionScope innerScope) {
+	public void linkTypes(TypeResolutionContext context) {
 		if (typesCompiled)
 			return;
+		typesCompiled = true;
 		
-		for (ParsedDefinitionMember member : members)
-			member.compileTypes(innerScope);
+		System.out.println("compileTypes " + getCompiled().name);
+		LocalTypeResolutionContext localContext = new LocalTypeResolutionContext(context, this, getCompiled().genericParameters);
+		linkTypesLocal(localContext);
 	}
 	
-	private HighLevelDefinition loadInnerType(DefinitionScope scope, ParsedInnerDefinition member) {
-		member.compileTypes(scope);
-		return member.getCompiled().innerDefinition;
+	protected void linkTypesLocal(TypeResolutionContext localContext) {
+		for (ParsedDefinitionMember member : members) {
+			member.linkTypes(localContext);
+			getCompiled().addMember(member.getCompiled());
+		}
 	}
 	
 	@Override
-	public void linkInnerTypes() {
-		for (ParsedDefinitionMember member : members)
-			member.linkInnerTypes();
-	}
-
-	@Override
-	public void compileMembers(BaseScope scope) {
-		getCompiled().annotations = ParsedAnnotation.compileForDefinition(annotations, getCompiled(), scope);
-		
+	public void registerMembers(BaseScope scope, PrecompilationState state) {
 		DefinitionScope innerScope = new DefinitionScope(scope, getCompiled());
 		for (ParsedDefinitionMember member : members) {
-			member.linkTypes(innerScope);
-			getCompiled().addMember(member.getCompiled());
+			state.register(innerScope, member);
+			member.registerMembers(innerScope, state);
 		}
 	}
-	
+
 	@Override
-	public void listMembers(BaseScope scope, PrecompilationState state) {
+	public void compile(BaseScope scope) {
+		if (isCompiled)
+			return;
+		isCompiled = true;
+		
+		getCompiled().annotations = ParsedAnnotation.compileForDefinition(annotations, getCompiled(), scope);
+		
 		DefinitionScope innerScope = new DefinitionScope(scope, getCompiled());
 		for (ParsedDefinitionMember member : members)
-			state.register(innerScope, member);
+			member.compile(innerScope);
 	}
 	
 	@Override
-	public void precompile(BaseScope scope, PrecompilationState state) {
-		for (ParsedDefinitionMember member : members)
-			state.precompile(member.getCompiled());
+	public HighLevelDefinition load(TypeResolutionContext context) {
+		linkTypes(context);
+		return getCompiled();
 	}
-
+	
 	@Override
-	public void compileCode(BaseScope scope, PrecompilationState state) {
-		DefinitionScope innerScope = new DefinitionScope(scope, getCompiled());
-		for (ParsedDefinitionMember member : members)
-			member.compile(innerScope, state);
+	public CompilingType getInner(String name) {
+		return innerTypes.get(name);
 	}
 }

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

  */
 package org.openzen.zenscript.parser.definitions;
 
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
-import java.util.function.Function;
 import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingType;
+import org.openzen.zenscript.codemodel.context.LocalTypeResolutionContext;
+import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.partial.IPartialExpression;
-import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
-import org.openzen.zenscript.codemodel.scope.DefinitionScope;
-import org.openzen.zenscript.codemodel.statement.LoopStatement;
-import org.openzen.zenscript.codemodel.type.GenericName;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.ParsedDefinition;
 import org.openzen.zenscript.parser.PrecompilationState;
 	private final IParsedType type;
 	
 	private final AliasDefinition compiled;
+	private boolean typesLinked = false;
 	
 	public ParsedAlias(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> parameters, IParsedType type, HighLevelDefinition outerDefinition) {
 		super(position, modifiers, annotations);
 	}
 	
 	@Override
-	public void compileTypes(BaseScope scope) {
-		BaseScope innerScope = new CompileTypeScope(scope);
-		compiled.setType(type.compile(innerScope));
-	}
-	
-	@Override
-	public HighLevelDefinition getCompiled() {
-		return compiled;
-	}
-
-	@Override
-	public void compileMembers(BaseScope scope) {
-		DefinitionScope innerScope = new DefinitionScope(scope, compiled);
+	public void linkTypes(TypeResolutionContext context) {
+		if (typesLinked)
+			return;
+		typesLinked = true;
+		
+		LocalTypeResolutionContext localContext = new LocalTypeResolutionContext(context, this, compiled.genericParameters);
+		compiled.setType(type.compile(localContext));
+		
 		for (int i = 0; i < compiled.genericParameters.length; i++) {
 			TypeParameter output = compiled.genericParameters[i];
 			ParsedTypeParameter input = this.parameters.get(i);
 			for (ParsedGenericBound bound : input.bounds) {
-				output.addBound(bound.compile(innerScope));
+				output.addBound(bound.compile(localContext));
 			}
 		}
 	}
 	
 	@Override
-	public void listMembers(BaseScope scope, PrecompilationState state) {
-		// nothing to do
+	public HighLevelDefinition getCompiled() {
+		return compiled;
 	}
 	
 	@Override
-	public void precompile(BaseScope scope, PrecompilationState state) {
+	public void registerMembers(BaseScope scope, PrecompilationState state) {
 		// nothing to do
 	}
 
 	@Override
-	public void compileCode(BaseScope scope, PrecompilationState state) {
+	public void compile(BaseScope scope) {
 		// nothing to do
 	}
 
 	@Override
-	public void linkInnerTypes() {
+	public CompilingType getInner(String name) {
+		// TODO: this should be possible too
+		return null;
 	}
-	
-	public class CompileTypeScope extends BaseScope {
-		private final BaseScope outer;
-		private final Map<String, TypeParameter> typeParameters = new HashMap<>();
-
-		public CompileTypeScope(BaseScope outer) {
-			this.outer = outer;
-			
-			if (parameters != null)
-				for (ParsedTypeParameter parameter : parameters)
-					typeParameters.put(parameter.name, parameter.compiled);
-		}
-
-		@Override
-		public LocalMemberCache getMemberCache() {
-			return outer.getMemberCache();
-		}
-
-		@Override
-		public IPartialExpression get(CodePosition position, GenericName name) {
-			if (typeParameters.containsKey(name.name) && !name.hasArguments())
-				return new PartialTypeExpression(position, getTypeRegistry().getGeneric(typeParameters.get(name.name)), name.arguments);
 
-			return outer.get(position, name);
-		}
-
-		@Override
-		public ITypeID getType(CodePosition position, List<GenericName> name) {
-			if (typeParameters.containsKey(name.get(0).name) && name.size() == 1 && !name.get(0).hasArguments()) {
-				return getTypeRegistry().getGeneric(typeParameters.get(name.get(0).name));
-			}
-
-			return outer.getType(position, name);
-		}
-
-		@Override
-		public LoopStatement getLoop(String name) {
-			return null;
-		}
-
-		@Override
-		public FunctionHeader getFunctionHeader() {
-			return null;
-		}
-
-		@Override
-		public ITypeID getThisType() {
-			throw new UnsupportedOperationException("Not available at this stage");
-		}
-
-		@Override
-		public Function<CodePosition, Expression> getDollar() {
-			return outer.getDollar();
-		}
-
-		@Override
-		public IPartialExpression getOuterInstance(CodePosition position) {
-			return null;
-		}
-
-		@Override
-		public AnnotationDefinition getAnnotation(String name) {
-			return outer.getAnnotation(name);
-		}
+	@Override
+	public HighLevelDefinition load(TypeResolutionContext context) {
+		linkTypes(context);
+		return compiled;
 	}
 }

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

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
-import org.openzen.zenscript.codemodel.scope.BaseScope;
-import org.openzen.zenscript.codemodel.scope.GenericFunctionScope;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
 import org.openzen.zenscript.parser.type.IParsedType;
 	}
 
 	@Override
-	public void compileMembers(BaseScope scope) {
-		ParsedTypeParameter.compile(scope, compiled.genericParameters, genericParameters);
+	protected void linkTypesLocal(TypeResolutionContext context) {
 		if (superclass != null)
-			compiled.setSuperType(superclass.compile(new GenericFunctionScope(scope, compiled.genericParameters)));
+			compiled.setSuperType(superclass.compile(context));
 		
-		super.compileMembers(scope);
+		super.linkTypesLocal(context);
 	}
 }

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

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 	}
 	
 	@Override
-	public void compileMembers(BaseScope scope) {
-		super.compileMembers(scope);
-		
+	protected void linkTypesLocal(TypeResolutionContext context) {
 		for (ParsedEnumConstant constant : enumValues) {
 			compiled.addEnumConstant(constant.getCompiled());
 		}
+		
+		super.linkTypesLocal(context);
 	}
 
 	@Override
-	public void compileCode(BaseScope scope, PrecompilationState state) {
-		super.compileCode(scope, state);
+	public void compile(BaseScope scope) {
+		super.compile(scope);
 		
 		DefinitionTypeID type = scope.getTypeRegistry().getForDefinition(compiled, ITypeID.NONE);
 		ExpressionScope evalScope = new ExpressionScope(scope);

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedExpansion.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.LocalTypeResolutionContext;
+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.lexer.ZSTokenParser;
 	}
 
 	@Override
-	public void compileTypes(BaseScope scope) {
-		ParsedTypeParameter.compile(scope, compiled.genericParameters, this.parameters);
-		compiled.target = target.compile(new GenericFunctionScope(scope, compiled.genericParameters));
+	public void linkTypesLocal(TypeResolutionContext context) {
+		ParsedTypeParameter.compile(context, compiled.genericParameters, this.parameters);
+		compiled.target = target.compile(context);
 		if (compiled.target == null)
 			throw new CompileException(position, CompileExceptionCode.INTERNAL_ERROR, "Could not compile expansion target: " + target);
+		
+		super.linkTypesLocal(context);
 	}
 }

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

 package org.openzen.zenscript.parser.definitions;
 
 import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zencode.shared.CompileException;
-import org.openzen.zencode.shared.CompileExceptionCode;
 import static org.openzen.zenscript.lexer.ZSTokenType.*;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingType;
+import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.scope.FunctionScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.ParsedDefinition;
 import org.openzen.zenscript.parser.PrecompilationState;
 	}
 
 	@Override
-	public void linkInnerTypes() {
-		// nothing to do
-	}
-
-	@Override
-	public void compileMembers(BaseScope scope) {
-		compiled.setHeader(header.compile(scope));
+	public void linkTypes(TypeResolutionContext context) {
+		compiled.setHeader(header.compile(context));
 	}
 	
 	@Override
-	public void listMembers(BaseScope scope, PrecompilationState state) {
+	public void registerMembers(BaseScope scope, PrecompilationState state) {
 		
 	}
-	
+
 	@Override
-	public void precompile(BaseScope scope, PrecompilationState state) {
+	public void compile(BaseScope scope) {
+		FunctionScope innerScope = new FunctionScope(scope, compiled.header);
+		compiled.setCode(body.compile(innerScope, compiled.header));
+		
 		if (compiled.header.returnType == BasicTypeID.UNDETERMINED) {
-			ITypeID result = body.precompileForResultType(new FunctionScope(scope, compiled.header), state);
-			if (result == null)
-				throw new CompileException(position, CompileExceptionCode.PRECOMPILE_FAILED, "Could not determine return type for method " + compiled.name);
-			compiled.header = compiled.header.withReturnType(result);
+			compiled.header.returnType = compiled.statement.getReturnType();
 		}
 	}
 
 	@Override
-	public void compileCode(BaseScope scope, PrecompilationState state) {
-		FunctionScope innerScope = new FunctionScope(scope, compiled.header);
-		compiled.setCode(body.compile(innerScope, compiled.header));
+	public CompilingType getInner(String name) {
+		return null;
+	}
+
+	@Override
+	public HighLevelDefinition load(TypeResolutionContext context) {
+		return compiled;
 	}
 }

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

 import java.util.List;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.context.LocalTypeResolutionContext;
+import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.lexer.ZSToken;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import static org.openzen.zenscript.lexer.ZSTokenType.*;
-import org.openzen.zenscript.codemodel.scope.BaseScope;
-import org.openzen.zenscript.codemodel.scope.GenericFunctionScope;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.expression.ParsedExpression;
 import org.openzen.zenscript.parser.type.IParsedType;
 		this.thrownType = thrownType;
 	}
 	
-	public FunctionHeader compile(BaseScope scope) {
+	public FunctionHeader compile(TypeResolutionContext context) {
 		TypeParameter[] genericParameters = ParsedTypeParameter.getCompiled(this.genericParameters);
-		ParsedTypeParameter.compile(scope, genericParameters, this.genericParameters);
-		GenericFunctionScope innerScope = new GenericFunctionScope(scope, genericParameters);
+		LocalTypeResolutionContext localContext = new LocalTypeResolutionContext(context, null, genericParameters);
+		ParsedTypeParameter.compile(localContext, genericParameters, this.genericParameters);
 		
-		ITypeID returnType = this.returnType.compile(innerScope);
+		ITypeID returnType = this.returnType.compile(localContext);
 		FunctionParameter[] parameters = new FunctionParameter[this.parameters.size()];
 		for (int i = 0; i < parameters.length; i++)
-			parameters[i] = this.parameters.get(i).compile(innerScope);
+			parameters[i] = this.parameters.get(i).compile(localContext);
 		
-		return new FunctionHeader(genericParameters, returnType, thrownType == null ? null : thrownType.compile(scope), parameters);
+		return new FunctionHeader(genericParameters, returnType, thrownType == null ? null : thrownType.compile(context), parameters);
 	}
 }

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

 package org.openzen.zenscript.parser.definitions;
 
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.parser.ParsedAnnotation;
+import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.expression.ParsedExpression;
 import org.openzen.zenscript.parser.type.IParsedType;
 
 	public final ParsedExpression defaultValue;
 	public final boolean variadic;
 	
+	private FunctionParameter compiled;
+	
 	public ParsedFunctionParameter(ParsedAnnotation[] annotations, String name, IParsedType type, ParsedExpression defaultValue, boolean variadic) {
 		this.annotations = annotations;
 		this.name = name;
 		this.variadic = variadic;
 	}
 	
-	public FunctionParameter compile(BaseScope scope) {
-		ITypeID cType = type.compile(scope);
+	public FunctionParameter compile(TypeResolutionContext context) {
+		if (compiled != null)
+			return compiled;
+		
+		ITypeID cType = type.compile(context);
 		Expression cDefaultValue = null;
+		return compiled = new FunctionParameter(cType, name, cDefaultValue, variadic);
+	}
+	
+	public void compileInitializer(BaseScope scope, PrecompilationState state) {
 		if (defaultValue != null) {
-			cDefaultValue = defaultValue.compile(new ExpressionScope(scope, cType)).eval();
+			compiled.defaultValue = defaultValue.compile(new ExpressionScope(scope, compiled.type)).eval();
 		}
-		return new FunctionParameter(cType, name, cDefaultValue, variadic);
 	}
 }

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

  */
 package org.openzen.zenscript.parser.definitions;
 
+import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
-import org.openzen.zenscript.codemodel.scope.BaseScope;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public abstract class ParsedGenericBound {
-	public abstract GenericParameterBound compile(BaseScope scope);
+	public abstract GenericParameterBound compile(TypeResolutionContext context);
 }