Treat properties with private setters as read-only from Python

Python assignment to a CLR property resolved the setter with nonPublic: true,
so a property declared { get; private set; } was silently writable from
Python: the read-only guard in tp_descr_set never fired and reflection
invoked the private setter, mutating state the class never exposed.

Align property setter binding with the accessibility policy in
ClassManager.ShouldBindMethod (public, protected, protected internal):
CacheAccessors now discards a resolved setter that fails that check, so
assignment raises TypeError 'property is read-only'. Protected setters
remain writable from Python subclasses.

Author: jhonabreul

src/embed_tests/TestPropertyAccess.cs

@@ -34,12 +34,16 @@ public class Fixture
             public string PublicReadOnlyProperty { get; } = "Default value";
             protected string ProtectedReadOnlyProperty { get; } = "Default value";
 
+            public string PublicPropertyWithPrivateSetter { get; private set; } = "Default value";
+
             public static string PublicStaticProperty { get; set; } = "Default value";
             protected static string ProtectedStaticProperty { get; set; } = "Default value";
 
             public static string PublicStaticReadOnlyProperty { get; } = "Default value";
             protected static string ProtectedStaticReadOnlyProperty { get; } = "Default value";
 
+            public static string PublicStaticPropertyWithPrivateSetter { get; private set; } = "Default value";
+
             public string PublicField = "Default value";
             protected string ProtectedField = "Default value";
 
@@ -58,6 +62,11 @@ public static Fixture Create()
             {
                 return new Fixture();
             }
+
+            public static void ResetPublicStaticPropertyWithPrivateSetter()
+            {
+                PublicStaticPropertyWithPrivateSetter = "Default value";
+            }
         }
 
         public class NonStaticConstHolder
@@ -321,6 +330,32 @@ def SetValue(self, fixture):
             }
         }
 
+        [Test]
+        public void TestSetPublicPropertyWithPrivateSetterFails()
+        {
+            dynamic model = PyModule.FromString("module", @"
+from clr import AddReference
+AddReference(""System"")
+AddReference(""Python.EmbeddingTest"")
+
+from Python.EmbeddingTest import *
+
+class TestSetPublicPropertyWithPrivateSetterFails:
+    def SetValue(self, fixture):
+        fixture.PublicPropertyWithPrivateSetter = 'New value'
+").GetAttr("TestSetPublicPropertyWithPrivateSetterFails").Invoke();
+
+            var fixture = new Fixture();
+
+            using (Py.GIL())
+            {
+                var exception = Assert.Throws<PythonException>(() => model.SetValue(fixture));
+                Assert.AreEqual("TypeError", exception.Type.Name);
+                Assert.That(exception.Message, Does.Contain("read-only"));
+                Assert.AreEqual("Default value", fixture.PublicPropertyWithPrivateSetter);
+            }
+        }
+
         [Test]
         public void TestGetPublicReadOnlyPropertyFailsWhenAccessedOnClass()
         {
@@ -515,6 +550,41 @@ def SetValue(self):
             }
         }
 
+        [Test]
+        public void TestSetPublicStaticPropertyWithPrivateSetterFails()
+        {
+            dynamic model = PyModule.FromString("module", @"
+from clr import AddReference
+AddReference(""System"")
+AddReference(""Python.EmbeddingTest"")
+
+from Python.EmbeddingTest import *
+
+class TestSetPublicStaticPropertyWithPrivateSetterFails:
+    def SetValue(self):
+        TestPropertyAccess.Fixture.PublicStaticPropertyWithPrivateSetter = 'New value'
+").GetAttr("TestSetPublicStaticPropertyWithPrivateSetterFails").Invoke();
+
+            using (Py.GIL())
+            {
+                string valueAfterSet;
+                PythonException exception = null;
+                try
+                {
+                    exception = Assert.Throws<PythonException>(() => model.SetValue());
+                }
+                finally
+                {
+                    valueAfterSet = Fixture.PublicStaticPropertyWithPrivateSetter;
+                    Fixture.ResetPublicStaticPropertyWithPrivateSetter();
+                }
+
+                Assert.AreEqual("TypeError", exception.Type.Name);
+                Assert.That(exception.Message, Does.Contain("read-only"));
+                Assert.AreEqual("Default value", valueAfterSet);
+            }
+        }
+
         [Test]
         public void TestGetProtectedStaticReadOnlyPropertyWorks()
         {

src/runtime/Types/PropertyObject.cs

@@ -40,6 +40,13 @@ void CacheAccessors()
             PropertyInfo md = info.Value;
             getter = md.GetGetMethod(true) ?? md.GetBaseGetMethod(true);
             setter = md.GetSetMethod(true) ?? md.GetBaseSetMethod(true);
+            if (setter != null && !ClassManager.ShouldBindMethod(setter))
+            {
+                // A private/internal setter is not part of the surface exposed to Python:
+                // assignment must treat the property as read-only rather than silently
+                // writing through the non-public setter via reflection.
+                setter = null;
+            }
         }