Replace DictionaryObject with LookUpObject

Author: jhonabreul

src/embed_tests/ClassManagerTests.cs

@@ -1005,11 +1005,13 @@ def call(instance):
 
         #endregion
 
-        private static TestCaseData[] IDictionaryContainsTestCases => new TestCaseData[]
-        {
+        private static TestCaseData[] IDictionaryContainsTestCases =>
+        [
             new(typeof(TestDictionary<string, string>)),
             new(typeof(Dictionary<string, string>)),
-        };
+            new(typeof(TestKeyValueContainer<string, string>)),
+            new(typeof(DynamicClassDictionary<string, string>)),
+        ];
 
         [TestCaseSource(nameof(IDictionaryContainsTestCases))]
         public void IDictionaryContainsMethodIsBound(Type dictType)
@@ -1028,9 +1030,9 @@ def contains(dictionary, key):
 
             using var contains = module.GetAttr("contains");
 
-            var dictionary = (Activator.CreateInstance(dictType) as IDictionary)!;
+            var dictionary = Convert.ChangeType(Activator.CreateInstance(dictType), dictType);
             var key1 = "key1";
-            dictionary.Add(key1, "value1");
+            (dictionary as dynamic).Add(key1, "value1");
 
             using var pyDictionary = dictionary.ToPython();
             using var pyKey1 = key1.ToPython();
@@ -1060,8 +1062,8 @@ def contains(dictionary, key):
 
             using var contains = module.GetAttr("contains");
 
-            var dictionary = (Activator.CreateInstance(dictType) as IDictionary)!;
-            dictionary.Add("key1", "value1");
+            var dictionary = Convert.ChangeType(Activator.CreateInstance(dictType), dictType);
+            (dictionary as dynamic).Add("key1", "value1");
 
             using var pyDictionary = dictionary.ToPython();
 
@@ -1070,9 +1072,9 @@ def contains(dictionary, key):
             Assert.IsFalse(result);
         }
 
-        public class TestDictionary<TValue, TKey> : IDictionary
+        public class TestDictionary<TKey, TValue> : IDictionary
         {
-            private readonly Dictionary<TValue, TKey> _data = new();
+            private readonly Dictionary<TKey, TValue> _data = new();
 
             public object this[object key] { get => ((IDictionary)_data)[key]; set => ((IDictionary)_data)[key] = value; }
 
@@ -1130,6 +1132,36 @@ public bool ContainsKey(TKey key)
                 return Contains(key);
             }
         }
+
+        public class TestKeyValueContainer<TKey, TValue>
+            where TKey: class
+            where TValue: class
+        {
+            private readonly Dictionary<TKey, TValue> _data = new();
+            public int Count => _data.Count;
+            public bool ContainsKey(TKey key)
+            {
+                return _data.ContainsKey(key);
+            }
+            public void Add(TKey key, TValue value)
+            {
+                _data.Add(key, value);
+            }
+        }
+
+        public class DynamicClassDictionary<TKey, TValue> : TestPropertyAccess.DynamicFixture
+        {
+            private readonly Dictionary<TKey, TValue> _data = new();
+            public int Count => _data.Count;
+            public bool ContainsKey(TKey key)
+            {
+                return _data.ContainsKey(key);
+            }
+            public void Add(TKey key, TValue value)
+            {
+                _data.Add(key, value);
+            }
+        }
     }
 
     public class NestedTestParent

src/runtime/ClassManager.cs

@@ -180,11 +180,6 @@ internal static ClassBase CreateClass(Type type)
                 impl = new ArrayObject(type);
             }
 
-            else if (type.IsDictionary())
-            {
-                impl = new DictionaryObject(type);
-            }
-
             else if (type.IsKeyValuePairEnumerable())
             {
                 impl = new KeyValuePairEnumerableObject(type);
@@ -210,7 +205,19 @@ internal static ClassBase CreateClass(Type type)
 
             else if (typeof(IDynamicMetaObjectProvider).IsAssignableFrom(type))
             {
-                impl = new DynamicClassObject(type);
+                if (type.IsLookUp())
+                {
+                    impl = new DynamicClassLookUpObject(type);
+                }
+                else
+                {
+                    impl = new DynamicClassObject(type);
+                }
+            }
+
+            else if (type.IsLookUp())
+            {
+                impl = new LookUpObject(type);
             }
 
             else

src/runtime/Types/DictionaryObject.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace Python.Runtime
+{
+    /// <summary>
+    /// Implements a Python type for managed DynamicClass objects that support look up (dictionaries),
+    /// that is, they implement ContainsKey().
+    /// This type is essentially the same as a ClassObject, except that it provides
+    /// sequence semantics to support natural dictionary usage (__contains__ and __len__)
+    /// from Python.
+    /// </summary>
+    internal class DynamicClassLookUpObject : DynamicClassObject
+    {
+        internal DynamicClassLookUpObject(Type tp) : base(tp)
+        {
+        }
+
+        /// <summary>
+        /// Implements __len__ for dictionary types.
+        /// </summary>
+        public static int mp_length(BorrowedReference ob)
+        {
+            return LookUpObject.mp_length(ob);
+        }
+
+        /// <summary>
+        /// Implements __contains__ for dictionary types.
+        /// </summary>
+        public static int sq_contains(BorrowedReference ob, BorrowedReference v)
+        {
+            return LookUpObject.sq_contains(ob, v);
+        }
+    }
+}

src/runtime/Types/DynamicClassLookUpObject.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Reflection;
 
 namespace Python.Runtime
 {
@@ -10,82 +9,14 @@ namespace Python.Runtime
     /// sequence semantics to support natural dictionary usage (__contains__ and __len__)
     /// from Python.
     /// </summary>
-    internal class KeyValuePairEnumerableObject : ClassObject
+    internal class KeyValuePairEnumerableObject : LookUpObject
     {
-        [NonSerialized]
-        private static Dictionary<Tuple<Type, string>, MethodInfo> methodsByType = new Dictionary<Tuple<Type, string>, MethodInfo>();
-        private static List<string> requiredMethods = new List<string> { "Count", "ContainsKey" };
-
-        internal static bool VerifyMethodRequirements(Type type)
-        {
-            foreach (var requiredMethod in requiredMethods)
-            {
-                var method = type.GetMethod(requiredMethod);
-                if (method == null)
-                {
-                    method = type.GetMethod($"get_{requiredMethod}");
-                    if (method == null)
-                    {
-                        return false;
-                    }
-                }
-
-                var key = Tuple.Create(type, requiredMethod);
-                methodsByType.Add(key, method);
-            }
-
-            return true;
-        }
-
         internal KeyValuePairEnumerableObject(Type tp) : base(tp)
         {
 
         }
 
         internal override bool CanSubclass() => false;
-
-        /// <summary>
-        /// Implements __len__ for dictionary types.
-        /// </summary>
-        public static int mp_length(BorrowedReference ob)
-        {
-            var obj = (CLRObject)GetManagedObject(ob);
-            var self = obj.inst;
-
-            var key = Tuple.Create(self.GetType(), "Count");
-            var methodInfo = methodsByType[key];
-
-            return (int)methodInfo.Invoke(self, null);
-        }
-
-        /// <summary>
-        /// Implements __contains__ for dictionary types.
-        /// </summary>
-        public static int sq_contains(BorrowedReference ob, BorrowedReference v)
-        {
-            var obj = (CLRObject)GetManagedObject(ob);
-            var self = obj.inst;
-
-            var key = Tuple.Create(self.GetType(), "ContainsKey");
-            var methodInfo = methodsByType[key];
-
-            var parameters = methodInfo.GetParameters();
-            object arg;
-            if (!Converter.ToManaged(v, parameters[0].ParameterType, out arg, false))
-            {
-                Exceptions.SetError(Exceptions.TypeError,
-                    $"invalid parameter type for sq_contains: should be {Converter.GetTypeByAlias(v)}, found {parameters[0].ParameterType}");
-            }
-
-            // If the argument is None, we return false. Python allows using None as key,
-            // but C# doesn't and will throw, so we shortcut here
-            if (arg == null)
-            {
-                return 0;
-            }
-
-            return (bool)methodInfo.Invoke(self, new[] { arg }) ? 1 : 0;
-        }
     }
 
     public static class KeyValuePairEnumerableObjectExtension
@@ -109,7 +40,7 @@ public static bool IsKeyValuePairEnumerable(this Type type)
                         a.GetGenericTypeDefinition() == keyValuePairType &&
                         a.GetGenericArguments().Length == 2)
                     {
-                        return KeyValuePairEnumerableObject.VerifyMethodRequirements(type);
+                        return LookUpObject.VerifyMethodRequirements(type);
                     }
                 }
             }