Return eleements of interface arrays as interface objects

danabr · danabr · commit a74664cc70ad · 2020-10-01T21:41:37.000+02:00
Even when a method is declared to return an array of interfaces, the CLR
may use an array of the concrete type. Keep track of the intended type
in `ArrayObject` so that elements of the array can be properly wrapped in
`InterfaceObject` when accessed.
diff --git a/src/runtime/arrayobject.cs b/src/runtime/arrayobject.cs
@@ -43,8 +43,9 @@ public static IntPtr tp_new(IntPtr tp, IntPtr args, IntPtr kw)
         public static IntPtr mp_subscript(IntPtr ob, IntPtr idx)
         {
             var obj = (CLRObject)GetManagedObject(ob);
+            var arrObj = (ArrayObject)GetManagedObjectType(ob);
             var items = obj.inst as Array;
-            Type itemType = obj.inst.GetType().GetElementType();
+            Type itemType = arrObj.type.GetElementType();
             int rank = items.Rank;
             int index;
             object value;
diff --git a/src/runtime/converter.cs b/src/runtime/converter.cs
@@ -179,6 +179,15 @@ internal static IntPtr ToPython(object value, Type type)
                 return CLRObject.GetInstHandle(value, ifaceObj.pyHandle);
             }
 
+            // We need to special case interface array handling to ensure we
+            // produce the correct type. Value may be an array of some concrete
+            // type (FooImpl[]), but we want access to go via the interface type
+            // (IFoo[]).
+            if (type.IsArray && type.GetElementType().IsInterface)
+            {
+                return CLRObject.GetInstHandle(value, type);
+            }
+
             // it the type is a python subclass of a managed type then return the
             // underlying python object rather than construct a new wrapper object.
             var pyderived = value as IPythonDerivedType;
@@ -188,7 +197,6 @@ internal static IntPtr ToPython(object value, Type type)
                     return ClassDerivedObject.ToPython(pyderived);
             }
 
-
             // hmm - from Python, we almost never care what the declared
             // type is. we'd rather have the object bound to the actual
             // implementing class.
diff --git a/src/runtime/managedtype.cs b/src/runtime/managedtype.cs
@@ -45,6 +45,25 @@ internal static ManagedType GetManagedObject(IntPtr ob)
             return null;
         }
 
+        /// <summary>
+        /// Given a Python object, return the associated managed object type or null.
+        /// </summary>
+        internal static ManagedType GetManagedObjectType(IntPtr ob)
+        {
+            if (ob != IntPtr.Zero)
+            {
+                IntPtr tp = Runtime.PyObject_TYPE(ob);
+                var flags = Util.ReadCLong(tp, TypeOffset.tp_flags);
+                if ((flags & TypeFlags.Managed) != 0)
+                {
+                    tp = Marshal.ReadIntPtr(tp, TypeOffset.magic());
+                    var gc = (GCHandle)tp;
+                    return (ManagedType)gc.Target;
+                }
+            }
+            return null;
+        }
+
 
         internal static ManagedType GetManagedObjectErr(IntPtr ob)
         {
diff --git a/src/testing/interfacetest.cs b/src/testing/interfacetest.cs
@@ -58,6 +58,11 @@ public ISayHello1 GetNoSayHello(out ISayHello2 hello2)
             return null;
         }
 
+        public ISayHello1 [] GetISayHello1Array()
+        {
+            return new[] { this };
+        }
+
         public interface IPublic
         {
         }
diff --git a/src/tests/test_interface.py b/src/tests/test_interface.py
@@ -99,3 +99,11 @@ def test_null_interface_object_returned():
     hello1, hello2 = ob.GetNoSayHello(None)
     assert hello1 is None
     assert hello2 is None
+
+def test_interface_array_returned():
+    """Test interface type used for methods returning interface arrays"""
+    from Python.Test import InterfaceTest
+
+    ob = InterfaceTest()
+    hellos = ob.GetISayHello1Array()
+    assert type(hellos[0]).__name__ == 'ISayHello1'

Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,11 @@ public ISayHello1 GetNoSayHello(out ISayHello2 hello2)`
`58`	`58`	`return null;`
`59`	`59`	`}`
`60`	`60`
	`61`	`+ public ISayHello1 [] GetISayHello1Array()`
	`62`	`+ {`
	`63`	`+ return new[] { this };`
	`64`	`+ }`
	`65`	`+`
`61`	`66`	`public interface IPublic`
`62`	`67`	`{`
`63`	`68`	`}`