Revert "Merge pull request #11721 from eric-wieser/fix-9647"

This reverts commit 7ce7382d5eacbc3da026289483a841184a609928, reversing
changes made to c52543e4a7d2ab5d1ae4be7364c51965dc4fdb9e.

4 files changed, 25 insertions, 100 deletions

diff --git a/numpy/core/_add_newdocs.py b/numpy/core/_add_newdocs.py
index 513415e09..80fa1466e 100644
--- a/numpy/core/_add_newdocs.py
+++ b/numpy/core/_add_newdocs.py
@@ -2042,6 +2042,14 @@ add_newdoc('numpy.core.multiarray', 'ndarray', ('ctypes',
 
     .. automethod:: numpy.core._internal._ctypes.strides_as
 
+    Be careful using the ctypes attribute - especially on temporary
+    arrays or arrays constructed on the fly. For example, calling
+    ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory
+    that is invalid because the array created as (a+b) is deallocated
+    before the next Python statement. You can avoid this problem using
+    either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will
+    hold a reference to the array until ct is deleted or re-assigned.
+
     If the ctypes module is not available, then the ctypes attribute
     of array objects still returns something useful, but ctypes objects
     are not returned and errors may be raised instead. In particular,
diff --git a/numpy/core/_internal.py b/numpy/core/_internal.py
index a38a7dc35..59da60253 100644
--- a/numpy/core/_internal.py
+++ b/numpy/core/_internal.py
@@ -238,45 +238,19 @@ _getintp_ctype.cache = None
 
 class _missing_ctypes(object):
     def cast(self, num, obj):
-        return obj.value
-
-    class c_void_p(object):
-        def __init__(self, ptr):
-            self.value = ptr
-
-
-
-def _get_void_ptr(arr):
-    """
-    Get a `ctypes.c_void_p` to arr.data, that keeps a reference to the array
-    """
-    import numpy as np
-    # don't let subclasses interfere
-    arr = arr.view(ndarray)
-    # collapse the array to point to at most 1 element, so it become contiguous
-    arr = arr[np.s_[:1,] * arr.ndim + np.s_[...,]]
-    # then convert to ctypes now that we've reduced it to a simple, empty, array
-    arr.flags.writeable = True
-    arr = (ctypes.c_char * 0).from_buffer(arr)
-    # finally cast to void*
-    return ctypes.cast(ctypes.pointer(arr), ctypes.c_void_p)
+        return num
 
+    def c_void_p(self, num):
+        return num
 
 class _ctypes(object):
     def __init__(self, array, ptr=None):
-        self._arr = array
-
         if ctypes:
             self._ctypes = ctypes
-            # get a void pointer to the buffer, which keeps the array alive
-            self._data = _get_void_ptr(array)
-            assert self._data.value == ptr
         else:
-            # fake a pointer-like object that holds onto the reference
             self._ctypes = _missing_ctypes()
-            self._data = self._ctypes.c_void_p(ptr)
-            self._data._objects = array
-
+        self._arr = array
+        self._data = ptr
         if self._arr.ndim == 0:
             self._zerod = True
         else:
@@ -289,8 +263,6 @@ class _ctypes(object):
         ``self.data_as(ctypes.c_void_p)``. Perhaps you want to use the data as a
         pointer to a ctypes array of floating-point data:
         ``self.data_as(ctypes.POINTER(ctypes.c_double))``.
-
-        The returned pointer will keep a reference to the array.
         """
         return self._ctypes.cast(self._data, obj)
 
@@ -312,8 +284,7 @@ class _ctypes(object):
             return None
         return (obj*self._arr.ndim)(*self._arr.strides)
 
-    @property
-    def data(self):
+    def get_data(self):
         """
         A pointer to the memory area of the array as a Python integer.
         This memory area may contain data that is not aligned, or not in correct
@@ -322,16 +293,10 @@ class _ctypes(object):
         attribute to arbitrary C-code to avoid trouble that can include Python
         crashing. User Beware! The value of this attribute is exactly the same
         as ``self._array_interface_['data'][0]``.
-
-        Note that unlike `data_as`, a reference will not be kept to the array:
-        code like ``ctypes.c_void_p((a + b).ctypes.data)`` will result in a
-        pointer to a deallocated array, and should be spelt
-        ``(a + b).ctypes.data_as(ctypes.c_void_p)``
         """
-        return self._data.value
+        return self._data
 
-    @property
-    def shape(self):
+    def get_shape(self):
         """
         (c_intp*self.ndim): A ctypes array of length self.ndim where
         the basetype is the C-integer corresponding to ``dtype('p')`` on this
@@ -342,8 +307,7 @@ class _ctypes(object):
         """
         return self.shape_as(_getintp_ctype())
 
-    @property
-    def strides(self):
+    def get_strides(self):
         """
         (c_intp*self.ndim): A ctypes array of length self.ndim where
         the basetype is the same as for the shape attribute. This ctypes array
@@ -353,20 +317,13 @@ class _ctypes(object):
         """
         return self.strides_as(_getintp_ctype())
 
-    @property
-    def _as_parameter_(self):
-        """
-        Overrides the ctypes semi-magic method
-
-        Enables `c_func(some_array.ctypes)`
-        """
-        return self._data
+    def get_as_parameter(self):
+        return self._ctypes.c_void_p(self._data)
 
-    # kept for compatibility
-    get_data = data.fget
-    get_shape = shape.fget
-    get_strides = strides.fget
-    get_as_parameter = _as_parameter_.fget
+    data = property(get_data)
+    shape = property(get_shape)
+    strides = property(get_strides)
+    _as_parameter_ = property(get_as_parameter, None, doc="_as parameter_")
 
 
 def _newnames(datatype, order):
diff --git a/numpy/core/tests/test_multiarray.py b/numpy/core/tests/test_multiarray.py
index 124629c6a..32d49df02 100644
--- a/numpy/core/tests/test_multiarray.py
+++ b/numpy/core/tests/test_multiarray.py
@@ -7626,46 +7626,6 @@ class TestCTypes(object):
         finally:
             _internal.ctypes = ctypes
 
-    def _make_readonly(x):
-        x.flags.writeable = False
-        return x
-
-    @pytest.mark.parametrize('arr', [
-        np.array([1, 2, 3]),
-        np.array([['one', 'two'], ['three', 'four']]),
-        np.array((1, 2), dtype='i4,i4'),
-        np.array([None], dtype=object),
-        np.array([]),
-        np.empty((0, 0)),
-        _make_readonly(np.array([1, 2, 3])),
-    ], ids=[
-        '1d',
-        '2d',
-        'structured',
-        'object',
-        'empty',
-        'empty-2d',
-        'readonly'
-    ])
-    def test_ctypes_data_as_holds_reference(self, arr):
-        # gh-9647
-        # create a copy to ensure that pytest does not mess with the refcounts
-        arr = arr.copy()
-
-        arr_ref = weakref.ref(arr)
-
-        ctypes_ptr = arr.ctypes.data_as(ctypes.c_void_p)
-
-        # `ctypes_ptr` should hold onto `arr`
-        del arr
-        gc.collect()
-        assert_(arr_ref() is not None, "ctypes pointer did not hold onto a reference")
-
-        # but when the `ctypes_ptr` object dies, so should `arr`
-        del ctypes_ptr
-        gc.collect()
-        assert_(arr_ref() is None, "unknowable whether ctypes pointer holds a reference")
-
 
 class TestWritebackIfCopy(object):
     # all these tests use the WRITEBACKIFCOPY mechanism
diff --git a/numpy/ma/tests/test_core.py b/numpy/ma/tests/test_core.py
index e0dbf1b1a..2775b11ec 100644
--- a/numpy/ma/tests/test_core.py
+++ b/numpy/ma/tests/test_core.py
@@ -2401,9 +2401,9 @@ class TestMaskedArrayInPlaceArithmetics(object):
         assert_equal(xm, y + 1)
 
         (x, _, xm) = self.floatdata
-        id1 = x.data.ctypes.data
+        id1 = x.data.ctypes._data
         x += 1.
-        assert_(id1 == x.data.ctypes.data)
+        assert_(id1 == x.data.ctypes._data)
         assert_equal(x, y + 1.)
 
     def test_inplace_addition_array(self):