Return eleements of interface arrays as interface objects

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.

Author: danabr

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;

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.

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)
         {

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
         {
         }

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'