- Fixed validator acting up on type argument validation

- Moved enum constants to enum type, they are no longer type members
- Added override modifier
- Performed some minor fixes during compilation
- Fixed type member registration on optionals
- Expanded arrays with functional methods
-

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

@@ -105,7 +105,7 @@ public class DefinitionFormatter implements DefinitionVisitor<Void> {
 					.append("{\n");
 		}
 		
-		List<EnumConstantMember> enumConstants = definition.getEnumConstants();
+		List<EnumConstantMember> enumConstants = definition.enumConstants;
 		boolean first = true;
 		ExpressionFormatter expressionFormatter = new ExpressionFormatter(settings, typeFormatter);
 		for (EnumConstantMember enumConstant : enumConstants) {

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

@@ -125,11 +125,6 @@ public class MemberFormatter implements MemberVisitor<Void> {
 		return null;
 	}
 
-	@Override
-	public Void visitEnumConstant(EnumConstantMember member) {
-		return null; // TODO: handle separately
-	}
-
 	@Override
 	public Void visitOperator(OperatorMember member) {
 		visit(false);

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

@@ -74,15 +74,6 @@ public abstract class HighLevelDefinition extends Taggable {
 		return fields;
 	}
 	
-	public List<EnumConstantMember> getEnumConstants() {
-		List<EnumConstantMember> enumMembers = new ArrayList<>();
-		for (IDefinitionMember member : members)
-            if (member instanceof EnumConstantMember)
-				enumMembers.add((EnumConstantMember) member);
-		
-		return enumMembers;
-	}
-	
 	public boolean hasEmptyConstructor() {
 		for (IDefinitionMember member : members) {
 			if (member instanceof ConstructorMember) {

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

@@ -24,6 +24,7 @@ public class Modifiers {
 	public static final int IMPLICIT = 512;
 	public static final int VIRTUAL = 1024;
 	public static final int EXTERN = 2048;
+	public static final int OVERRIDE = 4096;
 	
 	public static boolean isPublic(int modifiers) {
 		return (modifiers & PUBLIC) > 0;

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

@@ -5,7 +5,10 @@
  */
 package org.openzen.zenscript.codemodel.definition;
 
+import java.util.ArrayList;
+import java.util.List;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
@@ -13,6 +16,8 @@ import org.openzen.zenscript.shared.CodePosition;
  * @author Hoofdgebruiker
  */
 public class EnumDefinition extends HighLevelDefinition {
+	public List<EnumConstantMember> enumConstants = new ArrayList<>();
+	
 	public EnumDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
 		super(position, pkg, name, modifiers, outerDefinition);
 	}
@@ -21,4 +26,8 @@ public class EnumDefinition extends HighLevelDefinition {
 	public <T> T accept(DefinitionVisitor<T> visitor) {
 		return visitor.visitEnum(this);
 	}
+	
+	public void addEnumConstant(EnumConstantMember constant) {
+		enumConstants.add(constant);
+	}
 }

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

@@ -8,9 +8,7 @@ package org.openzen.zenscript.codemodel.definition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
-import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.member.CallerMember;
-import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/ParameterTypeBound.java

@@ -28,7 +28,7 @@ public class ParameterTypeBound extends GenericParameterBound {
 
 	@Override
 	public void registerMembers(LocalMemberCache cache, TypeMembers type) {
-		cache.get(this.type).copyMembersTo(position, type, TypeMemberPriority.SPECIFIED);
+		cache.get(this.type).copyMembersTo(position, type, TypeMemberPriority.FROM_TYPE_BOUNDS);
 	}
 
 	@Override

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

@@ -5,51 +5,26 @@
  */
 package org.openzen.zenscript.codemodel.member;
 
-import java.util.Map;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.expression.NewExpression;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
-import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class EnumConstantMember extends DefinitionMember {
+public class EnumConstantMember {
+	public final CodePosition position;
+	public final HighLevelDefinition definition;
 	public final String name;
 	public final int value;
 	
 	public NewExpression constructor;
 	
 	public EnumConstantMember(CodePosition position, HighLevelDefinition definition, String name, int value) {
-		super(position, definition, Modifiers.STATIC);
-		
+		this.position = position;
+		this.definition = definition;
 		this.name = name;
 		this.value = value;
 	}
-
-	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addEnumMember(this, priority);
-	}
-
-	@Override
-	public DefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		throw new UnsupportedOperationException("Enums can't have type parameters");
-	}
-
-	@Override
-	public String describe() {
-		return "enum member " + name;
-	}
-
-	@Override
-	public <T> T accept(MemberVisitor<T> visitor) {
-		return visitor.visitEnumConstant(this);
-	}
 }

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

@@ -22,8 +22,6 @@ public interface MemberVisitor<T> {
 	
 	public T visitSetter(SetterMember member);
 	
-	public T visitEnumConstant(EnumConstantMember member);
-	
 	public T visitOperator(OperatorMember member);
 	
 	public T visitCaster(CasterMember member);

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

@@ -53,8 +53,8 @@ public class PartialMemberGroupExpression implements IPartialExpression {
 	
 	@Override
 	public List<ITypeID> getAssignHints() {
-		if (group.getGetter() != null)
-			return Collections.singletonList(group.getGetter().getType());
+		if (group.getSetter() != null)
+			return Collections.singletonList(group.getSetter().type);
 		if (group.getField() != null)
 			return Collections.singletonList(group.getField().type);
 		

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

@@ -5,6 +5,7 @@
  */
 package org.openzen.zenscript.codemodel.partial;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 import org.openzen.zenscript.codemodel.FunctionHeader;
@@ -78,4 +79,14 @@ public class PartialStaticMemberGroupExpression implements IPartialExpression {
 	public ITypeID[] getGenericCallTypes() {
 		return typeArguments;
 	}
+	
+	@Override
+	public List<ITypeID> getAssignHints() {
+		if (group.getSetter() != null)
+			return Collections.singletonList(group.getSetter().type);
+		if (group.getField() != null)
+			return Collections.singletonList(group.getField().type);
+		
+		return Collections.emptyList();
+	}
 }

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

@@ -7,7 +7,6 @@ package org.openzen.zenscript.codemodel.type;
 
 import java.util.Arrays;
 import java.util.Map;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 /**

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

@@ -6,18 +6,13 @@
 package org.openzen.zenscript.codemodel.type.member;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.AccessScope;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.shared.CompileException;
-import org.openzen.zenscript.shared.CompileExceptionCode;
 
 /**
  *
@@ -55,32 +50,9 @@ public class LocalMemberCache {
 	
 	private void registerMembers(TypeMembers members) {
 		members.type.accept(new TypeMemberBuilder(registry, members, this));
-		
-		for (ExpansionDefinition expansion : expansions) {
-			if (expansion.target == null)
-				throw new CompileException(expansion.position, CompileExceptionCode.INTERNAL_ERROR, "Missing expansion target");
-			
-			Map<TypeParameter, ITypeID> mapping = matchType(members.type, expansion.target);
-			if (mapping != null) {
-				if (mapping.isEmpty()) {
-					for (IDefinitionMember member : expansion.members)
-						member.registerTo(members, TypeMemberPriority.SPECIFIED);
-				} else {
-					for (IDefinitionMember member : expansion.members)
-						member.instance(registry, mapping).registerTo(members, TypeMemberPriority.SPECIFIED);
-				}
-			}
-		}
 	}
 	
-	private Map<TypeParameter, ITypeID> matchType(ITypeID type, ITypeID pattern) {
-		if (type == pattern)
-			return Collections.emptyMap();
-		
-		Map<TypeParameter, ITypeID> mapping = new HashMap<>();
-		if (pattern.inferTypeParameters(this, type, mapping))
-			return mapping;
-		
-		return null;
+	public List<ExpansionDefinition> getExpansions() {
+		return expansions;
 	}
 }

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

@@ -24,7 +24,10 @@ public class TypeMember<T extends IDefinitionMember> {
 	
 	public TypeMember<T> resolve(TypeMember<T> other) {
 		if (priority == other.priority)
-			throw new CompileException(other.member.getPosition(), CompileExceptionCode.MEMBER_DUPLICATE, "Duplicate " + other.member.describe());
+			if (priority == TypeMemberPriority.SPECIFIED)
+				throw new CompileException(other.member.getPosition(), CompileExceptionCode.MEMBER_DUPLICATE, "Duplicate " + other.member.describe());
+			else
+				return this;
 		
 		if (priority.compareTo(other.priority) < 0) {
 			return other;

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

@@ -5,6 +5,7 @@
  */
 package org.openzen.zenscript.codemodel.type.member;
 
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -15,6 +16,7 @@ import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
 import org.openzen.zenscript.codemodel.definition.StructDefinition;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
@@ -26,6 +28,7 @@ import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.EqualsMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.FunctionalMember;
@@ -58,6 +61,8 @@ import org.openzen.zenscript.codemodel.type.OptionalTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import static org.openzen.zenscript.codemodel.type.member.BuiltinTypeMembers.*;
 import static org.openzen.zenscript.shared.CodePosition.BUILTIN;
+import org.openzen.zenscript.shared.CompileException;
+import org.openzen.zenscript.shared.CompileExceptionCode;
 
 /**
  *
@@ -77,6 +82,35 @@ public class TypeMemberBuilder implements ITypeVisitor<Void> {
 			members.addOperator(OperatorType.EQUALS, new EqualsMember(members.type), TypeMemberPriority.BUILTIN_DEFAULT);
 		}
 	}
+	
+	private void registerExpansions(ITypeID type) {
+		for (ExpansionDefinition expansion : cache.getExpansions()) {
+			if (expansion.target == null)
+				throw new CompileException(expansion.position, CompileExceptionCode.INTERNAL_ERROR, "Missing expansion target");
+			
+			Map<TypeParameter, ITypeID> mapping = matchType(type, expansion.target);
+			if (mapping != null) {
+				if (mapping.isEmpty()) {
+					for (IDefinitionMember member : expansion.members)
+						member.registerTo(members, TypeMemberPriority.SPECIFIED);
+				} else {
+					for (IDefinitionMember member : expansion.members)
+						member.instance(registry, mapping).registerTo(members, TypeMemberPriority.SPECIFIED);
+				}
+			}
+		}
+	}
+	
+	private Map<TypeParameter, ITypeID> matchType(ITypeID type, ITypeID pattern) {
+		if (type == pattern)
+			return Collections.emptyMap();
+		
+		Map<TypeParameter, ITypeID> mapping = new HashMap<>();
+		if (pattern.inferTypeParameters(cache, type, mapping))
+			return mapping;
+		
+		return null;
+	}
 
 	@Override
 	public Void visitBasic(BasicTypeID basic) {
@@ -103,6 +137,8 @@ public class TypeMemberBuilder implements ITypeVisitor<Void> {
 				visitString();
 				break;
 		}
+		
+		registerExpansions(basic);
 		return null;
 	}
 
@@ -166,6 +202,8 @@ public class TypeMemberBuilder implements ITypeVisitor<Void> {
 		members.addIterator(new ArrayIteratorKeyValues(array), TypeMemberPriority.SPECIFIED);
 		members.addIterator(new ArrayIteratorValues(array), TypeMemberPriority.SPECIFIED);
 		members.addMethod(new MethodMember(BUILTIN, definition, 0, "clear", new FunctionHeader(VOID)), TypeMemberPriority.SPECIFIED);
+		
+		registerExpansions(array);
 		return null;
 	}
 
@@ -195,6 +233,8 @@ public class TypeMemberBuilder implements ITypeVisitor<Void> {
 		members.addGetter(new GetterMember(BUILTIN, definition, Modifiers.PUBLIC | Modifiers.EXTERN, "objectHashCode", BasicTypeID.INT));
 		
 		members.addIterator(new AssocIterator(assoc), TypeMemberPriority.SPECIFIED);
+		
+		registerExpansions(assoc);
 		return null;
 	}
 	
@@ -208,6 +248,8 @@ public class TypeMemberBuilder implements ITypeVisitor<Void> {
 		members.addMethod(new MethodMember(BUILTIN, definition, 0, "put", new FunctionHeader(map.keys, BasicTypeID.VOID, null, new FunctionParameter(valueType))));
 		members.addMethod(new MethodMember(BUILTIN, definition, 0, "contains", new FunctionHeader(map.keys, BasicTypeID.BOOL, null, new FunctionParameter[0])));
 		members.addGetter(new GetterMember(BUILTIN, definition, Modifiers.PUBLIC | Modifiers.EXTERN, "objectHashCode", BasicTypeID.INT));
+		
+		registerExpansions(map);
 		return null;
 	}
 	
@@ -220,6 +262,8 @@ public class TypeMemberBuilder implements ITypeVisitor<Void> {
 	public Void visitFunction(FunctionTypeID function) {
 		FunctionDefinition definition = new FunctionDefinition(BUILTIN, null, "", Modifiers.EXPORT, function.header);
 		members.addCaller(new CallerMember(BUILTIN, definition, 0, function.header), TypeMemberPriority.SPECIFIED);
+		
+		registerExpansions(function);
 		return null;
 	}
 
@@ -260,6 +304,13 @@ public class TypeMemberBuilder implements ITypeVisitor<Void> {
 					members.addVariantOption(option);
 			}
 		}
+		
+		if (definition instanceof EnumDefinition) {
+			EnumDefinition enumDef = (EnumDefinition) definition;
+			for (EnumConstantMember constant : enumDef.enumConstants) {
+				members.addEnumMember(constant, TypeMemberPriority.SPECIFIED);
+			}
+		}
 
 		DefinitionMemberGroup constructors = members.getOrCreateGroup(OperatorType.CONSTRUCTOR);
 		if (constructors.getMethodMembers().isEmpty()) {
@@ -286,15 +337,22 @@ public class TypeMemberBuilder implements ITypeVisitor<Void> {
 		}
 		
 		if (definition instanceof EnumDefinition) {
-			members.addGetter(new GetterMember(BUILTIN, definition, 0, "name", BasicTypeID.STRING), TypeMemberPriority.SPECIFIED);
-			members.addGetter(new GetterMember(BUILTIN, definition, 0, "ordinal", BasicTypeID.INT), TypeMemberPriority.SPECIFIED);
+			members.addGetter(new GetterMember(BUILTIN, definition, Modifiers.PUBLIC, "name", BasicTypeID.STRING), TypeMemberPriority.SPECIFIED);
+			members.addGetter(new GetterMember(BUILTIN, definition, Modifiers.PUBLIC, "ordinal", BasicTypeID.INT), TypeMemberPriority.SPECIFIED);
+			members.addField(new FieldMember(BUILTIN, definition, Modifiers.PUBLIC | Modifiers.STATIC, "VALUES", registry.getArray(type, 1)));
 			
 			if (!members.canCast(BasicTypeID.STRING)) {
 				members.addCaster(new CasterMember(BUILTIN, definition, Modifiers.PUBLIC | Modifiers.EXTERN | Modifiers.IMPLICIT, BasicTypeID.STRING));
 			}
 		}
 		
-		members.addGetter(new GetterMember(BUILTIN, definition, Modifiers.PUBLIC | Modifiers.EXTERN, "objectHashCode", BasicTypeID.INT));
+		if (type.superType != null) {
+			cache.get(type.superType).copyMembersTo(type.definition.position, members, TypeMemberPriority.INHERITED);
+		} else {
+			members.addGetter(new GetterMember(BUILTIN, definition, Modifiers.PUBLIC | Modifiers.EXTERN, "objectHashCode", BasicTypeID.INT));
+		}
+		
+		registerExpansions(type);
 		return null;
 	}
 
@@ -305,6 +363,7 @@ public class TypeMemberBuilder implements ITypeVisitor<Void> {
 		for (GenericParameterBound bound : parameter.bounds) {
 			bound.registerMembers(cache, members);
 		}
+		
 		return null;
 	}
 
@@ -326,17 +385,23 @@ public class TypeMemberBuilder implements ITypeVisitor<Void> {
 				|| range.from == BasicTypeID.ULONG)) {
 			members.addIterator(new RangeIterator(range), TypeMemberPriority.SPECIFIED);
 		}
+		
+		registerExpansions(range);
 		return null;
 	}
 
 	@Override
 	public Void visitConst(ConstTypeID type) {
-		return type.baseType.accept(this);
+		type.baseType.accept(this);
+		registerExpansions(type);
+		return null;
 	}
 
 	@Override
 	public Void visitOptional(OptionalTypeID optional) {
-		return optional.baseType.accept(this);
+		optional.baseType.accept(this);
+		registerExpansions(optional);
+		return null;
 	}
 	
 	private void visitBool() {

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

@@ -11,6 +11,7 @@ package org.openzen.zenscript.codemodel.type.member;
  */
 public enum TypeMemberPriority {
 	BUILTIN_DEFAULT,
+	FROM_TYPE_BOUNDS,
 	INTERFACE,
 	INHERITED,
 	SPECIFIED;

Constructor/libraries/stdlib/src/Arrays.zs

@@ -16,4 +16,82 @@ export expand <T> T[] {
 	public extern copy() as T[];
 	public extern copy(newSize as int) as T[];
 	public extern copyTo(target as T[], sourceOffset as int, targetOffset as int, length as int) as void;
+	
+	public get first as T?;
+	public get last as T?;
+	
+	public map<U>(projection as function(value as T) as U) as U[] {
+		val result as U[] = new U[](this.length);
+		for i, value in this
+			result[i] = projection(value);
+		return result;
+	}
+	
+	public map<U>(projection as function(index as int, value as T) as U) as U[] {
+		val result as U[] = new U[](this.length);
+		for i, value in this
+			result[i] = projection(i, value);
+		return result;
+	}
+	
+	public extern filter(predicate as function(value as T) as bool) as T[];
+	public extern filter(predicate as function(index as int, value as T) as bool) as T[];
+	
+	public each(consumer as function(value as T) as void) as void {
+		for value in this
+			consumer(value);
+	}
+	
+	public each(consumer as function(index as int, value as T) as void) as void {
+		for i, value in this
+			consumer(i, value);
+	}
+	
+	public contains(predicate as function(value as T) as bool) as bool {
+		for value in this
+			if predicate(value)
+				return true;
+		
+		return false;
+	}
+	
+	public contains(predicate as function(index as int, value as T) as bool) as bool {
+		for i, value in this
+			if predicate(i, value)
+				return true;
+		
+		return false;
+	}
+	
+	public all(predicate as function(value as T) as bool) as bool {
+		for value in this
+			if !predicate(value)
+				return false;
+		
+		return true;
+	}
+	
+	public all(predicate as function(i as int, value as T) as bool) as bool {
+		for i, value in this
+			if !predicate(i, value)
+				return false;
+		
+		return true;
+	}
+	
+	public count(predicate as function(value as T) as bool) as int {
+		var result = 0;
+		for value in this
+			if predicate(value)
+				result++;
+		return result;
+	}
+	
+	public count(predicate as function(index as int, value as T) as bool) as int {
+		var result = 0;
+		for i, value in this
+			if predicate(i, value)
+				result++;
+		return result;
+	}
 }

Constructor/libraries/stdlib/src/Assoc.zs

@@ -0,0 +1,8 @@
+export expand <K, V> V[K] {
+	mapValues<W>(projection as function(value as V) as W) as W[K] {
+		val result = new W[K];
+		for k, v in this
+			result[k] = projection(v);
+		return result;
+	}
+}

Constructor/libraries/stdlib/src/Strings.zs

@@ -1,5 +1,8 @@
 export expand string {
-	public get isEmpty as bool => length == 0;
+	public get empty as bool => length == 0;
+	
+	public const in(c as char)as bool
+		=> indexOf(c) >= 0;
 	
 	public const indexOf(c as char) as int {
 		for i in 0 .. length {
@@ -54,6 +57,8 @@ export expand string {
 		return result;
 	}
 	
+	public const extern trim() as string;
+	
 	public const lpad(length as int, c as char) as string
 		=> this.length >= length ? this : c.times(length - this.length) + this;
 	

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

@@ -92,7 +92,7 @@ public class Module {
 			// respective definitions, such as fields, constructors, methods...
 			// It doesn't yet compile the method contents.
 			try {
-				file.compileTypes(rootPackage, definitions, registry.typeRegistry, expansions, globals);
+				file.compileTypes(rootPackage, pkg, definitions, registry.typeRegistry, expansions, globals);
 			} catch (CompileException ex) {
 				System.out.println(ex.getMessage());
 				failed = true;
@@ -107,7 +107,7 @@ public class Module {
 			// respective definitions, such as fields, constructors, methods...
 			// It doesn't yet compile the method contents.
 			try {
-				file.compileMembers(rootPackage, definitions, registry.typeRegistry, expansions, globals);
+				file.compileMembers(rootPackage, pkg, definitions, registry.typeRegistry, expansions, globals);
 			} catch (CompileException ex) {
 				System.out.println(ex.getMessage());
 				failed = true;
@@ -124,7 +124,7 @@ public class Module {
 			// into semantic code. This semantic code can then be compiled
 			// to various targets.
 			try {
-				file.compileCode(rootPackage, definitions, registry.typeRegistry, expansions, scripts, globals);
+				file.compileCode(rootPackage, pkg, definitions, registry.typeRegistry, expansions, scripts, globals);
 			} catch (CompileException ex) {
 				System.out.println(ex.getMessage());
 				failed = true;

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

@@ -160,28 +160,6 @@ public class JavaMemberVisitor implements MemberVisitor<Void> {
         return null;
     }
 
-    @Override
-    public Void visitEnumConstant(EnumConstantMember member) {
-        writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_ENUM, member.name, "L" + definition.name + ";", null, null).visitEnd();
-        final String internalName = member.constructor.type.accept(JavaTypeVisitor.INSTANCE).getInternalName();
-        final JavaWriter clinitWriter = clinitStatementVisitor.getJavaWriter();
-        clinitWriter.newObject(internalName);
-        clinitWriter.dup();
-        clinitWriter.constant(member.name);
-        clinitWriter.constant(member.value);
-        for (Expression argument : member.constructor.arguments.arguments) {
-            argument.accept(clinitStatementVisitor.expressionVisitor);
-        }
-
-        clinitWriter.invokeSpecial(internalName, "<init>", CompilerUtils.calcDesc(member.constructor.constructor.header, true));
-        clinitWriter.putStaticField(internalName, member.name, "L" + internalName + ";");
-
-
-        enumDefinition = (EnumDefinition) member.definition;
-
-        return null;
-    }
-
     @Override
     public Void visitOperator(OperatorMember member) {
         return null;
@@ -221,8 +199,26 @@ public class JavaMemberVisitor implements MemberVisitor<Void> {
     public void end() {
 
         if (enumDefinition != null) {
+			for (EnumConstantMember constant : enumDefinition.enumConstants) {
+				writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_ENUM, constant.name, "L" + definition.name + ";", null, null).visitEnd();
+				final String internalName = constant.constructor.type.accept(JavaTypeVisitor.INSTANCE).getInternalName();
+				final JavaWriter clinitWriter = clinitStatementVisitor.getJavaWriter();
+				clinitWriter.newObject(internalName);
+				clinitWriter.dup();
+				clinitWriter.constant(constant.name);
+				clinitWriter.constant(constant.value);
+				for (Expression argument : constant.constructor.arguments.arguments) {
+					argument.accept(clinitStatementVisitor.expressionVisitor);
+				}
+
+				clinitWriter.invokeSpecial(internalName, "<init>", CompilerUtils.calcDesc(constant.constructor.constructor.header, true));
+				clinitWriter.putStaticField(internalName, constant.name, "L" + internalName + ";");
+				
+				enumDefinition = (EnumDefinition) constant.definition;
+			}
+			
             final JavaWriter clinitWriter = clinitStatementVisitor.getJavaWriter();
-            final List<EnumConstantMember> enumConstants = enumDefinition.getEnumConstants();
+            final List<EnumConstantMember> enumConstants = enumDefinition.enumConstants;
             clinitWriter.constant(enumConstants.size());
             clinitWriter.newArray(Type.getType("L" + definition.name + ";"));
 

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

@@ -150,12 +150,13 @@ public class ParsedFile {
 	
 	public void compileTypes(
 			ZSPackage rootPackage,
+			ZSPackage modulePackage,
 			PackageDefinitions packageDefinitions,
 			GlobalTypeRegistry globalRegistry,
 			List<ExpansionDefinition> expansions,
 			Map<String, ISymbol> globalSymbols) {
 		FileScope scope = new FileScope(access, rootPackage, packageDefinitions, globalRegistry, expansions, globalSymbols);
-		loadImports(scope, rootPackage);
+		loadImports(scope, rootPackage, modulePackage);
 		for (ParsedDefinition definition : this.definitions) {
 			definition.compileTypes(scope);
 		}
@@ -163,12 +164,13 @@ public class ParsedFile {
 	
 	public void compileMembers(
 			ZSPackage rootPackage,
+			ZSPackage modulePackage,
 			PackageDefinitions packageDefinitions,
 			GlobalTypeRegistry globalRegistry,
 			List<ExpansionDefinition> expansions,
 			Map<String, ISymbol> globalSymbols) {
 		FileScope scope = new FileScope(access, rootPackage, packageDefinitions, globalRegistry, expansions, globalSymbols);
-		loadImports(scope, rootPackage);
+		loadImports(scope, rootPackage, modulePackage);
 		for (ParsedDefinition definition : this.definitions) {
 			definition.compileMembers(scope);
 		}
@@ -176,13 +178,14 @@ public class ParsedFile {
 	
 	public void compileCode(
 			ZSPackage rootPackage,
+			ZSPackage modulePackage,
 			PackageDefinitions packageDefinitions,
 			GlobalTypeRegistry globalRegistry,
 			List<ExpansionDefinition> expansions,
 			List<ScriptBlock> scripts,
 			Map<String, ISymbol> globalSymbols) {
 		FileScope scope = new FileScope(access, rootPackage, packageDefinitions, globalRegistry, expansions, globalSymbols);
-		loadImports(scope, rootPackage);
+		loadImports(scope, rootPackage, modulePackage);
 		for (ParsedDefinition definition : this.definitions) {
 			definition.compileCode(scope);
 		}
@@ -201,11 +204,17 @@ public class ParsedFile {
 		}
 	}
 	
-	private void loadImports(FileScope scope, ZSPackage rootPackage) {
+	private void loadImports(FileScope scope, ZSPackage rootPackage, ZSPackage modulePackage) {
 		for (ParsedImport importEntry : imports) {
-			HighLevelDefinition definition = rootPackage.getImport(importEntry.getPath(), 0);
+			HighLevelDefinition definition;
+			if (importEntry.isRelative()) {
+				definition = modulePackage.getImport(importEntry.getPath(), 0);
+			} else {
+				definition = rootPackage.getImport(importEntry.getPath(), 0);
+			}
+			
 			if (definition == null)
-				throw new CompileException(importEntry.position, CompileExceptionCode.IMPORT_NOT_FOUND, "Could not find type");
+				throw new CompileException(importEntry.position, CompileExceptionCode.IMPORT_NOT_FOUND, "Could not find type " + importEntry.toString());
 			
 			scope.register(importEntry.getName(), definition);
 		}

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

@@ -18,6 +18,8 @@ import static org.openzen.zenscript.lexer.ZSTokenType.*;
  */
 public class ParsedImport {
 	public static ParsedImport parse(CodePosition position, ZSTokenStream tokens) {
+		boolean relative = tokens.optional(T_DOT) != null;
+		
 		List<String> importName = new ArrayList<>();
 		ZSToken tName = tokens.required(T_IDENTIFIER, "identifier expected");
 		importName.add(tName.content);
@@ -34,15 +36,17 @@ public class ParsedImport {
 		}
 
 		tokens.required(T_SEMICOLON, "; expected");
-		return new ParsedImport(position, importName, rename);
+		return new ParsedImport(position, relative, importName, rename);
 	}
 	
 	public final CodePosition position;
+	private final boolean relative;
 	private final List<String> importName;
 	private final String rename;
 	
-	public ParsedImport(CodePosition position, List<String> importName, String rename) {
+	public ParsedImport(CodePosition position, boolean relative, List<String> importName, String rename) {
 		this.position = position;
+		this.relative = relative;
 		this.importName = importName;
 		this.rename = rename;
 	}
@@ -51,7 +55,22 @@ public class ParsedImport {
 		return rename == null ? importName.get(importName.size() - 1) : rename;
 	}
 	
+	public boolean isRelative() {
+		return relative;
+	}
+	
 	public List<String> getPath() {
 		return importName;
 	}
+	
+	@Override
+	public String toString() {
+		StringBuilder result = new StringBuilder();
+		for (int i = 0; i < importName.size(); i++) {
+			if (i > 0)
+				result.append('.');
+			result.append(importName.get(i));
+		}
+		return result.toString();
+	}
 }

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

@@ -70,7 +70,7 @@ public class ParsedEnum extends BaseParsedDefinition {
 		super.compileMembers(scope);
 		
 		for (ParsedEnumConstant constant : enumValues) {
-			compiled.addMember(constant.getCompiled());
+			compiled.addEnumConstant(constant.getCompiled());
 		}
 	}
 

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

@@ -43,6 +43,8 @@ public class ParsedFunctionHeader {
 		if (tokens.optional(T_BRCLOSE) == null) {
 			do {
 				ZSToken argName = tokens.required(T_IDENTIFIER, "identifier expected");
+				boolean variadic = tokens.optional(T_DOT3) != null;
+				
 				IParsedType type = ParsedTypeBasic.ANY;
 				if (tokens.optional(K_AS) != null) {
 					type = IParsedType.parse(tokens);
@@ -51,7 +53,6 @@ public class ParsedFunctionHeader {
 				if (tokens.optional(T_ASSIGN) != null) {
 					defaultValue = ParsedExpression.parse(tokens);
 				}
-				boolean variadic = tokens.optional(T_DOT3) != null;
 				parameters.add(new ParsedFunctionParameter(argName.content, type, defaultValue, variadic));
 			} while (tokens.optional(T_COMMA) != null);
 			tokens.required(T_BRCLOSE, ") expected");

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

@@ -1,38 +0,0 @@
-/*
- * 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.definitions;
-
-import java.util.List;
-import org.openzen.zenscript.shared.CodePosition;
-
-/**
- *
- * @author Stanneke
- */
-public class ParsedImport {
-	private final CodePosition position;
-	private final List<String> name;
-	private final String rename;
-
-	public ParsedImport(CodePosition position, List<String> name, String rename) {
-		this.position = position;
-		this.name = name;
-		this.rename = rename;
-	}
-
-	public CodePosition getPosition() {
-		return position;
-	}
-
-	public List<String> getName() {
-		return name;
-	}
-
-	public String getRename() {
-		return rename == null ? name.get(name.size() - 1) : rename;
-	}
-}

Parser/src/main/java/org/openzen/zenscript/parser/member/ParsedDefinitionMember.java

@@ -81,6 +81,10 @@ public abstract class ParsedDefinitionMember {
 					tokens.next();
 					modifiers |= Modifiers.EXTERN;
 					break;
+				case K_OVERRIDE:
+					tokens.next();
+					modifiers |= Modifiers.OVERRIDE;
+					break;
 				default:
 					break outer;
 			}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/Main.java

@@ -95,6 +95,8 @@ public class Main {
 	}
 	
 	private static SemanticModule compileSyntaxToSemantic(ParsedFile[] files, GlobalRegistry registry) {
+		ZSPackage modulePackage = new ZSPackage(null);
+		
 		// We are considering all these files to be in the same package, so make
 		// a single PackageDefinition instance. If these files were in multiple
 		// packages, we'd need an instance for every package.
@@ -115,7 +117,7 @@ public class Main {
 			// compileMembers will register all definition members to their
 			// respective definitions, such as fields, constructors, methods...
 			// It doesn't yet compile the method contents.
-			file.compileMembers(rootPackage, definitions, globalRegistry, expansions, globals);
+			file.compileMembers(rootPackage, modulePackage, definitions, globalRegistry, expansions, globals);
 		}
 		
 		// scripts will store all the script blocks encountered in the files
@@ -124,7 +126,7 @@ public class Main {
 			// compileCode will convert the parsed statements and expressions
 			// into semantic code. This semantic code can then be compiled
 			// to various targets.
-			file.compileCode(rootPackage, definitions, globalRegistry, expansions, scripts, globals);
+			file.compileCode(rootPackage, modulePackage, definitions, globalRegistry, expansions, scripts, globals);
 		}
 		
 		Validator validator = new Validator();

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

@@ -159,9 +159,8 @@ public class DefinitionMemberValidator implements MemberVisitor<Boolean> {
 		
 		return isValid;
 	}
-
-	@Override
-	public Boolean visitEnumConstant(EnumConstantMember member) {
+	
+	public boolean visitEnumConstant(EnumConstantMember member) {
 		boolean isValid = true;
 		isValid &= ValidationUtils.validateIdentifier(validator, member.position, member.name);
 		if (member.constructor != null) {

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

@@ -5,6 +5,8 @@
  */
 package org.openzen.zenscript.validator.visitors;
 
+import java.util.HashSet;
+import java.util.Set;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import static org.openzen.zenscript.codemodel.Modifiers.*;
@@ -17,7 +19,9 @@ import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.definition.StructDefinition;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.validator.ValidationLogEntry;
 import org.openzen.zenscript.validator.Validator;
 import org.openzen.zenscript.validator.analysis.StatementScope;
 
@@ -168,6 +172,11 @@ public class DefinitionValidator implements DefinitionVisitor<Boolean> {
 		for (IDefinitionMember member : definition.members) {
 			isValid &= member.accept(memberValidator);
 		}
+		if (definition instanceof EnumDefinition) {
+			for (EnumConstantMember constant : ((EnumDefinition) definition).enumConstants) {
+				isValid &= memberValidator.visitEnumConstant(constant);
+			}
+		}
 		return isValid;
 	}
 

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

@@ -148,10 +148,28 @@ public class ValidationUtils {
 			TypeParameter[] typeParameters,
 			ITypeID[] typeArguments)
 	{
-		if (typeParameters == null)
-			return typeArguments == null;
-		if (typeArguments == null)
+		if (typeParameters == null || typeParameters.length == 0) {
+			if (typeArguments == null || typeArguments.length == 0) {
+				return true;
+			} else {
+				target.logError(
+					ValidationLogEntry.Code.INVALID_TYPE_ARGUMENT,
+					position,
+					"Invalid number of type arguments: "
+							+ typeArguments.length
+							+ " arguments given but none expected");
+				return false;
+			}
+		}
+		if (typeArguments == null || typeArguments.length == 0) {
+			target.logError(
+					ValidationLogEntry.Code.INVALID_TYPE_ARGUMENT,
+					position,
+					"Invalid number of type arguments: "
+							+ typeParameters.length
+							+ " arguments expected but none given");
 			return false;
+		}
 		
 		if (typeParameters.length != typeArguments.length) {
 			target.logError(