Fixed execution of methods with interface args using reflection.

GetType() returns the concrete type of an object which caused
InvokeMethod() and InvokeStaticMethod() to not match methods that
take arguments that require interface arguments.

This changes the type check of arguments, to handle overloaded
methods, to check whether an argument is assignable given an argument
which checks for compatibility with the expected interface.

Bug: 138224253
Change-Id: I575a03b10bd3b8576fb1c4503c57ddf9052587ca

Author: Stewart Miles

source/VersionHandler/src/VersionHandler.cs

@@ -516,7 +516,10 @@ public static object InvokeMethod(
                 if (position < numberOfPositionalArgs) {
                     var positionalArg = args[position];
                     // If the parameter type doesn't match, ignore this method.
-                    if (positionalArg != null && parameterType != positionalArg.GetType()) break;
+                    if (positionalArg != null &&
+                        !parameterType.IsAssignableFrom(positionalArg.GetType())) {
+                        break;
+                    }
                     parameterValues[position] = positionalArg;
                     matchedPositionalArgs ++;
                 } else if (parameter.RawDefaultValue != DBNull.Value) {
@@ -525,7 +528,10 @@ public static object InvokeMethod(
                         object namedArg;
                         if (namedArgs.TryGetValue(parameter.Name, out namedArg)) {
                             // If the parameter type doesn't match, ignore this method.
-                            if (namedArg != null && parameterType != namedArg.GetType()) break;
+                            if (namedArg != null &&
+                                !parameterType.IsAssignableFrom(namedArg.GetType())) {
+                                break;
+                            }
                             namedValue = namedArg;
                             matchedNamedArgs ++;
                         }

source/VersionHandler/test/reflection/Assets/PlayServicesResolver/Editor/TestReflection.cs

@@ -50,6 +50,16 @@ public static string GenericHelloWithCustomerNameAndPronoun(string customerName,
         return String.Format("{0} {1}", GenericHelloWithPronoun(pronoun: pronoun), customerName);
     }
 
+    public static string GenericHelloWithCustomerNameAndSuffixes(
+            string customerName, IEnumerable<string> suffixes = null) {
+        string fullName = Greeter.GenericHelloWithCustomerName(customerName);
+        if (suffixes != null) {
+            foreach (var suffix in suffixes) fullName += " " + suffix;
+        }
+        return fullName;
+    }
+
+
     private string MyNameIs() {
         return String.Format(", my name is {0}", name);
     }
@@ -91,9 +101,10 @@ static TestReflection() {
                     TestInvokeStaticMethodWithNamedArg,
                     TestInvokeStaticMethodWithArgAndNamedArgDefault,
                     TestInvokeStaticMethodWithArgAndNamedArg,
+                    TestInvokeStaticMethodWithArgAndNamedInterfaceArg,
                     TestInvokeInstanceMethodWithNoArgs,
                     TestInvokeInstanceMethodWithNamedArgDefault,
-                    TestInvokeInstanceMethodWithNamedArg
+                    TestInvokeInstanceMethodWithNamedArg,
                  }) {
             var testName = test.Method.Name;
             Exception exception = null;
@@ -213,6 +224,16 @@ static bool TestInvokeStaticMethodWithArgAndNamedArg() {
                               new Dictionary<string, object> { { "pronoun", "Mrs" } } ));
     }
 
+    // Invoke a static method with a positional and named interface arg.
+    static bool TestInvokeStaticMethodWithArgAndNamedInterfaceArg() {
+        IEnumerable<string> suffixes = new string[] { "BSc", "Hons", "PhD", "Kt", "MPerf" };
+        return CheckValue("Hello Angie BSc Hons PhD Kt MPerf",
+                          (string)VersionHandler.InvokeStaticMethod(
+                              typeof(Greeter), "GenericHelloWithCustomerNameAndSuffixes",
+                              new object[] { "Angie" },
+                              new Dictionary<string, object> { { "suffixes", suffixes } }));
+    }
+
     // Invoke an instance method with no args.
     static bool TestInvokeInstanceMethodWithNoArgs() {
         return CheckValue("Hello, my name is Sam",