Revert for asserts

Author: sergey-miryanov

Modules/_ctypes/_ctypes.c

@@ -987,7 +987,7 @@ CDataType_from_buffer_copy_impl(PyObject *type, PyTypeObject *cls,
 
     result = generic_pycdata_new(st, (PyTypeObject *)type, NULL, NULL);
     if (result != NULL) {
-        assert(_PyObject_IsUniquelyReferenced(result));
+        assert(Py_REFCNT(result) == 1);
         memcpy(((CDataObject *) result)->b_ptr, (char *)buffer->buf + offset, info->size);
     }
     return result;

Modules/_functoolsmodule.c

@@ -1093,7 +1093,7 @@ _functools_reduce_impl(PyObject *module, PyObject *func, PyObject *seq,
             result = op2;
         else {
             /* Update the args tuple in-place */
-            assert(_PyObject_IsUniquelyReferenced(args));
+            assert(Py_REFCNT(args) == 1);
             Py_XSETREF(_PyTuple_ITEMS(args)[0], result);
             Py_XSETREF(_PyTuple_ITEMS(args)[1], op2);
             if ((result = PyObject_Call(func, args, NULL)) == NULL) {

Modules/itertoolsmodule.c

@@ -2143,7 +2143,7 @@ product_next_lock_held(PyObject *op)
             _PyTuple_Recycle(result);
         }
         /* Now, we've got the only copy so we can update it in-place */
-        assert (npools==0 || _PyObject_IsUniquelyReferenced(result));
+        assert (npools==0 || Py_REFCNT(result) == 1);
 
         /* Update the pool indices right-to-left.  Only advance to the
            next pool when the previous one rolls-over */
@@ -2381,7 +2381,7 @@ combinations_next_lock_held(PyObject *op)
          * CPython's empty tuple is a singleton and cached in
          * PyTuple's freelist.
          */
-        assert(r == 0 || _PyObject_IsUniquelyReferenced(result));
+        assert(r == 0 || Py_REFCNT(result) == 1);
 
         /* Scan indices right-to-left until finding one that is not
            at its maximum (i + n - r). */
@@ -2633,7 +2633,7 @@ cwr_next(PyObject *op)
         }
         /* Now, we've got the only copy so we can update it in-place CPython's
            empty tuple is a singleton and cached in PyTuple's freelist. */
-        assert(r == 0 || _PyObject_IsUniquelyReferenced(result));
+        assert(r == 0 || Py_REFCNT(result) == 1);
 
        /* Scan indices right-to-left until finding one that is not
         * at its maximum (n-1). */
@@ -2893,7 +2893,7 @@ permutations_next(PyObject *op)
             _PyTuple_Recycle(result);
         }
         /* Now, we've got the only copy so we can update it in-place */
-        assert(r == 0 || _PyObject_IsUniquelyReferenced(result));
+        assert(r == 0 || Py_REFCNT(result) == 1);
 
         /* Decrement rightmost cycle, moving leftward upon zero rollover */
         for (i=r-1 ; i>=0 ; i--) {

Objects/longobject.c

@@ -3848,7 +3848,7 @@ long_add(PyLongObject *a, PyLongObject *b)
                    and thus z must be a multiple-digit int.
                    That also means z is not an element of
                    small_ints, so negating it in-place is safe. */
-                assert(_PyObject_IsUniquelyReferenced((PyObject *)z));
+                assert(Py_REFCNT(z) == 1);
                 _PyLong_FlipSign(z);
             }
         }
@@ -3895,8 +3895,7 @@ long_sub(PyLongObject *a, PyLongObject *b)
         else {
             z = x_add(a, b);
             if (z != NULL) {
-                assert(_PyLong_IsZero(z) ||
-                       _PyObject_IsUniquelyReferenced((PyObject *)z));
+                assert(_PyLong_IsZero(z) || Py_REFCNT(z) == 1);
                 _PyLong_FlipSign(z);
             }
         }
@@ -5488,7 +5487,7 @@ long_lshift1(PyLongObject *a, Py_ssize_t wordshift, digit remshift)
     if (z == NULL)
         return NULL;
     if (_PyLong_IsNegative(a)) {
-        assert(_PyObject_IsUniquelyReferenced((PyObject *)z));
+        assert(Py_REFCNT(z) == 1);
         _PyLong_FlipSign(z);
     }
     for (i = 0; i < wordshift; i++)

Objects/setobject.c

@@ -1058,7 +1058,7 @@ set_update_lock_held(PySetObject *so, PyObject *other)
 static int
 set_update_local(PySetObject *so, PyObject *other)
 {
-    assert(_PyObject_IsUniquelyReferenced((PyObject *)so));
+    assert(Py_REFCNT(so) == 1);
     if (PyAnySet_Check(other)) {
         int rv;
         Py_BEGIN_CRITICAL_SECTION(other);

Objects/unicodeobject.c

@@ -1162,7 +1162,7 @@ static int
 resize_inplace(PyObject *unicode, Py_ssize_t length)
 {
     assert(!PyUnicode_IS_COMPACT(unicode));
-    assert(_PyObject_IsUniquelyReferenced(unicode));
+    assert(Py_REFCNT(unicode) == 1);
 
     Py_ssize_t new_size;
     Py_ssize_t char_size;