Changes DictionaryObject to KeyValuePairEnumerableObject

It is more generical.
Verifies the existence of `Count` and `ContainsKey` that are necessary for `__len__` and `__contains__`.

Author: AlexCatarino

src/runtime/Python.Runtime.csproj

@@ -76,7 +76,7 @@
     <Reference Include="System" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="dictionaryobject.cs" />
+    <Compile Include="keyvaluepairenumerableobject.cs" />
     <Compile Include="finalizer.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="..\SharedAssemblyInfo.cs">

src/runtime/classmanager.cs

@@ -87,9 +87,9 @@ private static ClassBase CreateClass(Type type)
                 impl = new ArrayObject(type);
             }
 
-            else if (type.IsDictionary())
+            else if (type.IsKeyValuePairEnumerable())
             {
-                impl = new DictionaryObject(type);
+                impl = new KeyValuePairEnumerableObject(type);
             }
 
             else if (type.IsInterface)

src/runtime/dictionaryobject.cs renamed to src/runtime/keyvaluepairenumerableobject.cs

@@ -5,11 +5,12 @@
 namespace Python.Runtime
 {
     /// <summary>
-    /// Implements a Python type for managed dictionaries. 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.
+    /// Implements a Python type for managed KeyValuePairEnumerable (dictionaries).
+    /// 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 DictionaryObject : ClassObject
+    internal class KeyValuePairEnumerableObject : ClassObject
     {
         private static Dictionary<Tuple<Type, string>, MethodInfo> methodsByType = new Dictionary<Tuple<Type, string>, MethodInfo>();
         private static Dictionary<string, string> methodMap = new Dictionary<string, string>
@@ -20,11 +21,11 @@ internal class DictionaryObject : ClassObject
 
         public List<string> MappedMethods { get; } = new List<string>();
 
-        internal DictionaryObject(Type tp) : base(tp)
+        internal KeyValuePairEnumerableObject(Type tp) : base(tp)
         {
-            if (!tp.IsDictionary())
+            if (!tp.IsKeyValuePairEnumerable())
             {
-                throw new ArgumentException("object is not a dict");
+                throw new ArgumentException("object is not a KeyValuePair Enumerable");
             }
 
             foreach (var name in methodMap)
@@ -59,11 +60,8 @@ public static int mp_length(IntPtr ob)
             var obj = (CLRObject)GetManagedObject(ob);
             var self = obj.inst;
 
-            MethodInfo methodInfo;
-            if (!TryGetMethodInfo(self.GetType(), "Count", out methodInfo))
-            {
-                return 0;
-            }
+            var key = Tuple.Create(self.GetType(), "Count");
+            var methodInfo = methodsByType[key];
 
             return (int)methodInfo.Invoke(self, null);
         }
@@ -76,11 +74,8 @@ public static int sq_contains(IntPtr ob, IntPtr v)
             var obj = (CLRObject)GetManagedObject(ob);
             var self = obj.inst;
 
-            MethodInfo methodInfo;
-            if (!TryGetMethodInfo(self.GetType(), "ContainsKey", out methodInfo))
-            {
-                return 0;
-            }
+            var key = Tuple.Create(self.GetType(), "ContainsKey");
+            var methodInfo = methodsByType[key];
 
             var parameters = methodInfo.GetParameters();
             object arg;
@@ -92,29 +87,15 @@ public static int sq_contains(IntPtr ob, IntPtr v)
 
             return (bool)methodInfo.Invoke(self, new[] { arg }) ? 1 : 0;
         }
-
-        private static bool TryGetMethodInfo(Type type, string alias, out MethodInfo methodInfo)
-        {
-            var key = Tuple.Create(type, alias);
-
-            if (!methodsByType.TryGetValue(key, out methodInfo))
-            {
-                Exceptions.SetError(Exceptions.TypeError,
-                    $"{nameof(type)} does not define {alias} method");
-
-                return false;
-            }
-
-            return true;
-        }
     }
 
-    public static class DictionaryObjectExtension
+    public static class KeyValuePairEnumerableObjectExtension
     {
-        public static bool IsDictionary(this Type type)
+        public static bool IsKeyValuePairEnumerable(this Type type)
         {
             var iEnumerableType = typeof(IEnumerable<>);
             var keyValuePairType = typeof(KeyValuePair<,>);
+            var requiredMethods = new[] { "ContainsKey", "Count" };
 
             var interfaces = type.GetInterfaces();
             foreach (var i in interfaces)
@@ -130,6 +111,19 @@ public static bool IsDictionary(this Type type)
                         a.GetGenericTypeDefinition() == keyValuePairType &&
                         a.GetGenericArguments().Length == 2)
                     {
+                        foreach (var requiredMethod in requiredMethods)
+                        {
+                            var method = type.GetMethod(requiredMethod);
+                            if (method == null)
+                            {
+                                method = type.GetMethod($"get_{requiredMethod}");
+                                if (method == null)
+                                {
+                                    return false;
+                                }
+                            }
+                        }
+
                         return true;
                     }
                 }