- Added support for local fields ($field)

- Fixed a couple minor issues & inefficiencies
- Added horizontal scrollbar to IDE (incomplete!)

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

 			return false;
 		
 		for (int i = 0; i < parameters.length; i++) {
-			if (parameters[i].type != other.parameters[i].type)
+			if (!parameters[i].type.equals(other.parameters[i].type))
 				return false;
 		}
 		
 		}
 	}
 	
-	public FunctionHeader withGenericArguments(GlobalTypeRegistry registry, GenericMapper mapper) {
+	public FunctionHeader withGenericArguments(GenericMapper mapper) {
 		if (typeParameters.length > 0)
-			mapper = mapper.getInner(registry, StoredType.getSelfMapping(registry, typeParameters));
+			mapper = mapper.getInner(mapper.registry, StoredType.getSelfMapping(mapper.registry, typeParameters));
 		
 		return instance(mapper);
 	}

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

 	
 	public FunctionParameter withGenericArguments(GenericMapper mapper) {
 		StoredType instanced = type.instance(mapper);
-		if (instanced == type)
+		if (instanced.equals(type))
 			return this;
 		
 		FunctionParameter result = new FunctionParameter(instanced, name, defaultValue, variadic);

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

 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
-import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 		return mapping;
 	}
 	
-	public StoredType map(CodePosition position, StoredType original) {
+	public StoredType map(StoredType original) {
 		return mapping.isEmpty() ? original : original.instance(this);
 	}
 	
 	}
 	
 	public FunctionHeader map(FunctionHeader original) {
-		return mapping.isEmpty() ? original : original.withGenericArguments(registry, this);
+		return mapping.isEmpty() ? original : original.withGenericArguments(this);
 	}
 	
 	public GenericMapper getInner(GlobalTypeRegistry registry, Map<TypeParameter, StoredType> mapping) {

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

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.codemodel.type;
+package org.openzen.zenscript.codemodel;
 
 import java.util.List;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *

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

 import org.openzen.zenscript.codemodel.serialization.CodeSerializationInput;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.codemodel.type.storage.ValueStorageTag;
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/CompilingPackage.java

 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/CompilingType.java

 import java.util.List;
 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.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 
 /**

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/FileResolutionContext.java

 import org.openzen.zencode.shared.CompileExceptionCode;
 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.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/LocalTypeResolutionContext.java

 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.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/ModuleTypeResolutionContext.java

 import org.openzen.zencode.shared.CompileExceptionCode;
 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.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.codemodel.type.StoredType;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/TypeResolutionContext.java

 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.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;

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

 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.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.TypeID;
 

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

 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.Statement;

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

 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberGroup;

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

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

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

 import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.expression.LambdaClosure;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
 

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

 import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
 import org.openzen.zenscript.codemodel.expression.GlobalExpression;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**

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

 import org.openzen.zenscript.codemodel.expression.LambdaClosure;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberGroup;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.TypeMember;

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

 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
 

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

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberGroup;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;

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

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.expression.LambdaClosure;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;

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

 import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
 import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**

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

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;

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

 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.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;

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

 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 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.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;

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

 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPreparer;

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

 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.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;

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

 import org.openzen.zenscript.codemodel.statement.ForeachStatement;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;

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

 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.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;

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

 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.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;

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

 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.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;

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

 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;

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

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;

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

 import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
 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.GenericName;
 
 /**
  *

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

  */
 package org.openzen.zenscript.codemodel.type;
 
+import org.openzen.zenscript.codemodel.GenericName;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;

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

 				for (StoredType resultHint : typeHints) {
 					Map<TypeParameter, StoredType> mapping = header.getReturnType().inferTypeParameters(scope.getMemberCache(), resultHint);
 					if (mapping != null) {
-						header = header.withGenericArguments(scope.getTypeRegistry(), scope.getLocalTypeParameters().getInner(scope.getTypeRegistry(), mapping));
+						header = header.withGenericArguments(scope.getLocalTypeParameters().getInner(scope.getTypeRegistry(), mapping));
 						break;
 					}
 				}

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

 import org.openzen.zenscript.codemodel.partial.PartialVariantOptionExpression;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
 		return members.get(name);
 	}
 	
+	public TypeMemberGroup getGroup(String name) {
+		return members.get(name);
+	}
+	
 	public TypeMemberGroup getOrCreateGroup(OperatorType operator) {
 		if (!operators.containsKey(operator))
 			operators.put(operator, new TypeMemberGroup(false, operator.operator + " operator"));
 		return operators.get(operator);
 	}
 	
+	public TypeMemberGroup getGroup(OperatorType operator) {
+		return operators.get(operator);
+	}
+	
 	public void addEnumMember(EnumConstantMember member, TypeMemberPriority priority) {
 		enumMembers.put(member.name, member);
 	}

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

 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.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;

DrawableGui/src/main/java/org/openzen/drawablegui/scroll/DScrollBar.java

 	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	
 	private final DStyleClass styleClass;
-	private final LiveInt targetHeight;
+	private final LiveInt targetSize;
 	private final LiveInt offset;
+	private final boolean horizontal;
 	
 	private final ListenerHandle<LiveInt.Listener> targetHeightListener;
 	private final ListenerHandle<LiveInt.Listener> offsetListener;
 	private DScrollBarStyle style;
 	private DIRectangle bounds;
 	
-	private int fromY = 0;
-	private int toY = 0;
+	private int from = 0;
+	private int to = 0;
 	private boolean hovering = false;
 	private boolean dragging = false;
 	private int dragStartOffset;
-	private int dragStartY;
+	private int dragStart;
 	
 	private DDrawnRectangle background;
 	private DDrawnShape bar;
 	
-	public DScrollBar(DStyleClass styleClass, LiveInt targetHeight, LiveInt offset) {
+	public DScrollBar(DStyleClass styleClass, LiveInt targetHeight, LiveInt offset, boolean horizontal) {
 		this.styleClass = styleClass;
-		this.targetHeight = targetHeight;
+		this.targetSize = targetHeight;
 		this.offset = offset;
+		this.horizontal = horizontal;
 		
 		targetHeightListener = targetHeight.addListener(new ScrollListener());
 		offsetListener = offset.addListener(new ScrollListener());
 	public void mount(DComponentContext parent) {
 		context = parent.getChildContext("scrollbar", styleClass);
 		style = context.getStyle(DScrollBarStyle::new);
-		sizing.setValue(new DSizing(style.width, 0));
+		
+		if (horizontal) {
+			sizing.setValue(new DSizing(0, style.width));
+		} else {
+			sizing.setValue(new DSizing(style.width, 0));
+		}
 		
 		background = context.fillRect(0, DIRectangle.EMPTY, style.scrollBarBackgroundColor);
 	}
 	@Override
 	public void onMouseDrag(DMouseEvent e) {
 		if (dragging) {
-			int deltaY = e.y - dragStartY;
-			int offsetForDelta = deltaY * targetHeight.getValue() / this.bounds.height;
-			offset.setValue(dragStartOffset + offsetForDelta);
+			if (horizontal) {
+				int deltaX = e.x - dragStart;
+				int offsetForDelta = deltaX * targetSize.getValue() / this.bounds.width;
+				offset.setValue(dragStartOffset + offsetForDelta);
+			} else {
+				int deltaY = e.y - dragStart;
+				int offsetForDelta = deltaY * targetSize.getValue() / this.bounds.height;
+				offset.setValue(dragStartOffset + offsetForDelta);
+			}
 		}
 	}
 	
 	@Override
 	public void onMouseDown(DMouseEvent e) {
-		if (e.y >= fromY && e.y < toY) {
-			dragStartOffset = offset.getValue();
-			dragStartY = e.y;
-			setDragging(true);
+		if (horizontal) {
+			if (e.x >= from && e.x < to) {
+				dragStartOffset = offset.getValue();
+				dragStart = e.x;
+				setDragging(true);
+			}
+		} else {
+			if (e.y >= from && e.y < to) {
+				dragStartOffset = offset.getValue();
+				dragStart = e.y;
+				setDragging(true);
+			}
 		}
 	}
 	
 			color = style.scrollBarHoverColor;
 		if (dragging)
 			color = style.scrollBarPressColor;		
-		if (targetHeight.getValue() <= this.bounds.height)
+		if (targetSize.getValue() <= this.bounds.height)
 			color = 0;
 		
 		bar.setColor(color);
 	}
 	
 	private void checkHover(DMouseEvent e) {
-		setHovering(e.y >= fromY && e.y < toY);
+		if (horizontal) {
+			setHovering(e.x >= from && e.x < to);
+		} else {
+			setHovering(e.y >= from && e.y < to);
+		}
 	}
 	
 	private void setHovering(boolean hovering) {
 	}
 	
 	private void recalculate() {
-		if (targetHeight.getValue() == 0 || bounds == null)
+		if (targetSize.getValue() == 0 || bounds == null)
 			return;
 		
-		fromY = bounds.y + this.bounds.height * offset.getValue() / targetHeight.getValue();
-		toY = bounds.y + this.bounds.height * (offset.getValue() + this.bounds.height) / targetHeight.getValue();
+		if (horizontal) {
+			from = bounds.x + this.bounds.width * offset.getValue() / targetSize.getValue();
+			to = bounds.x + this.bounds.width * (offset.getValue() + this.bounds.width) / targetSize.getValue();
+		} else {
+			from = bounds.y + this.bounds.height * offset.getValue() / targetSize.getValue();
+			to = bounds.y + this.bounds.height * (offset.getValue() + this.bounds.height) / targetSize.getValue();
+		}
 		
 		if (bar != null)
 			bar.close();
-		bar = context.fillPath(1, DPath.rectangle(bounds.x, fromY, bounds.width, toY - fromY), DTransform2D.IDENTITY, style.scrollBarNormalColor);
+		
+		if (horizontal) {
+			bar = context.fillPath(1, DPath.rectangle(from, bounds.y, to - from, bounds.height), DTransform2D.IDENTITY, style.scrollBarNormalColor);
+		} else {
+			bar = context.fillPath(1, DPath.rectangle(bounds.x, from, bounds.width, to - from), DTransform2D.IDENTITY, style.scrollBarNormalColor);
+		}
+		
 		updateBarColor();
 	}
 	

DrawableGui/src/main/java/org/openzen/drawablegui/scroll/DScrollPane.java

 public class DScrollPane implements DComponent, DScrollContext {
 	private final DStyleClass styleClass;
 	private final DComponent contents;
-	private final DScrollBar scrollBar;
+	private final DScrollBar verticalScrollBar;
+	private final DScrollBar horizontalScrollBar;
 	
 	private DComponentContext context;
 	private DScrollPaneStyle style;
 	private DIRectangle bounds;
 	
 	private DDrawnShape shape;
+	private final LiveInt contentsWidth;
 	private final LiveInt contentsHeight;
 	private final LiveInt offsetX;
 	private final LiveInt offsetY;
 	private final SimpleLiveObject<DSizing> sizing = new SimpleLiveObject<>(DSizing.EMPTY);
 	private final LiveObject<DScalableSize> size;
 	
+	private final ListenerHandle<LiveInt.Listener> contentsWidthListener;
 	private final ListenerHandle<LiveInt.Listener> contentsHeightListener;
 	private final ListenerHandle<LiveInt.Listener> offsetXListener;
 	private final ListenerHandle<LiveInt.Listener> offsetYListener;
 		this.styleClass = styleClass;
 		this.contents = contents;
 		
+		contentsWidth = new SimpleLiveInt(0);
 		contentsHeight = new SimpleLiveInt(0);
 		offsetX = new SimpleLiveInt(0);
 		offsetY = new SimpleLiveInt(0);
 		
-		scrollBar = new DScrollBar(DStyleClass.EMPTY, contentsHeight, offsetY);
+		verticalScrollBar = new DScrollBar(DStyleClass.EMPTY, contentsHeight, offsetY, false);
+		horizontalScrollBar = new DScrollBar(DStyleClass.EMPTY, contentsWidth, offsetX, true);
 		
+		contentsWidthListener = contentsWidth.addListener(new ScrollListener());
 		contentsHeightListener = contentsHeight.addListener(new ScrollListener());
 		offsetXListener = offsetX.addListener(new ScrollListener());
 		offsetYListener = offsetY.addListener(new ScrollListener());
 		subSurface = context.createSubSurface(1);
 		DComponentContext newContext = new DComponentContext(this, context.path, 0, subSurface);
 		contents.mount(newContext);
-		scrollBar.mount(context);
+		horizontalScrollBar.mount(context);
+		verticalScrollBar.mount(context);
 		
 		sizing.setValue(new DSizing(
 				size.getValue().width.evalInt(parent.getUIContext()),
 		style.border.close();
 		
 		contents.unmount();
-		scrollBar.unmount();
+		horizontalScrollBar.unmount();
+		verticalScrollBar.unmount();
 	}
 
 	@Override
 		shape = context.shadowPath(0, style.shape.instance(style.margin.apply(bounds)), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
 		style.border.update(context, style.margin.apply(bounds));
 		
+		int width = Math.max(
+				bounds.width - style.border.getPaddingHorizontal(),
+				contents.getSizing().getValue().preferredWidth);
 		int height = Math.max(
 				bounds.height - style.border.getPaddingHorizontal(),
 				contents.getSizing().getValue().preferredHeight);
-		int scrollBarWidth = scrollBar.getSizing().getValue().preferredWidth;
-		scrollBar.setBounds(new DIRectangle(
+		int scrollBarWidth = verticalScrollBar.getSizing().getValue().preferredWidth;
+		int scrollBarHeight = horizontalScrollBar.getSizing().getValue().preferredHeight;
+
+		verticalScrollBar.setBounds(new DIRectangle(
 				bounds.x + bounds.width - scrollBarWidth - style.border.getPaddingRight() - style.margin.right,
 				bounds.y + style.border.getPaddingTop() + style.margin.top,
 				scrollBarWidth,
 				bounds.height - style.border.getPaddingVertical() - style.margin.getVertical()));
-		contents.setBounds(new DIRectangle(0, 0, bounds.width - scrollBar.getBounds().width, height));
+		
+		horizontalScrollBar.setBounds(new DIRectangle(
+				bounds.x + style.border.getPaddingLeft() + style.margin.left,
+				bounds.y + bounds.height - scrollBarHeight - style.border.getPaddingBottom() - style.margin.bottom,
+				bounds.width - style.border.getPaddingHorizontal() - style.margin.getHorizontal(),
+				scrollBarHeight));
+		
+		contents.setBounds(new DIRectangle(0, 0, width, height));
+		contentsWidth.setValue(width);
 		contentsHeight.setValue(height);
 		
 		subSurface.setOffset(bounds.x - offsetX.getValue(), bounds.y - offsetY.getValue());
 	
 	@Override
 	public void onMouseEnter(DMouseEvent e) {
-		if (e.x >= scrollBar.getBounds().x) {
-			setHovering(scrollBar, e);
+		if (e.x >= verticalScrollBar.getBounds().x) {
+			setHovering(verticalScrollBar, e);
+		} else if (e.y >= horizontalScrollBar.getBounds().y) {
+			setHovering(horizontalScrollBar, e);
 		} else {
 			setHovering(contents, e);
 		}
 	
 	@Override
 	public void onMouseMove(DMouseEvent e) {
-		if (e.x >= scrollBar.getBounds().x) {
-			if (hovering != scrollBar) {
-				setHovering(scrollBar, e);
+		if (e.x >= verticalScrollBar.getBounds().x) {
+			if (hovering != verticalScrollBar) {
+				setHovering(verticalScrollBar, e);
+			} else {
+				verticalScrollBar.onMouseMove(e);
+			}
+		} else if (e.y >= horizontalScrollBar.getBounds().y) {
+			if (hovering != horizontalScrollBar) {
+				setHovering(horizontalScrollBar, e);
 			} else {
-				scrollBar.onMouseMove(e);
+				horizontalScrollBar.onMouseMove(e);
 			}
 		} else {
 			if (hovering != contents) {
 
 	@Override
 	public void scrollInView(int x, int y, int width, int height) {
+		if (x < offsetX.getValue())
+			offsetX.setValue(x);
+		if (x + width > offsetX.getValue() + bounds.width)
+			offsetX.setValue(x + width - bounds.width);
+		
 		if (y < offsetY.getValue())
 			offsetY.setValue(y);
 		if (y + height > offsetY.getValue() + bounds.height)
 
 		@Override
 		public void onChanged(int oldValue, int newValue) {
-			int value = offsetY.getValue();
-			if (value > contentsHeight.getValue() - bounds.height)
-				value = contentsHeight.getValue() - bounds.height;
-			if (value < 0)
-				value = 0;
+			int valueX = offsetX.getValue();
+			if (valueX > contentsWidth.getValue() - bounds.width)
+				valueX = contentsWidth.getValue() - bounds.width;
+			if (valueX < 0)
+				valueX = 0;
+			
+			if (valueX != offsetX.getValue())
+				offsetX.setValue(valueX);
+			
+			int valueY = offsetY.getValue();
+			if (valueY > contentsHeight.getValue() - bounds.height)
+				valueY = contentsHeight.getValue() - bounds.height;
+			if (valueY < 0)
+				valueY = 0;
 			
-			if (value != offsetY.getValue())
-				offsetY.setValue(value);
+			if (valueY != offsetY.getValue())
+				offsetY.setValue(valueY);
 			
 			subSurface.setOffset(bounds.x - offsetX.getValue(), bounds.y - offsetY.getValue());
 		}

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/editor/SourceEditor.java

 		fullLineHeight = textLineHeight + fontMetrics.getLeading() + style.extraLineSpacing;
 		selectionLineHeight = textLineHeight + style.selectionPaddingTop + style.selectionPaddingBottom;
 		
-		sizing.setValue(new DSizing(0, fullLineHeight * tokens.getLineCount()));
-		
 		blinkTimer = context.getUIContext().setTimer(300, this::blink);
 		
 		selection = context.fillRect(2, DIRectangle.EMPTY, style.selectionColor);
 		for (int i = 0; i < tokens.getLineCount(); i++)
 			lineNumbers.add(context.drawText(3, font, style.lineBarTextColor, 0, 0, Integer.toString(i + 1)));
 		
-		for (TokenLine line : tokens.getLines())
+		for (TokenLine line : tokens.getLines()) {
 			drawnTokens.add(lineToTokens(line));
+			line.lengthInPixels = measureLineLength(line);
+		}
 		
 		window.aspectBar.toolbars.add(editToolbar);
 		window.aspectBar.active.setValue(editToolbar);
+		
+		updatePreferredSize();
 	}
 	
 	@Override
 		return token.type == ZSTokenType.T_WHITESPACE_TAB ? tab : token.content;
 	}
 	
-	private void onLinesUpdated() {
-		sizing.setValue(new DSizing(0, fullLineHeight * tokens.getLineCount()));
-	}
-	
 	private void layoutLines(int fromIndex) {
 		for (int i = fromIndex; i < drawnTokens.size(); i++) {
 			layoutLine(i);
 		return tokenLine;
 	}
 	
+	private int measureLineLength(TokenLine line) {
+		int result = 0;
+		for (ZSToken token : line.getTokens()) {
+			String content = getDisplayContent(token);
+			result += fontMetrics.getWidth(content);
+		}
+		return result;
+	}
+	
+	private void updatePreferredSize() {
+		int width = 0;
+		for (TokenLine line : tokens.getLines()) {
+			width = Math.max(width, line.lengthInPixels);
+		}
+		
+		DSizing sizing = new DSizing(width + lineBarWidth, fullLineHeight * tokens.getLineCount());
+		this.sizing.setValue(sizing);
+		System.out.println("Preferred size: " + sizing.preferredWidth + " x " + sizing.preferredHeight);
+	}
+	
 	private class TokenListener implements TokenModel.Listener {
 
 		@Override
 		public void onLineInserted(int index) {
-			onLinesUpdated();
-			
 			if (bounds != null) {
 				String str = Integer.toString(lineNumbers.size() + 1);
 				int x = bounds.x + lineBarWidth - style.lineBarSpacingRight - style.lineBarMargin - fontMetrics.getWidth(str);
 				int y = bounds.y + style.selectionPaddingTop + lineNumbers.size() * fullLineHeight + fontMetrics.getAscent();
 				lineNumbers.add(context.drawText(3, font, style.lineBarTextColor, x, y, str));
 				
-				drawnTokens.add(index, lineToTokens(tokens.getLine(index)));
+				TokenLine line = tokens.getLine(index);
+				drawnTokens.add(index, lineToTokens(line));
 				layoutLines(index);
+				
+				line.lengthInPixels = measureLineLength(line);
 			}
+			
+			updatePreferredSize();
 		}
 
 		@Override
 		public void onLineChanged(int index) {
 			if (bounds != null) {
 				Destructible.close(drawnTokens.get(index));
-				drawnTokens.set(index, lineToTokens(tokens.getLine(index)));
+				
+				TokenLine line = tokens.getLine(index);
+				drawnTokens.set(index, lineToTokens(line));
 				layoutLine(index);
+				
+				line.lengthInPixels = measureLineLength(line);
+				updatePreferredSize();
 			}
 		}
 
 		@Override
 		public void onLineDeleted(int index) {
-			onLinesUpdated();
+			updatePreferredSize();
 			
 			if (index >= lineNumbers.size())
 				return;

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/editor/TokenLine.java

 	private final List<ZSToken> tokens = new ArrayList<>();
 	private int length = 0;
 	
+	public int lengthInPixels = 0; // used by SourceEditor
+	
 	public List<ZSToken> getTokens() {
 		return Collections.unmodifiableList(tokens);
 	}

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaCompiledModule.java

 	public JavaMethod getMethodInfo(IDefinitionMember member) {
 		JavaMethod method = methods.get(member);
 		if (method == null)
-			throw new IllegalStateException("Missing field info for field " + member.getDefinition().name + "." + member.describe());
+			throw new IllegalStateException("Missing method info for method " + member.getDefinition().name + "." + member.describe());
 		
 		return method;
 	}

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

 			}
 			case T_IDENTIFIER: {
 				String name = parser.next().content;
+				if (name.startsWith("@"))
+					name = name.substring(1);
+				
 				List<IParsedType> genericParameters = IParsedType.parseTypeArguments(parser);
 				return new ParsedExpressionVariable(position, name, genericParameters);
 			}
+			case T_LOCAL_IDENTIFIER: {
+				String name = parser.next().content.substring(1);
+				return new ParsedLocalVariableExpression(position, name);
+			}
 			case K_THIS:
 				parser.next();
 				return new ParsedExpressionThis(position);

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

 		}
 		
 		StoredType functionType = scope.getTypeRegistry()
-				.getFunction(genericHeader.withGenericArguments(scope.getTypeRegistry(), new GenericMapper(scope.getTypeRegistry(), scope.genericInferenceMap)))
+				.getFunction(genericHeader.withGenericArguments(new GenericMapper(scope.getTypeRegistry(), scope.genericInferenceMap)))
 				.stored(storage);
 		return new FunctionExpression(position, functionType, closure, header, statements);
 	}

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

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberGroup;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.StoredType;

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

 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;

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

 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.StoredType;

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedLocalVariableExpression.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.parser.expression;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.codemodel.expression.GetFieldExpression;
+import org.openzen.zenscript.codemodel.expression.ThisExpression;
+import org.openzen.zenscript.codemodel.partial.IPartialExpression;
+import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberGroup;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ParsedLocalVariableExpression extends ParsedExpression {
+	private final String name;
+	
+	public ParsedLocalVariableExpression(CodePosition position, String name) {
+		super(position);
+		
+		this.name = name;
+	}
+
+	@Override
+	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
+		TypeMembers members = scope.getTypeMembers(scope.getThisType());
+		TypeMemberGroup group = members.getGroup(name);
+		if (group == null)
+			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "No such field: " + name);
+		if (group.getField() == null)
+			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "No such field: " + name);
+		
+		return new GetFieldExpression(position, new ThisExpression(position, scope.getThisType()), group.getField());
+	}
+
+	@Override
+	public boolean hasStrongType() {
+		return true;
+	}
+}

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

 import org.openzen.zenscript.codemodel.statement.CatchClause;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
 import org.openzen.zenscript.codemodel.statement.VariableID;

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

 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.SwitchStatement;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.scope.StatementScope;

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedNamedType.java

 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedTypeGenericMap.java

 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;

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

 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;