From dfc80e3d97680ee26e509daba4a08502fefe22ee Mon Sep 17 00:00:00 2001
From: Brian Curtin <brian@python.org>
Date: Wed, 10 Aug 2011 20:28:54 -0500
Subject: Replace Py_NotImplemented returns with the macro form
 Py_RETURN_NOTIMPLEMENTED. The macro was introduced in #12724.

---
 Modules/_collectionsmodule.c |  3 +--
 Modules/_datetimemodule.c    | 59 ++++++++++++++++----------------------------
 Modules/_sqlite/row.c        | 10 +++-----
 Modules/arraymodule.c        |  6 ++---
 Modules/posixmodule.c        | 10 +++-----
 Modules/xxlimited.c          |  3 +--
 Objects/abstract.c           |  3 +--
 Objects/bytearrayobject.c    |  9 +++----
 Objects/classobject.c        |  6 ++---
 Objects/codeobject.c         |  3 +--
 Objects/complexobject.c      |  3 +--
 Objects/dictobject.c         |  6 ++---
 Objects/floatobject.c        |  3 +--
 Objects/listobject.c         |  6 ++---
 Objects/longobject.c         |  9 +++----
 Objects/memoryobject.c       |  3 +--
 Objects/methodobject.c       |  3 +--
 Objects/object.c             |  3 +--
 Objects/setobject.c          | 59 ++++++++++++++++----------------------------
 Objects/sliceobject.c        |  6 ++---
 Objects/tupleobject.c        |  6 ++---
 Objects/typeobject.c         | 18 +++++---------
 Objects/unicodeobject.c      |  9 +++----
 Objects/weakrefobject.c      |  3 +--
 24 files changed, 87 insertions(+), 162 deletions(-)

diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c
index 8743408..156ad18 100644
--- a/Modules/_collectionsmodule.c
+++ b/Modules/_collectionsmodule.c
@@ -832,8 +832,7 @@ deque_richcompare(PyObject *v, PyObject *w, int op)
 
     if (!PyObject_TypeCheck(v, &deque_type) ||
         !PyObject_TypeCheck(w, &deque_type)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
+        Py_RETURN_NOTIMPLEMENTED;
     }
 
     /* Shortcuts */
diff --git a/Modules/_datetimemodule.c b/Modules/_datetimemodule.c
index 747be45..718dfe2 100644
--- a/Modules/_datetimemodule.c
+++ b/Modules/_datetimemodule.c
@@ -1812,8 +1812,7 @@ delta_richcompare(PyObject *self, PyObject *other, int op)
         return diff_to_bool(diff, op);
     }
     else {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
+        Py_RETURN_NOTIMPLEMENTED;
     }
 }
 
@@ -1911,10 +1910,8 @@ delta_remainder(PyObject *left, PyObject *right)
     PyObject *pyus_remainder;
     PyObject *remainder;
 
-    if (!PyDelta_Check(left) || !PyDelta_Check(right)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (!PyDelta_Check(left) || !PyDelta_Check(right))
+        Py_RETURN_NOTIMPLEMENTED;
 
     pyus_left = delta_to_microseconds((PyDateTime_Delta *)left);
     if (pyus_left == NULL)
@@ -1949,10 +1946,8 @@ delta_divmod(PyObject *left, PyObject *right)
     PyObject *delta;
     PyObject *result;
 
-    if (!PyDelta_Check(left) || !PyDelta_Check(right)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (!PyDelta_Check(left) || !PyDelta_Check(right))
+        Py_RETURN_NOTIMPLEMENTED;
 
     pyus_left = delta_to_microseconds((PyDateTime_Delta *)left);
     if (pyus_left == NULL)
@@ -2546,10 +2541,9 @@ add_date_timedelta(PyDateTime_Date *date, PyDateTime_Delta *delta, int negate)
 static PyObject *
 date_add(PyObject *left, PyObject *right)
 {
-    if (PyDateTime_Check(left) || PyDateTime_Check(right)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (PyDateTime_Check(left) || PyDateTime_Check(right))
+        Py_RETURN_NOTIMPLEMENTED;
+
     if (PyDate_Check(left)) {
         /* date + ??? */
         if (PyDelta_Check(right))
@@ -2568,17 +2562,15 @@ date_add(PyObject *left, PyObject *right)
                                       (PyDateTime_Delta *) left,
                                       0);
     }
-    Py_INCREF(Py_NotImplemented);
-    return Py_NotImplemented;
+    Py_RETURN_NOTIMPLEMENTED;
 }
 
 static PyObject *
 date_subtract(PyObject *left, PyObject *right)
 {
-    if (PyDateTime_Check(left) || PyDateTime_Check(right)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (PyDateTime_Check(left) || PyDateTime_Check(right))
+        Py_RETURN_NOTIMPLEMENTED;
+
     if (PyDate_Check(left)) {
         if (PyDate_Check(right)) {
             /* date - date */
@@ -2597,8 +2589,7 @@ date_subtract(PyObject *left, PyObject *right)
                                       1);
         }
     }
-    Py_INCREF(Py_NotImplemented);
-    return Py_NotImplemented;
+    Py_RETURN_NOTIMPLEMENTED;
 }
 
 
@@ -2715,10 +2706,8 @@ date_richcompare(PyObject *self, PyObject *other, int op)
                           _PyDateTime_DATE_DATASIZE);
         return diff_to_bool(diff, op);
     }
-    else {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    else
+        Py_RETURN_NOTIMPLEMENTED;
 }
 
 static PyObject *
@@ -3215,10 +3204,8 @@ static PyObject *
 timezone_richcompare(PyDateTime_TimeZone *self,
                      PyDateTime_TimeZone *other, int op)
 {
-    if (op != Py_EQ && op != Py_NE) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (op != Py_EQ && op != Py_NE)
+        Py_RETURN_NOTIMPLEMENTED;
     return delta_richcompare(self->offset, other->offset, op);
 }
 
@@ -3664,10 +3651,8 @@ time_richcompare(PyObject *self, PyObject *other, int op)
     PyObject *offset1, *offset2;
     int diff;
 
-    if (! PyTime_Check(other)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (! PyTime_Check(other))
+        Py_RETURN_NOTIMPLEMENTED;
 
     if (GET_TIME_TZINFO(self) == GET_TIME_TZINFO(other)) {
         diff = memcmp(((PyDateTime_Time *)self)->data,
@@ -4356,8 +4341,7 @@ datetime_add(PyObject *left, PyObject *right)
                                       (PyDateTime_Delta *) left,
                                       1);
     }
-    Py_INCREF(Py_NotImplemented);
-    return Py_NotImplemented;
+    Py_RETURN_NOTIMPLEMENTED;
 }
 
 static PyObject *
@@ -4559,8 +4543,7 @@ datetime_richcompare(PyObject *self, PyObject *other, int op)
                 Py_RETURN_TRUE;
             return cmperror(self, other);
         }
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
+        Py_RETURN_NOTIMPLEMENTED;
     }
 
     if (GET_DT_TZINFO(self) == GET_DT_TZINFO(other)) {
diff --git a/Modules/_sqlite/row.c b/Modules/_sqlite/row.c
index 3d44094..b50658c 100644
--- a/Modules/_sqlite/row.c
+++ b/Modules/_sqlite/row.c
@@ -173,10 +173,9 @@ static Py_hash_t pysqlite_row_hash(pysqlite_Row *self)
 
 static PyObject* pysqlite_row_richcompare(pysqlite_Row *self, PyObject *_other, int opid)
 {
-    if (opid != Py_EQ && opid != Py_NE) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (opid != Py_EQ && opid != Py_NE)
+        Py_RETURN_NOTIMPLEMENTED;
+
     if (PyType_IsSubtype(Py_TYPE(_other), &pysqlite_RowType)) {
         pysqlite_Row *other = (pysqlite_Row *)_other;
         PyObject *res = PyObject_RichCompare(self->description, other->description, opid);
@@ -186,8 +185,7 @@ static PyObject* pysqlite_row_richcompare(pysqlite_Row *self, PyObject *_other,
             return PyObject_RichCompare(self->data, other->data, opid);
         }
     }
-    Py_INCREF(Py_NotImplemented);
-    return Py_NotImplemented;
+    Py_RETURN_NOTIMPLEMENTED;
 }
 
 PyMappingMethods pysqlite_row_as_mapping = {
diff --git a/Modules/arraymodule.c b/Modules/arraymodule.c
index ae68c15..81c9c36 100644
--- a/Modules/arraymodule.c
+++ b/Modules/arraymodule.c
@@ -514,10 +514,8 @@ array_richcompare(PyObject *v, PyObject *w, int op)
     Py_ssize_t i, k;
     PyObject *res;
 
-    if (!array_Check(v) || !array_Check(w)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (!array_Check(v) || !array_Check(w))
+        Py_RETURN_NOTIMPLEMENTED;
 
     va = (arrayobject *)v;
     wa = (arrayobject *)w;
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index 2be5ec9..d701690 100644
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -4925,10 +4925,9 @@ cpu_set_richcompare(Py_cpu_set *set, Py_cpu_set *other, int op)
 {
     int eq;
 
-    if ((op != Py_EQ && op != Py_NE) || Py_TYPE(other) != &cpu_set_type) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if ((op != Py_EQ && op != Py_NE) || Py_TYPE(other) != &cpu_set_type)
+        Py_RETURN_NOTIMPLEMENTED;
+
     eq = set->ncpus == other->ncpus && CPU_EQUAL_S(set->size, set->set, other->set);
     if ((op == Py_EQ) ? eq : !eq)
         Py_RETURN_TRUE;
@@ -4949,8 +4948,7 @@ cpu_set_richcompare(Py_cpu_set *set, Py_cpu_set *other, int op)
         } \
         if (Py_TYPE(right) != &cpu_set_type || left->ncpus != right->ncpus) { \
             Py_DECREF(res); \
-            Py_INCREF(Py_NotImplemented); \
-            return Py_NotImplemented; \
+            Py_RETURN_NOTIMPLEMENTED; \
         } \
         assert(left->size == right->size && right->size == res->size); \
         op(res->size, res->set, left->set, right->set); \
diff --git a/Modules/xxlimited.c b/Modules/xxlimited.c
index ec924f2..661b6e2 100644
--- a/Modules/xxlimited.c
+++ b/Modules/xxlimited.c
@@ -187,8 +187,7 @@ static PyType_Spec Str_Type_spec = {
 static PyObject *
 null_richcompare(PyObject *self, PyObject *other, int op)
 {
-    Py_INCREF(Py_NotImplemented);
-    return Py_NotImplemented;
+    Py_RETURN_NOTIMPLEMENTED;
 }
 
 static PyType_Slot Null_Type_slots[] = {
diff --git a/Objects/abstract.c b/Objects/abstract.c
index f992573..8298fd4 100644
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -793,8 +793,7 @@ binary_op1(PyObject *v, PyObject *w, const int op_slot)
             return x;
         Py_DECREF(x); /* can't do it */
     }
-    Py_INCREF(Py_NotImplemented);
-    return Py_NotImplemented;
+    Py_RETURN_NOTIMPLEMENTED;
 }
 
 static PyObject *
diff --git a/Objects/bytearrayobject.c b/Objects/bytearrayobject.c
index 37668c7..d365fbc 100644
--- a/Objects/bytearrayobject.c
+++ b/Objects/bytearrayobject.c
@@ -964,23 +964,20 @@ bytearray_richcompare(PyObject *self, PyObject *other, int op)
                 return NULL;
         }
 
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
+        Py_RETURN_NOTIMPLEMENTED;
     }
 
     self_size = _getbuffer(self, &self_bytes);
     if (self_size < 0) {
         PyErr_Clear();
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
+        Py_RETURN_NOTIMPLEMENTED;
     }
 
     other_size = _getbuffer(other, &other_bytes);
     if (other_size < 0) {
         PyErr_Clear();
         PyBuffer_Release(&self_bytes);
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
+        Py_RETURN_NOTIMPLEMENTED;
     }
 
     if (self_size != other_size && (op == Py_EQ || op == Py_NE)) {
diff --git a/Objects/classobject.c b/Objects/classobject.c
index 6df930f..b52a209 100644
--- a/Objects/classobject.c
+++ b/Objects/classobject.c
@@ -190,8 +190,7 @@ method_richcompare(PyObject *self, PyObject *other, int op)
         !PyMethod_Check(self) ||
         !PyMethod_Check(other))
     {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
+        Py_RETURN_NOTIMPLEMENTED;
     }
     a = (PyMethodObject *)self;
     b = (PyMethodObject *)other;
@@ -516,8 +515,7 @@ instancemethod_richcompare(PyObject *self, PyObject *other, int op)
         !PyInstanceMethod_Check(self) ||
         !PyInstanceMethod_Check(other))
     {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
+        Py_RETURN_NOTIMPLEMENTED;
     }
     a = (PyInstanceMethodObject *)self;
     b = (PyInstanceMethodObject *)other;
diff --git a/Objects/codeobject.c b/Objects/codeobject.c
index db5c17e..3f77718 100644
--- a/Objects/codeobject.c
+++ b/Objects/codeobject.c
@@ -402,8 +402,7 @@ code_richcompare(PyObject *self, PyObject *other, int op)
     if ((op != Py_EQ && op != Py_NE) ||
         !PyCode_Check(self) ||
         !PyCode_Check(other)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
+        Py_RETURN_NOTIMPLEMENTED;
     }
 
     co = (PyCodeObject *)self;
diff --git a/Objects/complexobject.c b/Objects/complexobject.c
index 3c6c32a..85c1d22 100644
--- a/Objects/complexobject.c
+++ b/Objects/complexobject.c
@@ -650,8 +650,7 @@ complex_richcompare(PyObject *v, PyObject *w, int op)
     return res;
 
 Unimplemented:
-    Py_INCREF(Py_NotImplemented);
-    return Py_NotImplemented;
+    Py_RETURN_NOTIMPLEMENTED;
 }
 
 static PyObject *
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
index 3fa5cc4..cdc27ab 100644
--- a/Objects/dictobject.c
+++ b/Objects/dictobject.c
@@ -2608,10 +2608,8 @@ dictview_richcompare(PyObject *self, PyObject *other, int op)
     assert(PyDictViewSet_Check(self));
     assert(other != NULL);
 
-    if (!PyAnySet_Check(other) && !PyDictViewSet_Check(other)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (!PyAnySet_Check(other) && !PyDictViewSet_Check(other))
+        Py_RETURN_NOTIMPLEMENTED;
 
     len_self = PyObject_Size(self);
     if (len_self < 0)
diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index 3392614..a031d1b 100644
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -517,8 +517,7 @@ float_richcompare(PyObject *v, PyObject *w, int op)
     return PyBool_FromLong(r);
 
  Unimplemented:
-    Py_INCREF(Py_NotImplemented);
-    return Py_NotImplemented;
+    Py_RETURN_NOTIMPLEMENTED;
 }
 
 static Py_hash_t
diff --git a/Objects/listobject.c b/Objects/listobject.c
index dab91db..2cd8642 100644
--- a/Objects/listobject.c
+++ b/Objects/listobject.c
@@ -2225,10 +2225,8 @@ list_richcompare(PyObject *v, PyObject *w, int op)
     PyListObject *vl, *wl;
     Py_ssize_t i;
 
-    if (!PyList_Check(v) || !PyList_Check(w)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (!PyList_Check(v) || !PyList_Check(w))
+        Py_RETURN_NOTIMPLEMENTED;
 
     vl = (PyListObject *)v;
     wl = (PyListObject *)w;
diff --git a/Objects/longobject.c b/Objects/longobject.c
index 552f8f0..5df519c 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -1382,10 +1382,8 @@ PyLong_AsLongLongAndOverflow(PyObject *vv, int *overflow)
 
 #define CHECK_BINOP(v,w)                                \
     do {                                                \
-        if (!PyLong_Check(v) || !PyLong_Check(w)) {     \
-            Py_INCREF(Py_NotImplemented);               \
-            return Py_NotImplemented;                   \
-        }                                               \
+        if (!PyLong_Check(v) || !PyLong_Check(w))       \
+            Py_RETURN_NOTIMPLEMENTED;                   \
     } while(0)
 
 /* bits_in_digit(d) returns the unique integer k such that 2**(k-1) <= d <
@@ -3611,8 +3609,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
     else {
         Py_DECREF(a);
         Py_DECREF(b);
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
+        Py_RETURN_NOTIMPLEMENTED;
     }
 
     if (Py_SIZE(b) < 0) {  /* if exponent is negative */
diff --git a/Objects/memoryobject.c b/Objects/memoryobject.c
index 2e32b2a..e0d1a89 100644
--- a/Objects/memoryobject.c
+++ b/Objects/memoryobject.c
@@ -773,8 +773,7 @@ _end:
 _notimpl:
     PyBuffer_Release(&vv);
     PyBuffer_Release(&ww);
-    Py_INCREF(Py_NotImplemented);
-    return Py_NotImplemented;
+    Py_RETURN_NOTIMPLEMENTED;
 }
 
 
diff --git a/Objects/methodobject.c b/Objects/methodobject.c
index f1a9f4b..a7334cf 100644
--- a/Objects/methodobject.c
+++ b/Objects/methodobject.c
@@ -208,8 +208,7 @@ meth_richcompare(PyObject *self, PyObject *other, int op)
         !PyCFunction_Check(self) ||
         !PyCFunction_Check(other))
     {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
+        Py_RETURN_NOTIMPLEMENTED;
     }
     a = (PyCFunctionObject *)self;
     b = (PyCFunctionObject *)other;
diff --git a/Objects/object.c b/Objects/object.c
index 6af426f..cf49e1b 100644
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -1392,8 +1392,7 @@ notimplemented_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         PyErr_SetString(PyExc_TypeError, "NotImplementedType takes no arguments");
         return NULL;
     }
-    Py_INCREF(Py_NotImplemented);
-    return Py_NotImplemented;
+    Py_RETURN_NOTIMPLEMENTED;
 }
 
 static PyTypeObject PyNotImplemented_Type = {
diff --git a/Objects/setobject.c b/Objects/setobject.c
index 2e62518..d1bad27 100644
--- a/Objects/setobject.c
+++ b/Objects/setobject.c
@@ -1212,10 +1212,8 @@ set_or(PySetObject *so, PyObject *other)
 {
     PySetObject *result;
 
-    if (!PyAnySet_Check(so) || !PyAnySet_Check(other)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (!PyAnySet_Check(so) || !PyAnySet_Check(other))
+        Py_RETURN_NOTIMPLEMENTED;
 
     result = (PySetObject *)set_copy(so);
     if (result == NULL)
@@ -1232,10 +1230,9 @@ set_or(PySetObject *so, PyObject *other)
 static PyObject *
 set_ior(PySetObject *so, PyObject *other)
 {
-    if (!PyAnySet_Check(other)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (!PyAnySet_Check(other))
+        Py_RETURN_NOTIMPLEMENTED;
+
     if (set_update_internal(so, other) == -1)
         return NULL;
     Py_INCREF(so);
@@ -1385,10 +1382,8 @@ PyDoc_STRVAR(intersection_update_doc,
 static PyObject *
 set_and(PySetObject *so, PyObject *other)
 {
-    if (!PyAnySet_Check(so) || !PyAnySet_Check(other)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (!PyAnySet_Check(so) || !PyAnySet_Check(other))
+        Py_RETURN_NOTIMPLEMENTED;
     return set_intersection(so, other);
 }
 
@@ -1397,10 +1392,8 @@ set_iand(PySetObject *so, PyObject *other)
 {
     PyObject *result;
 
-    if (!PyAnySet_Check(other)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (!PyAnySet_Check(other))
+        Py_RETURN_NOTIMPLEMENTED;
     result = set_intersection_update(so, other);
     if (result == NULL)
         return NULL;
@@ -1627,20 +1620,16 @@ PyDoc_STRVAR(difference_doc,
 static PyObject *
 set_sub(PySetObject *so, PyObject *other)
 {
-    if (!PyAnySet_Check(so) || !PyAnySet_Check(other)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (!PyAnySet_Check(so) || !PyAnySet_Check(other))
+        Py_RETURN_NOTIMPLEMENTED;
     return set_difference(so, other);
 }
 
 static PyObject *
 set_isub(PySetObject *so, PyObject *other)
 {
-    if (!PyAnySet_Check(other)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (!PyAnySet_Check(other))
+        Py_RETURN_NOTIMPLEMENTED;
     if (set_difference_update_internal(so, other) == -1)
         return NULL;
     Py_INCREF(so);
@@ -1738,10 +1727,8 @@ PyDoc_STRVAR(symmetric_difference_doc,
 static PyObject *
 set_xor(PySetObject *so, PyObject *other)
 {
-    if (!PyAnySet_Check(so) || !PyAnySet_Check(other)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (!PyAnySet_Check(so) || !PyAnySet_Check(other))
+        Py_RETURN_NOTIMPLEMENTED;
     return set_symmetric_difference(so, other);
 }
 
@@ -1750,10 +1737,8 @@ set_ixor(PySetObject *so, PyObject *other)
 {
     PyObject *result;
 
-    if (!PyAnySet_Check(other)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (!PyAnySet_Check(other))
+        Py_RETURN_NOTIMPLEMENTED;
     result = set_symmetric_difference_update(so, other);
     if (result == NULL)
         return NULL;
@@ -1815,10 +1800,9 @@ set_richcompare(PySetObject *v, PyObject *w, int op)
 {
     PyObject *r1, *r2;
 
-    if(!PyAnySet_Check(w)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if(!PyAnySet_Check(w))
+        Py_RETURN_NOTIMPLEMENTED;
+
     switch (op) {
     case Py_EQ:
         if (PySet_GET_SIZE(v) != PySet_GET_SIZE(w))
@@ -1848,8 +1832,7 @@ set_richcompare(PySetObject *v, PyObject *w, int op)
             Py_RETURN_FALSE;
         return set_issuperset(v, w);
     }
-    Py_INCREF(Py_NotImplemented);
-    return Py_NotImplemented;
+    Py_RETURN_NOTIMPLEMENTED;
 }
 
 static PyObject *
diff --git a/Objects/sliceobject.c b/Objects/sliceobject.c
index 53cc951..92464ab 100644
--- a/Objects/sliceobject.c
+++ b/Objects/sliceobject.c
@@ -326,10 +326,8 @@ slice_richcompare(PyObject *v, PyObject *w, int op)
     PyObject *t2;
     PyObject *res;
 
-    if (!PySlice_Check(v) || !PySlice_Check(w)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (!PySlice_Check(v) || !PySlice_Check(w))
+        Py_RETURN_NOTIMPLEMENTED;
 
     if (v == w) {
         /* XXX Do we really need this shortcut?
diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
index bfb7ec7..ccfd281 100644
--- a/Objects/tupleobject.c
+++ b/Objects/tupleobject.c
@@ -546,10 +546,8 @@ tuplerichcompare(PyObject *v, PyObject *w, int op)
     Py_ssize_t i;
     Py_ssize_t vlen, wlen;
 
-    if (!PyTuple_Check(v) || !PyTuple_Check(w)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (!PyTuple_Check(v) || !PyTuple_Check(w))
+        Py_RETURN_NOTIMPLEMENTED;
 
     vt = (PyTupleObject *)v;
     wt = (PyTupleObject *)w;
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index d80b594..bb4622f 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -1212,10 +1212,8 @@ call_maybe(PyObject *o, char *name, PyObject **nameobj, char *format, ...)
     func = lookup_maybe(o, name, nameobj);
     if (func == NULL) {
         va_end(va);
-        if (!PyErr_Occurred()) {
-            Py_INCREF(Py_NotImplemented);
-            return Py_NotImplemented;
-        }
+        if (!PyErr_Occurred())
+            Py_RETURN_NOTIMPLEMENTED;
         return NULL;
     }
 
@@ -3449,8 +3447,7 @@ object_reduce_ex(PyObject *self, PyObject *args)
 static PyObject *
 object_subclasshook(PyObject *cls, PyObject *args)
 {
-    Py_INCREF(Py_NotImplemented);
-    return Py_NotImplemented;
+    Py_RETURN_NOTIMPLEMENTED;
 }
 
 PyDoc_STRVAR(object_subclasshook_doc,
@@ -4818,8 +4815,7 @@ FUNCNAME(PyObject *self, PyObject *other) \
         return call_maybe( \
             other, ROPSTR, &rcache_str, "(O)", self); \
     } \
-    Py_INCREF(Py_NotImplemented); \
-    return Py_NotImplemented; \
+    Py_RETURN_NOTIMPLEMENTED; \
 }
 
 #define SLOT1BIN(FUNCNAME, SLOTNAME, OPSTR, ROPSTR) \
@@ -4996,8 +4992,7 @@ slot_nb_power(PyObject *self, PyObject *other, PyObject *modulus)
         return call_method(self, "__pow__", &pow_str,
                            "(OO)", other, modulus);
     }
-    Py_INCREF(Py_NotImplemented);
-    return Py_NotImplemented;
+    Py_RETURN_NOTIMPLEMENTED;
 }
 
 SLOT0(slot_nb_negative, "__neg__")
@@ -5320,8 +5315,7 @@ slot_tp_richcompare(PyObject *self, PyObject *other, int op)
     func = lookup_method(self, name_op[op], &op_str[op]);
     if (func == NULL) {
         PyErr_Clear();
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
+        Py_RETURN_NOTIMPLEMENTED;
     }
     args = PyTuple_Pack(1, other);
     if (args == NULL)
diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
index bef2abf..0918671 100644
--- a/Objects/unicodeobject.c
+++ b/Objects/unicodeobject.c
@@ -7417,8 +7417,7 @@ PyUnicode_RichCompare(PyObject *left, PyObject *right, int op)
         return v;
     }
 
-    Py_INCREF(Py_NotImplemented);
-    return Py_NotImplemented;
+    Py_RETURN_NOTIMPLEMENTED;
 }
 
 int
@@ -9291,10 +9290,8 @@ static PyMethodDef unicode_methods[] = {
 static PyObject *
 unicode_mod(PyObject *v, PyObject *w)
 {
-    if (!PyUnicode_Check(v)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
+    if (!PyUnicode_Check(v))
+        Py_RETURN_NOTIMPLEMENTED;
     return PyUnicode_Format(v, w);
 }
 
diff --git a/Objects/weakrefobject.c b/Objects/weakrefobject.c
index d0a09d5..c99f6ba 100644
--- a/Objects/weakrefobject.c
+++ b/Objects/weakrefobject.c
@@ -193,8 +193,7 @@ weakref_richcompare(PyWeakReference* self, PyWeakReference* other, int op)
     if ((op != Py_EQ && op != Py_NE) ||
         !PyWeakref_Check(self) ||
         !PyWeakref_Check(other)) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
+        Py_RETURN_NOTIMPLEMENTED;
     }
     if (PyWeakref_GET_OBJECT(self) == Py_None
         || PyWeakref_GET_OBJECT(other) == Py_None) {
-- 
cgit v0.12