Revert "Merge pull request pythonnet#1240 from danabr/auto-cast-ret-val-to-interface"

This reverts commit 50d947f, reversing
changes made to d44f1da.

Author: C-SELLERS

CHANGELOG.md

@@ -21,11 +21,6 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 details about the cause of the failure
 -   `clr.AddReference` no longer adds ".dll" implicitly
 -   `PyIter(PyObject)` constructor replaced with static `PyIter.GetIter(PyObject)` method
--   BREAKING: Return values from .NET methods that return an interface are now automatically
-     wrapped in that interface. This is a breaking change for users that rely on being
-     able to access members that are part of the implementation class, but not the
-     interface.  Use the new __implementation__ or __raw_implementation__ properties to
-     if you need to "downcast" to the implementation class.
 -   BREAKING: Parameters marked with `ParameterAttributes.Out` are no longer returned in addition
      to the regular method return value (unless they are passed with `ref` or `out` keyword).
 -   BREAKING: Drop support for the long-deprecated CLR.* prefix.

src/runtime/arrayobject.cs

@@ -137,13 +137,8 @@ static NewReference NewInstance(Type elementType, BorrowedReference arrayPyType,
         public new static IntPtr mp_subscript(IntPtr ob, IntPtr idx)
         {
             var obj = (CLRObject)GetManagedObject(ob);
-            var arrObj = (ArrayObject)GetManagedObjectType(ob);
-            if (!arrObj.type.Valid)
-            {
-                return Exceptions.RaiseTypeError(arrObj.type.DeletedMessage);
-            }
             var items = obj.inst as Array;
-            Type itemType = arrObj.type.Value.GetElementType();
+            Type itemType = obj.inst.GetType().GetElementType();
             int rank = items.Rank;
             int index;
             object value;

src/runtime/converter.cs

@@ -207,21 +207,6 @@ internal static IntPtr ToPython(object value, Type type)
                 }
             }
 
-            if (type.IsInterface)
-            {
-                var ifaceObj = (InterfaceObject)ClassManager.GetClass(type);
-                return ifaceObj.WrapObject(value);
-            }
-
-            // 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;

src/runtime/interfaceobject.cs

@@ -76,43 +76,7 @@ public static IntPtr tp_new(IntPtr tp, IntPtr args, IntPtr kw)
                 return IntPtr.Zero;
             }
 
-            return self.WrapObject(obj);
-        }
-
-        /// <summary>
-        /// Wrap the given object in an interface object, so that only methods
-        /// of the interface are available.
-        /// </summary>
-        public IntPtr WrapObject(object impl)
-        {
-            var objPtr = CLRObject.GetInstHandle(impl, pyHandle);
-            return objPtr;
-        }
-
-        /// <summary>
-        /// Expose the wrapped implementation through attributes in both
-        /// converted/encoded (__implementation__) and raw (__raw_implementation__) form.
-        /// </summary>
-        public static IntPtr tp_getattro(IntPtr ob, IntPtr key)
-        {
-            var clrObj = (CLRObject)GetManagedObject(ob);
-
-            if (!Runtime.PyString_Check(key))
-            {
-                return Exceptions.RaiseTypeError("string expected");
-            }
-
-            string name = Runtime.GetManagedString(key);
-            if (name == "__implementation__")
-            {
-                return Converter.ToPython(clrObj.inst);
-            }
-            else if (name == "__raw_implementation__")
-            {
-                return CLRObject.GetInstHandle(clrObj.inst);
-            }
-
-            return Runtime.PyObject_GenericGetAttr(ob, key);
+            return CLRObject.GetInstHandle(obj, self.pyHandle);
         }
     }
 }

src/runtime/managedtype.cs

@@ -109,25 +109,6 @@ 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/runtime/typemanager.cs

@@ -251,8 +251,10 @@ internal static IntPtr CreateType(ManagedType impl, Type clrType)
                 InitializeSlot(type, TypeOffset.mp_length, mp_length_slot.Method, slotsHolder);
             }
 
-            if (!typeof(IEnumerable).IsAssignableFrom(clrType) &&
-                !typeof(IEnumerator).IsAssignableFrom(clrType))
+            // we want to do this after the slot stuff above in case the class itself implements a slot method
+            InitializeSlots(type, impl.GetType());
+
+            if (!clrType.GetInterfaces().Any(ifc => ifc == typeof(IEnumerable) || ifc == typeof(IEnumerator)))
             {
                 // The tp_iter slot should only be set for enumerable types.
                 Marshal.WriteIntPtr(type, TypeOffset.tp_iter, IntPtr.Zero);

src/testing/interfacetest.cs

@@ -11,6 +11,7 @@ internal interface IInternalInterface
     {
     }
 
+
     public interface ISayHello1
     {
         string SayHello();
@@ -42,27 +43,6 @@ string ISayHello2.SayHello()
             return "hello 2";
         }
 
-        public ISayHello1 GetISayHello1()
-        {
-            return this;
-        }
-
-        public void GetISayHello2(out ISayHello2 hello2)
-        {
-            hello2 = this;
-        }
-
-        public ISayHello1 GetNoSayHello(out ISayHello2 hello2)
-        {
-            hello2 = null;
-            return null;
-        }
-
-        public ISayHello1 [] GetISayHello1Array()
-        {
-            return new[] { this };
-        }
-
         public interface IPublic
         {
         }

src/testing/subclasstest.cs

@@ -89,24 +89,13 @@ public static string test_bar(IInterfaceTest x, string s, int i)
         }
 
         // test instances can be constructed in managed code
-        public static SubClassTest create_instance(Type t)
-        {
-            return (SubClassTest)t.GetConstructor(new Type[] { }).Invoke(new object[] { });
-        }
-
-        public static IInterfaceTest create_instance_interface(Type t)
+        public static IInterfaceTest create_instance(Type t)
         {
             return (IInterfaceTest)t.GetConstructor(new Type[] { }).Invoke(new object[] { });
         }
 
-        // test instances pass through managed code unchanged ...
-        public static SubClassTest pass_through(SubClassTest s)
-        {
-            return s;
-        }
-
-        // ... but the return type is an interface type, objects get wrapped
-        public static IInterfaceTest pass_through_interface(IInterfaceTest s)
+        // test instances pass through managed code unchanged
+        public static IInterfaceTest pass_through(IInterfaceTest s)
         {
             return s;
         }

tests/test_array.py

@@ -1334,10 +1334,9 @@ def test_special_array_creation():
     assert value[1].__class__ == inst.__class__
     assert value.Length == 2
 
-    iface_class = ISayHello1(inst).__class__
     value = Array[ISayHello1]([inst, inst])
-    assert value[0].__class__ == iface_class
-    assert value[1].__class__ == iface_class
+    assert value[0].__class__ == inst.__class__
+    assert value[1].__class__ == inst.__class__
     assert value.Length == 2
 
     inst = System.Exception("badness")

tests/test_generic.py

@@ -318,6 +318,7 @@ def test_generic_method_type_handling():
     assert_generic_method_by_type(ShortEnum, ShortEnum.Zero)
     assert_generic_method_by_type(System.Object, InterfaceTest())
     assert_generic_method_by_type(InterfaceTest, InterfaceTest(), 1)
+    assert_generic_method_by_type(ISayHello1, InterfaceTest(), 1)
 
 
 def test_correct_overload_selection():
@@ -546,11 +547,10 @@ def test_method_overload_selection_with_generic_types():
     value = MethodTest.Overloaded.__overloads__[vtype](input_)
     assert value.value.__class__ == inst.__class__
 
-    iface_class = ISayHello1(inst).__class__
     vtype = GenericWrapper[ISayHello1]
     input_ = vtype(inst)
     value = MethodTest.Overloaded.__overloads__[vtype](input_)
-    assert value.value.__class__ == iface_class
+    assert value.value.__class__ == inst.__class__
 
     vtype = System.Array[GenericWrapper[int]]
     input_ = vtype([GenericWrapper[int](0), GenericWrapper[int](1)])
@@ -725,12 +725,11 @@ def test_overload_selection_with_arrays_of_generic_types():
     assert value[0].value.__class__ == inst.__class__
     assert value.Length == 2
 
-    iface_class = ISayHello1(inst).__class__
     gtype = GenericWrapper[ISayHello1]
     vtype = System.Array[gtype]
     input_ = vtype([gtype(inst), gtype(inst)])
     value = MethodTest.Overloaded.__overloads__[vtype](input_)
-    assert value[0].value.__class__ == iface_class
+    assert value[0].value.__class__ == inst.__class__
     assert value.Length == 2