Added partial parameter passing, method matching

* InjectionDefiniton now doesn't require injection methods marked with `InjectFlags.PassParametersVal` or `InjectFlags.PassParametersRef` to have **all** of the target method's parameters. The order must still be the same, though (might improve that later).
* Added method matching that allows to find methods that have **at least** the specified parameters.

Author: ghorsington

Mono.Cecil.Inject/InjectFlags.cs

@@ -68,11 +68,19 @@ public enum InjectFlags
 
         /// <summary>
         ///     Pass all parameters of the injected method. The parameters are passed by value.
+        ///     <b>Note:</b> Some methods (like constructor of <see cref="InjectionDefinition" />) implement partial parameter
+        ///     passing.
+        ///     It means that the injection method doesn't need to have all of the parameters for injected method (as long as they
+        ///     are in the same order).
         /// </summary>
         PassParametersVal = 0x20,
 
         /// <summary>
         ///     Pass all parameters of the injected method. The parameters are passed by reference (marked as "ref").
+        ///     <b>Note:</b> Some methods (like constructor of <see cref="InjectionDefinition" />) implement partial parameter
+        ///     passing.
+        ///     It means that the injection method doesn't need to have all of the parameters for injected method (as long as they
+        ///     are in the same order).
         /// </summary>
         PassParametersRef = 0x40,
 

Mono.Cecil.Inject/InjectionDefinition.cs

@@ -57,14 +57,21 @@ public InjectionDefinition(MethodDefinition injectTarget,
             int prefixCount = Convert.ToInt32(hFlags.PassTag) + Convert.ToInt32(hFlags.PassInvokingInstance)
                               + Convert.ToInt32(hFlags.ModifyReturn && !isVoid);
             int localsCount = hFlags.PassLocals ? localVarIDs.Length : 0;
-            int paramCount = (hFlags.PassParameters ? injectTarget.Parameters.Count : 0);
             int memberRefCount = (hFlags.PassFields ? memberReferences.Length : 0);
-
+            int paramCount = (hFlags.PassParameters ? injectTarget.Parameters.Count : 0);
+            int parameters = injectMethod.Parameters.Count - prefixCount - localsCount - memberRefCount;
+            // int parameters = injectMethod.Parameters.Count - prefixCount - localsCount - memberRefCount;
+            // PassParameters => 0 < parameters <= injectTarget.Patameters.Count
+            // !PassParameters => parameters = 0
             Assert(
-            injectMethod.Parameters.Count == prefixCount + localsCount + memberRefCount + paramCount,
+            (hFlags.PassParameters && 0 < parameters && parameters <= injectTarget.Parameters.Count
+             || !hFlags.PassParameters && parameters == 0),
+            //injectMethod.Parameters.Count == prefixCount + localsCount + memberRefCount + paramCount,
             $@"The injection method has a wrong number of parameters! Check that the provided target method, local variables, member references and injection flags add up to the right number of parameters.
 Needed parameters: Prefix: {
-            prefixCount}, Locals: {localsCount}, Members: {memberRefCount}, Parameters: {paramCount}, TOTAL: {
+            prefixCount}, Locals: {localsCount}, Members: {memberRefCount}, Parameters: {
+            (hFlags.PassParameters ? "between 1 and " + paramCount : "0")}, TOTAL: {
+            (hFlags.PassParameters ? $"between {prefixCount + localsCount + memberRefCount + 1} and " : "")}{
             prefixCount + localsCount + memberRefCount + paramCount}.
 Injection has {injectMethod.Parameters.Count
             } parameters.");
@@ -173,8 +180,11 @@ Injection has {injectMethod.Parameters.Count
                 injectMethod.Parameters.Skip(prefixCount + localsCount + memberRefCount)
                             .Select(p => p.ParameterType)
                             .SequenceEqual(
-                            injectTarget.Parameters.Select(
-                            p => (hFlags.PassParametersByRef ? new ByReferenceType(p.ParameterType) : p.ParameterType)),
+                            injectTarget.Parameters.Take(parameters)
+                                        .Select(
+                                        p =>
+                                        (hFlags.PassParametersByRef
+                                         ? new ByReferenceType(p.ParameterType) : p.ParameterType)),
                             comparer),
                 "Supposed to pass target method parameters by reference, but the types specified in injection and target methods do not match.");
             }
@@ -186,7 +196,7 @@ Injection has {injectMethod.Parameters.Count
             LocalVarIDs = localVarIDs;
             _PrefixCount = prefixCount;
             _MemeberRefCount = memberRefCount;
-            _ParameterCount = injectTarget.Parameters.Count;
+            _ParameterCount = parameters;
         }
 
         internal int _MemeberRefCount { get; set; }

Mono.Cecil.Inject/TypeDefinitionExtensions.cs

@@ -293,11 +293,13 @@ public static MethodDefinition GetMethod(this TypeDefinition self,
                                                  string methodName,
                                                  params TypeReference[] paramTypes)
         {
-            return
+            return GetMethod(self, methodName, paramTypes.Select(p => p.FullName).ToArray());
+            /*
             self.Methods.FirstOrDefault(
             m =>
             m.Name == methodName
             && paramTypes.SequenceEqual(m.Parameters.Select(p => p.ParameterType), new TypeComparer()));
+            */
         }
 
         /// <summary>
@@ -313,13 +315,7 @@ public static MethodDefinition GetMethod(this TypeDefinition self,
         /// </returns>
         public static MethodDefinition GetMethod(this TypeDefinition self, string methodName, params Type[] types)
         {
-            TypeReference[] trs = new TypeReference[types.Length];
-            for (int i = 0; i < types.Length; i++)
-            {
-                trs[i] = ParamHelper.FromType(types[i]);
-            }
-
-            return GetMethod(self, methodName, trs);
+            return GetMethod(self, methodName, types.Select(t => ParamHelper.FromType(t).FullName).ToArray());
         }
 
         /// <summary>
@@ -357,6 +353,58 @@ public static MethodDefinition[] GetMethods(this TypeDefinition self, string met
         {
             return self.Methods.Where(m => m.Name == methodName).ToArray();
         }
+
+        /// <summary>
+        ///     Finds the methods with the given name that have at least the provided parameters. The number of parameters need not
+        ///     match, which is why
+        ///     the methods returned may have more parameters than passed to this method.
+        /// </summary>
+        /// <param name="self">Reference to type definition that owns the method/member.</param>
+        /// <param name="methodName">Name of the method to match.</param>
+        /// <param name="types">Parameter types in the order they should be declared in the method.</param>
+        /// <returns>An array of methods that have the specified name and *at least* the given parameters.</returns>
+        public static MethodDefinition[] MatchMethod(this TypeDefinition self, string methodName, params Type[] types)
+        {
+            return MatchMethod(self, methodName, types.Select(t => ParamHelper.FromType(t).FullName).ToArray());
+        }
+
+        /// <summary>
+        ///     Finds the methods with the given name that have at least the provided parameters. The number of parameters need not
+        ///     match, which is why
+        ///     the methods returned may have more parameters than passed to this method.
+        /// </summary>
+        /// <param name="self">Reference to type definition that owns the method/member.</param>
+        /// <param name="methodName">Name of the method to match.</param>
+        /// <param name="paramTypes">Parameter types in the order they should be declared in the method.</param>
+        /// <returns>An array of methods that have the specified name and *at least* the given parameters.</returns>
+        public static MethodDefinition[] MatchMethod(this TypeDefinition self,
+                                                     string methodName,
+                                                     params TypeReference[] paramTypes)
+        {
+            return MatchMethod(self, methodName, paramTypes.Select(p => p.FullName).ToArray());
+        }
+
+        /// <summary>
+        ///     Finds the methods with the given name that have at least the provided parameters. The number of parameters need not
+        ///     match, which is why
+        ///     the methods returned may have more parameters than passed to this method.
+        /// </summary>
+        /// <param name="self">Reference to type definition that owns the method/member.</param>
+        /// <param name="methodName">Name of the method to match.</param>
+        /// <param name="paramTypes">Parameter types in the order they should be declared in the method.</param>
+        /// <returns>An array of methods that have the specified name and *at least* the given parameters.</returns>
+        public static MethodDefinition[] MatchMethod(this TypeDefinition self,
+                                                     string methodName,
+                                                     params string[] paramTypes)
+        {
+            return
+            self.Methods.Where(
+            m =>
+            m.Name == methodName && paramTypes.Length <= m.Parameters.Count
+            && paramTypes.SequenceEqual(
+            m.Parameters.Take(paramTypes.Length).Select(p => p.ParameterType.FullName),
+            StringComparer.InvariantCulture)).ToArray();
+        }
     }
 
     internal class TypeComparer : IEqualityComparer<TypeReference>

Tests/TypeDefinitionTests.cs

@@ -17,6 +17,12 @@ public static bool HookTest1(int tag, TypeDefinitionTests test, out byte ret, re
             return true;
         }
 
+        public static bool HookTest2(int tag, TypeDefinitionTests test, out int ret, int val1, byte val2, List<int> val3)
+        {
+            ret = 1;
+            return false;
+        }
+
         public static void Main(string[] args)
         {
             AssemblyDefinition ad = AssemblyLoader.LoadAssembly("Tests.exe");
@@ -57,7 +63,7 @@ public static void Main(string[] args)
             testType.GetField("testMember"));
 
             InjectionDefinition hd3 = testType.GetInjectionMethod("", null, InjectFlags.None, null, null);
-
+            /*
             testType.GetMethod("Test2")
                     .InjectWith(
                     testType.GetMethod("HookTest1"),
@@ -67,6 +73,12 @@ public static void Main(string[] args)
                     InjectDirection.Before,
                     new[] {0},
                     new[] {testType.GetField("testMember")});
+            */
+            InjectionDefinition hd4 = new InjectionDefinition(testType.GetMethod(nameof(TestPartialParams)), testType.GetMethod(nameof(HookTest2)), (new InjectValues { PassTag = true, PassInvokingInstance = true, ModifyReturn = true, ParameterType = InjectValues.PassParametersType.ByValue}).GetCombinedFlags());
+
+            hd4.Inject();
+
+            MethodDefinition[] matches = testType.MatchMethod("TestMatch", typeof(int), typeof(string));
 
             Console.WriteLine($"Another hookdef: {hd2}");
 
@@ -90,8 +102,28 @@ public byte Test2(int val)
             return 0;
         }
 
+        private int TestPartialParams(int val1, byte val2, List<int> val3)
+        {
+            return -1;
+        }
+
         public static void Test3(params object[] asd) {}
 
+        protected void TestMatch(int val1, bool val2)
+        {
+            Console.WriteLine("I am Groot!");
+        }
+
+        protected void TestMatch(int val1, bool val2, byte val3)
+        {
+            Console.WriteLine("I am Groot!");
+        }
+
+        protected void TestMatch(int val1, string val2)
+        {
+            Console.WriteLine("I am Groot!");
+        }
+
         private class Nested1
         {
             private class Nested2