Merge pull request #1786 from losttech/bugs/KeyCollection

lostmsu · web-flow · commit 87d4db92f6da · 2022-05-19T17:15:26.000-07:00
Multiple fixes related to Dictionary.Keys bug
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -21,6 +21,7 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 -   `__name__` and `__signature__` to reflected .NET methods
 -   .NET collection types now implement standard Python collection interfaces from `collections.abc`.
 See [Mixins/collections.py](src/runtime/Mixins/collections.py).
+-   you can cast objects to generic .NET interfaces without specifying generic arguments as long as there is no ambiguity.
 -   .NET arrays implement Python buffer protocol
 -   Python integer interoperability with `System.Numerics.BigInteger`
 -   Python.NET will correctly resolve .NET methods, that accept `PyList`, `PyInt`,
diff --git a/src/runtime/ClassManager.cs b/src/runtime/ClassManager.cs
@@ -133,7 +133,7 @@ internal static void RestoreRuntimeData(ClassManagerState storage)
         /// Return the ClassBase-derived instance that implements a particular
         /// reflected managed type, creating it if it doesn't yet exist.
         /// </summary>
-        internal static ReflectedClrType GetClass(Type type) => ReflectedClrType.GetOrCreate(type);
+        internal static BorrowedReference GetClass(Type type) => ReflectedClrType.GetOrCreate(type);
 
         internal static ClassBase GetClassImpl(Type type)
         {
diff --git a/src/runtime/Mixins/collections.py b/src/runtime/Mixins/collections.py
@@ -7,7 +7,11 @@
 
 class IteratorMixin(col.Iterator):
     def close(self):
-        self.Dispose()
+        if hasattr(self, 'Dispose'):
+            self.Dispose()
+        else:
+            from System import IDisposable
+            IDisposable(self).Dispose()
 
 class IterableMixin(col.Iterable):
     pass
@@ -16,7 +20,12 @@ class SizedMixin(col.Sized):
     def __len__(self): return self.Count
 
 class ContainerMixin(col.Container):
-    def __contains__(self, item): return self.Contains(item)
+    def __contains__(self, item):
+        if hasattr('self', 'Contains'):
+            return self.Contains(item)
+        else:
+            from System.Collections.Generic import ICollection
+            return ICollection(self).Contains(item)
 
 try:
     abc_Collection = col.Collection
diff --git a/src/runtime/TypeManager.cs b/src/runtime/TypeManager.cs
@@ -217,6 +217,23 @@ static void GetPythonTypeName(Type clrType, System.Text.StringBuilder target)
                     }
 
                     target.Append(']');
+
+                    int nestedStart = fullName.IndexOf('+');
+                    while (nestedStart >= 0)
+                    {
+                        target.Append('.');
+                        int nextNested = fullName.IndexOf('+', nestedStart + 1);
+                        if (nextNested < 0)
+                        {
+                            target.Append(fullName.Substring(nestedStart + 1));
+                        }
+                        else
+                        {
+                            target.Append(fullName.Substring(nestedStart + 1, length: nextNested - nestedStart - 1));
+                        }
+                        nestedStart = nextNested;
+                    }
+
                     return;
                 }
             }
diff --git a/src/runtime/Types/ClassObject.cs b/src/runtime/Types/ClassObject.cs
@@ -236,7 +236,7 @@ public override NewReference type_subscript(BorrowedReference idx)
                     return Exceptions.RaiseTypeError("type expected");
                 }
                 Type a = t.MakeArrayType();
-                PyType o = ClassManager.GetClass(a);
+                BorrowedReference o = ClassManager.GetClass(a);
                 return new NewReference(o);
             }
 
diff --git a/src/runtime/Types/ClrObject.cs b/src/runtime/Types/ClrObject.cs
@@ -43,13 +43,13 @@ internal static NewReference GetReference(object ob, BorrowedReference pyType)
 
         internal static NewReference GetReference(object ob, Type type)
         {
-            PyType cc = ClassManager.GetClass(type);
+            BorrowedReference cc = ClassManager.GetClass(type);
             return Create(ob, cc);
         }
 
         internal static NewReference GetReference(object ob)
         {
-            PyType cc = ClassManager.GetClass(ob.GetType());
+            BorrowedReference cc = ClassManager.GetClass(ob.GetType());
             return Create(ob, cc);
         }
 
diff --git a/src/runtime/Types/GenericType.cs b/src/runtime/Types/GenericType.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 
 namespace Python.Runtime
 {
@@ -20,10 +21,58 @@ internal GenericType(Type tp) : base(tp)
         /// </summary>
         public static NewReference tp_new(BorrowedReference tp, BorrowedReference args, BorrowedReference kw)
         {
+            var self = (GenericType)GetManagedObject(tp)!;
+            if (!self.type.Valid)
+            {
+                return Exceptions.RaiseTypeError(self.type.DeletedMessage);
+            }
+            var type = self.type.Value;
+
+            if (type.IsInterface && !type.IsConstructedGenericType)
+            {
+                var nargs = Runtime.PyTuple_Size(args);
+                if (nargs == 1)
+                {
+                    var instance = Runtime.PyTuple_GetItem(args, 0);
+                    return AsGenericInterface(instance, type);
+                }
+            }
+
             Exceptions.SetError(Exceptions.TypeError, "cannot instantiate an open generic type");
+
             return default;
         }
 
+        static NewReference AsGenericInterface(BorrowedReference instance, Type targetType)
+        {
+            if (GetManagedObject(instance) is not CLRObject obj)
+            {
+                return Exceptions.RaiseTypeError("only .NET objects can be cast to .NET interfaces");
+            }
+
+            Type[] supportedInterfaces = obj.inst.GetType().GetInterfaces();
+            Type[] constructedInterfaces = supportedInterfaces
+                .Where(i => i.IsConstructedGenericType && i.GetGenericTypeDefinition() == targetType)
+                .ToArray();
+
+            if (constructedInterfaces.Length == 1)
+            {
+                BorrowedReference pythonic = ClassManager.GetClass(constructedInterfaces[0]);
+                using var args = Runtime.PyTuple_New(1);
+                Runtime.PyTuple_SetItem(args.Borrow(), 0, instance);
+                return Runtime.PyObject_CallObject(pythonic, args.Borrow());
+            }
+
+            if (constructedInterfaces.Length > 1)
+            {
+                string interfaces = string.Join(", ", constructedInterfaces.Select(TypeManager.GetPythonTypeName));
+                return Exceptions.RaiseTypeError("Ambiguous cast to .NET interface. "
+                                               + $"Object implements: {interfaces}");
+            }
+
+            return Exceptions.RaiseTypeError("object does not implement "
+                                           + TypeManager.GetPythonTypeName(targetType));
+        }
 
         /// <summary>
         /// Implements __call__ for reflected generic types.
diff --git a/src/runtime/Types/MethodObject.cs b/src/runtime/Types/MethodObject.cs
@@ -191,7 +191,7 @@ public static NewReference tp_descr_get(BorrowedReference ds, BorrowedReference
                 && obj.inst is IPythonDerivedType
                 && self.type.Value.IsInstanceOfType(obj.inst))
             {
-                var basecls = ClassManager.GetClass(self.type.Value);
+                var basecls = ReflectedClrType.GetOrCreate(self.type.Value);
                 return new MethodBinding(self, new PyObject(ob), basecls).Alloc();
             }
 
diff --git a/src/runtime/Types/ReflectedClrType.cs b/src/runtime/Types/ReflectedClrType.cs
@@ -12,6 +12,7 @@ internal sealed class ReflectedClrType : PyType
 {
     private ReflectedClrType(StolenReference reference) : base(reference, prevalidated: true) { }
     internal ReflectedClrType(ReflectedClrType original) : base(original, prevalidated: true) { }
+    internal ReflectedClrType(BorrowedReference original) : base(original) { }
     ReflectedClrType(SerializationInfo info, StreamingContext context) : base(info, context) { }
 
     internal ClassBase Impl => (ClassBase)ManagedType.GetManagedObject(this)!;
diff --git a/tests/test_collection_mixins.py b/tests/test_collection_mixins.py
@@ -14,3 +14,10 @@ def test_dict_items():
     k,v = items[0]
     assert k == 42
     assert v == "a"
+
+# regression test for https://github.com/pythonnet/pythonnet/issues/1785
+def test_dict_in_keys():
+    d = C.Dictionary[str, int]()
+    d["a"] = 42
+    assert "a" in d.Keys
+    assert "b" not in d.Keys

Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,7 @@ internal static void RestoreRuntimeData(ClassManagerState storage)`
`133`	`133`	`/// Return the ClassBase-derived instance that implements a particular`
`134`	`134`	`/// reflected managed type, creating it if it doesn't yet exist.`
`135`	`135`	`/// </summary>`
`136`		`- internal static ReflectedClrType GetClass(Type type) => ReflectedClrType.GetOrCreate(type);`
	`136`	`+ internal static BorrowedReference GetClass(Type type) => ReflectedClrType.GetOrCreate(type);`
`137`	`137`
`138`	`138`	`internal static ClassBase GetClassImpl(Type type)`
`139`	`139`	`{`
Original file line number	Diff line number	Diff line change
`@@ -236,7 +236,7 @@ public override NewReference type_subscript(BorrowedReference idx)`
`236`	`236`	`return Exceptions.RaiseTypeError("type expected");`
`237`	`237`	`}`
`238`	`238`	`Type a = t.MakeArrayType();`
`239`		`- PyType o = ClassManager.GetClass(a);`
	`239`	`+ BorrowedReference o = ClassManager.GetClass(a);`
`240`	`240`	`return new NewReference(o);`
`241`	`241`	`}`
`242`	`242`
Original file line number	Diff line number	Diff line change
`@@ -43,13 +43,13 @@ internal static NewReference GetReference(object ob, BorrowedReference pyType)`
`43`	`43`
`44`	`44`	`internal static NewReference GetReference(object ob, Type type)`
`45`	`45`	`{`
`46`		`- PyType cc = ClassManager.GetClass(type);`
	`46`	`+ BorrowedReference cc = ClassManager.GetClass(type);`
`47`	`47`	`return Create(ob, cc);`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`internal static NewReference GetReference(object ob)`
`51`	`51`	`{`
`52`		`- PyType cc = ClassManager.GetClass(ob.GetType());`
	`52`	`+ BorrowedReference cc = ClassManager.GetClass(ob.GetType());`
`53`	`53`	`return Create(ob, cc);`
`54`	`54`	`}`
`55`	`55`
Original file line number	Diff line number	Diff line change
`@@ -191,7 +191,7 @@ public static NewReference tp_descr_get(BorrowedReference ds, BorrowedReference`
`191`	`191`	`&& obj.inst is IPythonDerivedType`
`192`	`192`	`&& self.type.Value.IsInstanceOfType(obj.inst))`
`193`	`193`	`{`
`194`		`- var basecls = ClassManager.GetClass(self.type.Value);`
	`194`	`+ var basecls = ReflectedClrType.GetOrCreate(self.type.Value);`
`195`	`195`	`return new MethodBinding(self, new PyObject(ob), basecls).Alloc();`
`196`	`196`	`}`
`197`	`197`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ internal sealed class ReflectedClrType : PyType`
`12`	`12`	`{`
`13`	`13`	`private ReflectedClrType(StolenReference reference) : base(reference, prevalidated: true) { }`
`14`	`14`	`internal ReflectedClrType(ReflectedClrType original) : base(original, prevalidated: true) { }`
	`15`	`+ internal ReflectedClrType(BorrowedReference original) : base(original) { }`
`15`	`16`	`ReflectedClrType(SerializationInfo info, StreamingContext context) : base(info, context) { }`
`16`	`17`
`17`	`18`	`internal ClassBase Impl => (ClassBase)ManagedType.GetManagedObject(this)!;`