Only remove CPython's slot wrappers, never failing the type creation

The cleanup now deletes a member only when it is a wrapper_descriptor, the
object PyType_Ready adds, instead of anything that is not a managed
object. It is best effort: a failed delete clears its error and any
exception is swallowed, since a wrapper left behind only keeps the
previous behavior.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: Martin-Molinero

src/embed_tests/TestOperator.cs

@@ -650,5 +650,25 @@ class Plain(TestOperator.ForwardOnlyOperable):
             Assert.AreEqual("custom", scope.Get<string>("custom"));
             Assert.AreEqual("TypeError", scope.Get<string>("plain"));
         }
+
+        public class ForwardOnlyOperableWithReflectedMethod
+        {
+            public static ForwardOnlyOperableWithReflectedMethod operator +(ForwardOnlyOperableWithReflectedMethod a, ForwardOnlyOperableWithReflectedMethod b) => a;
+
+            // a CLR member named like the reflected method, not a slot wrapper
+            public string __radd__(double other) => "clr";
+        }
+
+        [Test]
+        public void ClrMemberNamedLikeTheReflectedMethodIsKept()
+        {
+            using var _ = Py.GIL();
+            using var scope = Py.CreateScope();
+            scope.Exec(@"
+from Python.EmbeddingTest import TestOperator
+result = 1.0 + TestOperator.ForwardOnlyOperableWithReflectedMethod()
+");
+            Assert.AreEqual("clr", scope.Get<string>("result"));
+        }
     }
 }

src/runtime/Types/OperatorMethod.cs

@@ -136,25 +136,35 @@ public static void FixupSlots(BorrowedReference pyType, Type clrType)
         /// </summary>
         public static void RemoveUnboundSlotWrappers(BorrowedReference pyType, Type clrType)
         {
-            var dict = Util.ReadRef(pyType, TypeOffset.tp_dict);
-            var fixedSlots = GetOperatorCandidates(clrType)
-                .Where(method => OpMethodMap.ContainsKey(method.Name))
-                .Select(method => OpMethodMap[method.Name].MethodName)
-                .Distinct();
-            foreach (var pyName in fixedSlots)
+            // best effort: a wrapper left behind only keeps the previous behavior, so nothing here fails the type creation
+            try
             {
-                RemoveSlotWrapper(dict, pyName);
-                RemoveSlotWrapper(dict, ReversePyMethodName(pyName));
+                var dict = Util.ReadRef(pyType, TypeOffset.tp_dict);
+                var fixedSlots = GetOperatorCandidates(clrType)
+                    .Where(method => OpMethodMap.ContainsKey(method.Name))
+                    .Select(method => OpMethodMap[method.Name].MethodName)
+                    .Distinct();
+                foreach (var pyName in fixedSlots)
+                {
+                    RemoveSlotWrapper(dict, pyName);
+                    RemoveSlotWrapper(dict, ReversePyMethodName(pyName));
+                }
+            }
+            catch
+            {
+                // pass
             }
         }
 
         private static void RemoveSlotWrapper(BorrowedReference dict, string name)
         {
             var member = Runtime.PyDict_GetItemString(dict, name);
-            // the CLR operators are managed method objects, anything else was added by PyType_Ready
-            if (!member.IsNull && ManagedType.GetManagedObject(member) == null && Runtime.PyDict_DelItemString(dict, name) != 0)
+            // only the slot wrappers PyType_Ready added, the CLR operators are managed method objects
+            if (!member.IsNull && Runtime.PyObject_TYPE(member) == Runtime.PyWrapperDescriptorType
+                && Runtime.PyDict_DelItemString(dict, name) != 0)
             {
-                throw PythonException.ThrowLastAsClrException();
+                // don't let a failed delete leak, the wrapper just stays
+                Exceptions.Clear();
             }
         }