Pep8 named arguments generic methods (#86)

- Fix for pep8 named argument support for generic methods. Adding tests
  reproducing issue

Author: Martin-Molinero

src/embed_tests/ClassManagerTests.cs

@@ -159,6 +159,50 @@ public string JoinToString(string thisIsAStringParameter,
             };
 
             private static void Throw() => throw new Exception("Pepe");
+
+            public static string GenericMethodBindingStatic<T>(int arg1, SnakeCaseEnum enumValue)
+            {
+                return "GenericMethodBindingStatic";
+            }
+
+            public string GenericMethodBinding<T>(int arg1, SnakeCaseEnum enumValue = SnakeCaseEnum.EnumValue3)
+            {
+                return "GenericMethodBinding" + arg1;
+            }
+        }
+
+        [TestCase("generic_method_binding_static", "GenericMethodBindingStatic")]
+        [TestCase("generic_method_binding", "GenericMethodBinding1")]
+        [TestCase("generic_method_binding2", "GenericMethodBinding2")]
+        [TestCase("generic_method_binding3", "GenericMethodBinding3")]
+        public void GenericMethodBinding(string targetMethod, string expectedReturn)
+        {
+            using (Py.GIL())
+            {
+                var module = PyModule.FromString("module", $@"
+from clr import AddReference
+AddReference(""Python.EmbeddingTest"")
+
+from Python.EmbeddingTest import *
+
+def generic_method_binding_static(value):
+    return ClassManagerTests.SnakeCaseNamesTesClass.generic_method_binding_static[bool](1, enum_value=ClassManagerTests.SnakeCaseEnum.EnumValue1)
+
+def generic_method_binding(value):
+    return value.generic_method_binding[bool](1, enum_value=ClassManagerTests.SnakeCaseEnum.EnumValue1)
+
+def generic_method_binding2(value):
+    return value.generic_method_binding[bool](2, ClassManagerTests.SnakeCaseEnum.EnumValue1)
+
+def generic_method_binding3(value):
+    return value.generic_method_binding[bool](3)
+                    ");
+
+                using var obj = new SnakeCaseNamesTesClass().ToPython();
+                var result = module.InvokeMethod(targetMethod, new[] { obj }).As<string>();
+
+                Assert.AreEqual(expectedReturn, result);
+            }
         }
 
         [TestCase("StaticReadonlyActionProperty", "static_readonly_action_property", new object[] { })]
@@ -618,13 +662,13 @@ def SetEnumValue3(obj):
     obj.EnumValue = ClassManagerTests.SnakeCaseEnum.EnumValue3
 
 def SetEnumValue1SnakeCase(obj):
-    obj.enum_value = ClassManagerTests.SnakeCaseEnum.ENUM_VALUE1
+    obj.enum_value = ClassManagerTests.SnakeCaseEnum.ENUM_VALUE_1
 
 def SetEnumValue2SnakeCase(obj):
-    obj.enum_value = ClassManagerTests.SnakeCaseEnum.ENUM_VALUE2
+    obj.enum_value = ClassManagerTests.SnakeCaseEnum.ENUM_VALUE_2
 
 def SetEnumValue3SnakeCase(obj):
-    obj.enum_value = ClassManagerTests.SnakeCaseEnum.ENUM_VALUE3
+    obj.enum_value = ClassManagerTests.SnakeCaseEnum.ENUM_VALUE_3
                     ");
 
                 using var obj = new SnakeCaseNamesTesClass().ToPython();

src/runtime/MethodBinder.cs

@@ -23,6 +23,7 @@ internal class MethodBinder
         public const bool DefaultAllowThreads = true;
         public bool allow_threads = DefaultAllowThreads;
         public bool init = false;
+        public bool isOriginal;
 
         internal MethodBinder()
         {
@@ -40,15 +41,10 @@ public int Count
         }
 
         internal void AddMethod(MethodBase m)
-        {
-            AddMethod(m, true);
-        }
-
-        internal void AddMethod(MethodBase m, bool isOriginal)
         {
             // we added a new method so we have to re sort the method list
             init = false;
-            list.Add(new MethodInformation(m, m.GetParameters(), isOriginal));
+            list.Add(new MethodInformation(m, m.GetParameters()));
         }
 
         /// <summary>
@@ -454,7 +450,7 @@ internal Binding Bind(BorrowedReference inst, BorrowedReference args, BorrowedRe
                 var mi = methodInformation.MethodBase;
                 var pi = methodInformation.ParameterInfo;
                 // Avoid accessing the parameter names property unless necessary
-                var paramNames = hasNamedArgs ? methodInformation.ParameterNames : Array.Empty<string>();
+                var paramNames = hasNamedArgs ? methodInformation.ParameterNames(isOriginal) : Array.Empty<string>();
                 int pyArgCount = (int)Runtime.PyTuple_Size(args);
 
                 // Special case for operators
@@ -987,30 +983,32 @@ internal virtual NewReference Invoke(BorrowedReference inst, BorrowedReference a
         [Serializable]
         internal class MethodInformation
         {
-            private Lazy<string[]> _parametersNames;
+            private string[] _parametersNames = null;
 
             public MethodBase MethodBase { get; }
 
             public ParameterInfo[] ParameterInfo { get; }
 
-            public bool IsOriginal { get; }
-
-            public string[] ParameterNames { get { return _parametersNames.Value; } }
-
-            public MethodInformation(MethodBase methodBase, ParameterInfo[] parameterInfo)
-                : this(methodBase, parameterInfo, true)
+            public string[] ParameterNames(bool isOriginal)
             {
+                if (_parametersNames == null)
+                {
+                    if (isOriginal)
+                    {
+                        _parametersNames = ParameterInfo.Select(pi => pi.Name).ToArray();
+                    }
+                    else
+                    {
+                        _parametersNames = ParameterInfo.Select(pi => pi.Name.ToSnakeCase()).ToArray();
+                    }
+                }
+                return _parametersNames;
             }
 
-            public MethodInformation(MethodBase methodBase, ParameterInfo[] parameterInfo, bool isOriginal)
+            public MethodInformation(MethodBase methodBase, ParameterInfo[] parameterInfo)
             {
                 MethodBase = methodBase;
                 ParameterInfo = parameterInfo;
-                IsOriginal = isOriginal;
-
-                _parametersNames = new Lazy<string[]>(() => IsOriginal
-                    ? ParameterInfo.Select(pi => pi.Name).ToArray()
-                    : ParameterInfo.Select(pi => pi.Name.ToSnakeCase()).ToArray());
             }
 
             public override string ToString()

src/runtime/Types/MethodObject.cs

@@ -34,23 +34,26 @@ public MethodObject(MaybeType type, string name, MethodBase[] info, bool allow_t
             this.type = type;
             this.name = name;
             this.infoList = new List<MaybeMethodInfo>();
-            binder = new MethodBinder();
+            binder = new MethodBinder
+            {
+                isOriginal = isOriginal,
+                allow_threads = allow_threads
+            };
             foreach (MethodBase item in info)
             {
                 this.infoList.Add(item);
-                binder.AddMethod(item, isOriginal);
+                binder.AddMethod(item);
                 if (item.IsStatic)
                 {
                     this.is_static = true;
                 }
             }
-            binder.allow_threads = allow_threads;
         }
 
         public bool IsInstanceConstructor => name == "__init__";
 
         public MethodObject WithOverloads(MethodBase[] overloads)
-            => new(type, name, overloads, allow_threads: binder.allow_threads);
+            => new(type, name, overloads, allow_threads: binder.allow_threads, isOriginal: binder.isOriginal);
 
         internal MethodBase[] info
         {