feat: bind snake case name fields along with original method .net to python

Author: jhonabreul

src/embed_tests/ClassManagerTests.cs

@@ -1,3 +1,5 @@
+using System;
+
 using NUnit.Framework;
 
 using Python.Runtime;
@@ -29,7 +31,16 @@ public void NestedClassDerivingFromParent()
 
         public class SnakeCaseNamesTesClass
         {
-            // Purposely long method name to test snake case conversion
+            // Purposely long names to test snake case conversion
+
+            public string PublicStringField = "public_string_field";
+            public const string PublicConstStringField = "public_const_string_field";
+            public readonly string PublicReadonlyStringField = "public_readonly_string_field";
+            public static string PublicStaticStringField = "public_static_string_field";
+            public static readonly string PublicStaticReadonlyStringField = "public_static_readonly_string_field";
+
+            public static string SettablePublicStaticStringField = "settable_public_static_string_field";
+
             public int AddNumbersAndGetHalf(int a, int b)
             {
                 return (a + b) / 2;
@@ -49,11 +60,89 @@ public void BindsSnakeCaseClassMethods(string originalMethodName, string snakeCa
             using var a = 10.ToPython();
             using var b = 20.ToPython();
 
-            var camelCaseResult = obj.InvokeMethod(originalMethodName, a, b).As<int>();
-            var snakeCaseResult = obj.InvokeMethod(snakeCaseMethodName, a, b).As<int>();
+            var originalMethodResult = obj.InvokeMethod(originalMethodName, a, b).As<int>();
+            var snakeCaseMethodResult = obj.InvokeMethod(snakeCaseMethodName, a, b).As<int>();
 
-            Assert.AreEqual(15, camelCaseResult);
-            Assert.AreEqual(camelCaseResult, snakeCaseResult);
+            Assert.AreEqual(15, originalMethodResult);
+            Assert.AreEqual(originalMethodResult, snakeCaseMethodResult);
+        }
+
+        [TestCase("PublicStringField", "public_string_field")]
+        [TestCase("PublicConstStringField", "public_const_string_field")]
+        [TestCase("PublicReadonlyStringField", "public_readonly_string_field")]
+        [TestCase("PublicStaticStringField", "public_static_string_field")]
+        [TestCase("PublicStaticReadonlyStringField", "public_static_readonly_string_field")]
+        public void BindsSnakeCaseClassFields(string originalFieldName, string snakeCaseFieldName)
+        {
+            using var obj = new SnakeCaseNamesTesClass().ToPython();
+
+            var expectedValue = originalFieldName switch
+            {
+                "PublicStringField" => "public_string_field",
+                "PublicConstStringField" => "public_const_string_field",
+                "PublicReadonlyStringField" => "public_readonly_string_field",
+                "PublicStaticStringField" => "public_static_string_field",
+                "PublicStaticReadonlyStringField" => "public_static_readonly_string_field",
+                _ => throw new ArgumentException("Invalid field name")
+            };
+
+            var originalFieldValue = obj.GetAttr(originalFieldName).As<string>();
+            var snakeCaseFieldValue = obj.GetAttr(snakeCaseFieldName).As<string>();
+
+            Assert.AreEqual(expectedValue, originalFieldValue);
+            Assert.AreEqual(expectedValue, snakeCaseFieldValue);
+        }
+
+        [Test]
+        public void CanSetFieldUsingSnakeCaseName()
+        {
+            var obj = new SnakeCaseNamesTesClass();
+            using var pyObj = obj.ToPython();
+
+            // Try with the original field name
+            var newValue1 = "new value 1";
+            using var pyNewValue1 = newValue1.ToPython();
+            pyObj.SetAttr("PublicStringField", pyNewValue1);
+            Assert.AreEqual(newValue1, obj.PublicStringField);
+
+            // Try with the snake case field name
+            var newValue2 = "new value 2";
+            using var pyNewValue2 = newValue2.ToPython();
+            pyObj.SetAttr("public_string_field", pyNewValue2);
+            Assert.AreEqual(newValue2, obj.PublicStringField);
+        }
+
+        [Test]
+        public void CanSetStaticFieldUsingSnakeCaseName()
+        {
+            using (Py.GIL())
+            {
+                var module = PyModule.FromString("module", $@"
+from clr import AddReference
+AddReference(""Python.EmbeddingTest"")
+AddReference(""System"")
+
+from Python.EmbeddingTest import *
+
+def SetCamelCaseStaticProperty(value):
+    ClassManagerTests.SnakeCaseNamesTesClass.PublicStaticStringField = value
+
+def SetSnakeCaseStaticProperty(value):
+    ClassManagerTests.SnakeCaseNamesTesClass.public_static_string_field = value
+                    ");
+
+                // Try with the original field name
+                var newValue1 = "new value 1";
+                using var pyNewValue1 = newValue1.ToPython();
+                module.InvokeMethod("SetCamelCaseStaticProperty", pyNewValue1);
+                Assert.AreEqual(newValue1, SnakeCaseNamesTesClass.PublicStaticStringField);
+
+                // Try with the snake case field name
+                var newValue2 = "new value 2";
+                using var pyNewValue2 = newValue2.ToPython();
+                module.InvokeMethod("SetSnakeCaseStaticProperty", pyNewValue2);
+                Assert.AreEqual(newValue2, SnakeCaseNamesTesClass.PublicStaticStringField);
+            }
         }
 
         #endregion

src/runtime/ClassManager.cs

@@ -448,21 +448,21 @@ private static ClassInfo GetClassInfo(Type type, ClassBase impl)
                         if (name == "__init__" && !impl.HasCustomNew())
                             continue;
 
-                        List<MethodBase> methodList;
-                        var names = new List<string> { name };
-                        if (!meth.IsSpecialName && !OperatorMethod.IsOperatorMethod(meth))
+                        if (!methods.TryGetValue(name, out var methodList))
                         {
-                            names.Add(name.ToSnakeCase());
+                            methodList = methods[name] = new List<MethodBase>();
                         }
-                        foreach (var currentName in names.Distinct())
+                        methodList.Add(meth);
+
+                        if (!meth.IsSpecialName && !OperatorMethod.IsOperatorMethod(meth))
                         {
-                            if (!methods.TryGetValue(currentName, out methodList))
+                            name = name.ToSnakeCase();
+                            if (!methods.TryGetValue(name, out methodList))
                             {
-                                methodList = methods[currentName] = new List<MethodBase>();
+                                methodList = methods[name] = new List<MethodBase>();
                             }
                             methodList.Add(meth);
                         }
-
                         continue;
 
                     case MemberTypes.Constructor when !impl.HasCustomNew():
@@ -514,6 +514,7 @@ private static ClassInfo GetClassInfo(Type type, ClassBase impl)
                         }
                         ob = new FieldObject(fi);
                         ci.members[mi.Name] = ob.AllocObject();
+                        ci.members[mi.Name.ToSnakeCase()] = ob.AllocObject();
                         continue;
 
                     case MemberTypes.Event: