Fix expansion method signature and call

Signature: Include the type in the signature if it is an expansion method
Call: Call invokeStatic if its an expansion method

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

 			getJavaWriter().invokeStatic(methodInfo);
 		} else if (methodInfo.kind == JavaMethod.Kind.INTERFACE) {
 			getJavaWriter().invokeInterface(methodInfo);
+		} else if (methodInfo.kind == JavaMethod.Kind.EXPANSION) {
+			getJavaWriter().invokeStatic(methodInfo);
 		} else if (methodInfo.kind == JavaMethod.Kind.COMPILED) {
 			Objects.requireNonNull(methodInfo.translation).translate(expression, this);
-		} else if (methodInfo.cls.kind == JavaClass.Kind.INTERFACE) {
+		} else if (methodInfo.cls != null && methodInfo.cls.kind == JavaClass.Kind.INTERFACE) {
 			getJavaWriter().invokeInterface(methodInfo);
 		} else {
 			getJavaWriter().invokeVirtual(methodInfo);

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

 	}
 	
 	public String getMethodDescriptor(FunctionHeader header) {
-		return getMethodDescriptor(header, false);
+		return getMethodDescriptor(header, false, "");
+	}
+
+	public String getMethodDescriptorExpansion(FunctionHeader header, StoredType expandedType) {
+		return getMethodDescriptor(header, false, getDescriptor(expandedType));
 	}
 	
     public String getMethodSignature(FunctionHeader header) {
     }
 	
 	public String getEnumConstructorDescriptor(FunctionHeader header) {
-		return getMethodDescriptor(header, true);
+		return getMethodDescriptor(header, true, "");
 	}
 	
 	public JavaSynthesizedFunctionInstance getFunction(FunctionTypeID type) {
 			return new JavaSynthesizedClass(range.cls, new TypeID[] { type.baseType.type });
 		}
 	}
-	
-	private String getMethodDescriptor(FunctionHeader header, boolean isEnumConstructor) {
+
+	/**
+	 * @param header Function Header
+	 * @param isEnumConstructor If this is an enum constructor, add String, int as parameters
+	 * @param expandedType If this is for an expanded type, add the type at the beginning.
+	 *                        Can be null or an empty string if this is not an expansion method header
+	 * @return Method descriptor {@code (<LClass;*No.TypeParameters><LString;I if enum><expandedType><headerTypes>)<retType> }
+	 */
+	private String getMethodDescriptor(FunctionHeader header, boolean isEnumConstructor, String expandedType) {
         StringBuilder descBuilder = new StringBuilder("(");
 		for (int i = 0; i < header.getNumberOfTypeParameters(); i++)
 			descBuilder.append("Ljava/lang/Class;");
 		
         if (isEnumConstructor)
             descBuilder.append("Ljava/lang/String;I");
+
+        //TODO: Put this earlier? We'd need to agree on one...
+        if(expandedType != null)
+        	descBuilder.append(expandedType);
 		
         for (FunctionParameter parameter : header.parameters) {
 			descBuilder.append(getDescriptor(parameter.type));

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareExpansionMethodVisitor.java

  */
 package org.openzen.zenscript.javashared.prepare;
 
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.javashared.JavaNativeClass;
 import org.openzen.zencode.shared.StringExpansion;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 		JavaMethod method = null;
 		if (nativeTag != null && nativeClass != null)
 			method = nativeClass.getMethod(nativeTag.value);
-		if (method == null)
+		if (method == null) {
+			final JavaMethod.Kind kind = getKind(member);
+			final String descriptor;
+			if (kind == JavaMethod.Kind.EXPANSION && member.definition instanceof ExpansionDefinition) {
+				descriptor = context.getMethodDescriptorExpansion(header, ((ExpansionDefinition) member.definition).target);
+			} else {
+				descriptor = context.getMethodDescriptor(header);
+			}
 			method = new JavaMethod(
 					cls,
-					getKind(member),
+					kind,
 					name,
 					true,
-					context.getMethodDescriptor(header),
+					descriptor,
 					JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
 					header.getReturnType().type instanceof GenericTypeID,
-					header.useTypeParameters()); 
+					header.useTypeParameters());
+		}
 		
 		if (method.compile) {
 			if (DEBUG_EMPTY && cls.empty)