WIP: Rudimentary work on VarAargs

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

 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 	
 	public FunctionParameter getParameter(boolean isVariadic, int index) {
 		if (isVariadic && index >= parameters.length - 1) {
-			return parameters[parameters.length - 1];
+			final FunctionParameter parameter = parameters[parameters.length - 1];
+			if(parameter.type.type instanceof ArrayTypeID) {
+				return new FunctionParameter(((ArrayTypeID) parameter.type.type).elementType, parameter.name);
+			}
+			return parameter;
 		} else {
 			return parameters[index];
 		}

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

 
 				}
 			}
-			for (Expression argument : expression.arguments.arguments) {
-				argument.accept(this);
+
+			final Expression[] arguments = expression.arguments.arguments;
+			final FunctionParameter[] parameters = expression.instancedHeader.parameters;
+
+			final boolean variadic = expression.instancedHeader.isVariadicCall(expression.arguments) && ((arguments.length != parameters.length) || !parameters[parameters.length - 1].type.type
+					.equals(arguments[arguments.length - 1].type.type));
+
+			if(variadic) {
+				for (int i = 0; i < parameters.length - 1; i++) {
+					arguments[i].accept(this);
+				}
+
+				final int arrayCount = (arguments.length - parameters.length) + 1;
+				javaWriter.constant(arrayCount);
+				javaWriter.newArray(context.getType(parameters[parameters.length - 1].type).getElementType());
+				for (int i = 0; i < arrayCount; i++) {
+					javaWriter.dup();
+					javaWriter.constant(i);
+					arguments[i + parameters.length - 1].accept(this);
+					javaWriter.arrayStore(context.getType(arguments[i].type));
+				}
+
+
+			} else {
+ 				for (Expression argument : arguments) {
+					argument.accept(this);
+				}
 			}
 
+
+
 			if (!checkAndExecuteMethodInfo(expression.member, expression.type, expression))
 				throw new IllegalStateException("Call target has no method info!");
 

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

 		List<StoredType>[] predictedTypes = new List[arguments.size()];
 		for (int i = 0; i < predictedTypes.length; i++)
 			predictedTypes[i] = new ArrayList<>();
-		
+
 		for (FunctionHeader header : candidates) {
+			//TODO: this is wrong!
+			boolean variadic = header.isVariadic();
 			for (int i = 0; i < arguments.size(); i++) {
-				if (!predictedTypes[i].contains(header.parameters[i].type))
-					predictedTypes[i].add(header.parameters[i].type);
+				final StoredType parameterType = header.getParameterType(variadic, i);
+				if (!predictedTypes[i].contains(parameterType))
+					predictedTypes[i].add(parameterType);
 			}
 		}
 		
 	private boolean isCompatibleWith(BaseScope scope, FunctionHeader header, StoredType[] typeArguments) {
 		if (!header.accepts(arguments.size()))
 			return false;
-		
-		boolean variadic = false;
+
+		//TODO: This is wrong
+		boolean variadic = header.isVariadic();
 		for (int i = 0; i < arguments.size(); i++) {
 			FunctionParameter parameter = header.getParameter(variadic, i);
 			if (typeArguments == null && header.typeParameters != null && parameter.type.hasInferenceBlockingTypeParameters(header.typeParameters))