- Added key sorting to switches

- Fixed a couple more bugs with generics

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

 	}
 	
 	public static void formatTypeParameters(StringBuilder result, TypeParameter[] parameters, TypeFormatter typeFormatter) {
-		if (parameters.length > 0) {
+		if (parameters != null) {
 			result.append("<");
 			int index = 0;
 			for (TypeParameter parameter : parameters) {

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

 	@Override
 	public String visitDefinition(DefinitionTypeID definition) {
 		String importedName = importer.importDefinition(definition.definition);
-		if (definition.typeParameters.length == 0)
+		if (definition.typeParameters == null)
 			return importedName;
 		
 		StringBuilder result = new StringBuilder();

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

  * @author Hoofdgebruiker
  */
 public class FunctionHeader {
-	private static final TypeParameter[] NO_GENERIC_PARAMETERS = new TypeParameter[0];
 	private static final FunctionParameter[] NO_PARAMETERS = new FunctionParameter[0];
 	
 	public final TypeParameter[] typeParameters;
 	public final FunctionParameter[] parameters;
 	
 	public FunctionHeader(ITypeID returnType) {
-		this.typeParameters = NO_GENERIC_PARAMETERS;
+		this.typeParameters = null;
 		this.returnType = returnType;
 		this.parameters = NO_PARAMETERS;
 	}
 	
 	public FunctionHeader(ITypeID returnType, FunctionParameter... parameters) {
-		this.typeParameters = NO_GENERIC_PARAMETERS;
+		this.typeParameters = null;
 		this.returnType = returnType;
 		this.parameters = parameters;
 	}
 		this.parameters = parameters;
 	}
 	
+	public int getNumberOfTypeParameters() {
+		return typeParameters == null ? 0 : typeParameters.length;
+	}
+	
 	public FunctionHeader instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		TypeParameter[] genericParameters = new TypeParameter[this.typeParameters.length];
-		for (int i = 0; i < genericParameters.length; i++)
-			genericParameters[i] = this.typeParameters[i].withGenericArguments(registry, mapping);
+		TypeParameter[] genericParameters = this.typeParameters == null ? null : new TypeParameter[this.typeParameters.length];
+		if (genericParameters != null)
+			for (int i = 0; i < genericParameters.length; i++)
+				genericParameters[i] = this.typeParameters[i].withGenericArguments(registry, mapping);
+		
 		ITypeID returnType = this.returnType.withGenericArguments(registry, mapping);
 		FunctionParameter[] parameters = new FunctionParameter[this.parameters.length];
 		for (int i = 0; i < parameters.length; i++)
 	
 	public FunctionHeader withGenericArguments(GlobalTypeRegistry registry, ITypeID[] arguments) {
 		Map<TypeParameter, ITypeID> typeArguments = new HashMap<>();
-		for (int i = 0; i < typeParameters.length; i++)
-			typeArguments.put(typeParameters[i], arguments[i]);
+		if (typeParameters != null)
+			for (int i = 0; i < typeParameters.length; i++)
+				typeArguments.put(typeParameters[i], arguments[i]);
 		
 		ITypeID returnType = this.returnType.withGenericArguments(registry, typeArguments);
 		FunctionParameter[] parameters = new FunctionParameter[this.parameters.length];

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

 		this.typeArguments = typeArguments;
 		this.arguments = arguments;
 	}
+	
+	public int getNumberOfTypeArguments() {
+		return typeArguments.length;
+	}
 }

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.length > 0)
+		if (definition.genericParameters != null)
 			throw new IllegalArgumentException("Definition has type arguments!");
 		
 		return new DefinitionTypeID(definition, null);

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

 				if (definitionType.definition != definition.definition)
 					return false;
 				
-				for (int i = 0; i < definitionType.typeParameters.length; i++) {
-					if (!match(definitionType.typeParameters[i], definition.typeParameters[i]))
-						return false;
+				if (definition.typeParameters != null) {
+					for (int i = 0; i < definitionType.typeParameters.length; i++) {
+						if (!match(definitionType.typeParameters[i], definition.typeParameters[i]))
+							return false;
+					}
 				}
 				
 				return true;

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

 			if (header.parameters.length != arguments)
 				continue;
 			
-			if (header.typeParameters.length > 0) {
+			if (header.typeParameters != null) {
 				for (ITypeID resultHint : typeHints) {
 					Map<TypeParameter, ITypeID> mapping = new HashMap<>();
 					if (header.returnType.inferTypeParameters(scope.getMemberCache(), resultHint, mapping)) {
 			FunctionHeader header = method.member.getHeader();
 			if (header.parameters.length != arguments.arguments.length)
 				continue;
-			if (header.typeParameters.length != arguments.typeArguments.length)
+			if (header.getNumberOfTypeParameters() != arguments.getNumberOfTypeArguments())
 				continue;
 			
 			if (arguments.typeArguments.length > 0) {
 			FunctionHeader header = method.member.getHeader();
 			if (header.parameters.length != arguments.arguments.length)
 				continue;
-			if (header.typeParameters.length != arguments.typeArguments.length)
+			if (header.getNumberOfTypeParameters() != arguments.getNumberOfTypeArguments())
 				continue;
 			
 			if (arguments.typeArguments.length > 0) {

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

         final boolean hasNoDefault = hasNoDefault(statement);
 
         final List<SwitchCase> cases = statement.cases;
-
-        final int[] keys = new int[hasNoDefault ? cases.size() : cases.size() - 1];
-        final Label[] labels = new Label[keys.length];
+		final JavaSwitchLabel[] switchLabels = new JavaSwitchLabel[hasNoDefault ? cases.size() : cases.size() - 1];
         final Label defaultLabel = new Label();
-
-        Arrays.parallelSetAll(labels, value -> new Label());
-
+		
         int i = 0;
-        for (final SwitchCase switchCase : cases)
-            if (switchCase.value != null)
-                keys[i++] = CompilerUtils.getKeyForSwitch(switchCase.value);
+        for (final SwitchCase switchCase : cases) {
+            if (switchCase.value != null) {
+				switchLabels[i++] = new JavaSwitchLabel(CompilerUtils.getKeyForSwitch(switchCase.value), new Label());
+			}
+		}
+		
+		JavaSwitchLabel[] sortedSwitchLabels = Arrays.copyOf(switchLabels, switchLabels.length);
+		Arrays.sort(sortedSwitchLabels, (a, b) -> a.key - b.key);
 
-        javaWriter.lookupSwitch(defaultLabel, keys, labels);
+        javaWriter.lookupSwitch(defaultLabel, sortedSwitchLabels);
 
         i = 0;
         for (final SwitchCase switchCase : cases) {
             if (hasNoDefault || switchCase.value != null) {
-                javaWriter.label(labels[i++]);
+                javaWriter.label(switchLabels[i++].label);
             } else {
                 javaWriter.label(defaultLabel);
             }
         for (SwitchCase switchCase : switchStatement.cases)
             if (switchCase.value == null) return false;
         return true;
-    }
+	}
 
     @Override
     public Boolean visitThrow(ThrowStatement statement) {

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaSwitchLabel.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.javabytecode.compiler;
+
+import org.objectweb.asm.Label;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSwitchLabel {
+	public final int key;
+	public final Label label;
+	
+	public JavaSwitchLabel(int key, Label label) {
+		this.key = key;
+		this.label = label;
+	}
+}

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

             visitor.visitParameter(name, modifier);
     }
 
-    public void lookupSwitch(Label defaultLabel, int[] keys, Label[] labels) {
+    public void lookupSwitch(Label defaultLabel, JavaSwitchLabel[] switchLabels) {
+		int[] keys = new int[switchLabels.length];
+		Label[] labels = new Label[switchLabels.length];
+		for (int i = 0; i < switchLabels.length; i++) {
+			keys[i] = switchLabels[i].key;
+			labels[i] = switchLabels[i].label;
+		}
+		
         visitor.visitLookupSwitchInsn(defaultLabel, keys, labels);
     }
 

Linker/src/main/java/org/openzen/zenscript/linker/ExpressionScope.java

 	}
 	
 	public ExpressionScope forCall(FunctionHeader header) {
-		if (header.typeParameters.length == 0)
+		if (header.typeParameters == null)
 			return this;
 		
 		Map<TypeParameter, ITypeID> genericInferenceMap = new HashMap<>();

Linker/src/main/java/org/openzen/zenscript/linker/FunctionScope.java

 				}
 			}
 			
-			for (TypeParameter parameter : header.typeParameters) {
-				if (parameter.name.equals(name.name))
-					return new PartialTypeExpression(position, getTypeRegistry().getGeneric(parameter));
+			if (header.typeParameters != null) {
+				for (TypeParameter parameter : header.typeParameters) {
+					if (parameter.name.equals(name.name))
+						return new PartialTypeExpression(position, getTypeRegistry().getGeneric(parameter));
+				}
 			}
 		}
 		
 	@Override
 	public ITypeID getType(CodePosition position, List<GenericName> name) {
 		if (name.size() == 1 && name.get(0).hasNoArguments()) {
-			for (TypeParameter parameter : header.typeParameters) {
-				if (parameter.name.equals(name.get(0).name))
-					return getTypeRegistry().getGeneric(parameter);
+			if (header.typeParameters != null) {
+				for (TypeParameter parameter : header.typeParameters) {
+					if (parameter.name.equals(name.get(0).name))
+						return getTypeRegistry().getGeneric(parameter);
+				}
 			}
 		}
 		

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

  */
 public class ParsedFunctionHeader {
 	public static ParsedFunctionHeader parse(ZSTokenStream tokens) {
-		List<ParsedGenericParameter> genericParameters = new ArrayList<>();
+		List<ParsedGenericParameter> genericParameters = null;
 		if (tokens.optional(ZSTokenType.T_LESS) != null) {
+			genericParameters = new ArrayList<>();
 			do {
 				genericParameters.add(ParsedGenericParameter.parse(tokens));
 			} while (tokens.optional(ZSTokenType.T_COMMA) != null);

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

 			innerScope = scope.forCall(candidates.get(0));
 		} else {
 			candidates = candidates.stream()
-					.filter(candidate -> candidate.typeParameters.length == 0)
+					.filter(candidate -> candidate.typeParameters == null)
 					.collect(Collectors.toList());
 			
 			if (candidates.isEmpty()) {
 		ITypeID[] typeParameters = genericParameters;
 		if (typeParameters == null) {
 			for (FunctionHeader candidate : candidates) {
-				if (candidate.typeParameters.length > 0) {
+				if (candidate.typeParameters != null) {
 					typeParameters = new ITypeID[candidate.typeParameters.length];
 					for (int i = 0; i < typeParameters.length; i++) {
 						if (innerScope.genericInferenceMap.get(candidate.typeParameters[i]) == null)
 			return false;
 		
 		for (int i = 0; i < arguments.size(); i++) {
-			if (typeParameters == null && header.parameters[i].type.hasInferenceBlockingTypeParameters(header.typeParameters))
+			if (typeParameters == null && header.typeParameters != null && header.parameters[i].type.hasInferenceBlockingTypeParameters(header.typeParameters))
 				return false;
 			
 			if (!arguments.get(i).isCompatibleWith(scope, header.parameters[i].type))