@@ -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;
 
@@ -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.
 
@@ -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)
         {
 
@@ -58,6 +58,11 @@ public ISayHello1 GetNoSayHello(out ISayHello2 hello2)
             return null;
         }
 
+        public ISayHello1 [] GetISayHello1Array()
+        {
+            return new[] { this };
+        }
+
         public interface IPublic
         {
         }
 
@@ -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	}