Issue #1717, continued: remove PyObject_Compare and Py_CmpToRich declarations

from object.h; don't inherit tp_compare slot on subclasses; and raise TypeError
when initializing a type that has a nonzero tp_compare slot.  Fix up
comparison-related comments in object.c and code.h.

diff --git a/Include/code.h b/Include/code.h
index 40cce180f51618431becfef341fc6b3c3a66144e..d738d8dd8355067ed9a004c4a77c9993781c3265 100644 (file)
--- a/Include/code.h
+++ b/Include/code.h
@@ -20,7 +20,7 @@ typedef struct {
     PyObject *co_varnames;     /* tuple of strings (local variable names) */
     PyObject *co_freevars;     /* tuple of strings (free variable names) */
     PyObject *co_cellvars;      /* tuple of strings (cell variable names) */
-    /* The rest doesn't count for hash/cmp */
+    /* The rest doesn't count for hash or comparisons */
     PyObject *co_filename;     /* unicode (where it was loaded from) */
     PyObject *co_name;         /* unicode (name, for reference) */
     int co_firstlineno;                /* first source line number */

diff --git a/Include/object.h b/Include/object.h
index b1391ca3a005fa8e3f2a1ab58554f70bcc1d0409..30538b50422542b97eae61698ee5311e1263ea33 100644 (file)
--- a/Include/object.h
+++ b/Include/object.h
@@ -426,10 +426,8 @@ PyAPI_FUNC(PyObject *) PyObject_Repr(PyObject *);
 PyAPI_FUNC(PyObject *) PyObject_Str(PyObject *);
 PyAPI_FUNC(PyObject *) PyObject_ASCII(PyObject *);
 PyAPI_FUNC(PyObject *) PyObject_Bytes(PyObject *);
-PyAPI_FUNC(int) PyObject_Compare(PyObject *, PyObject *);
 PyAPI_FUNC(PyObject *) PyObject_RichCompare(PyObject *, PyObject *, int);
 PyAPI_FUNC(int) PyObject_RichCompareBool(PyObject *, PyObject *, int);
-PyAPI_FUNC(PyObject *) Py_CmpToRich(int op, int cmp);
 PyAPI_FUNC(PyObject *) PyObject_GetAttrString(PyObject *, const char *);
 PyAPI_FUNC(int) PyObject_SetAttrString(PyObject *, const char *, PyObject *);
 PyAPI_FUNC(int) PyObject_HasAttrString(PyObject *, const char *);

diff --git a/Misc/NEWS b/Misc/NEWS
index bcc444a04651314838aef50d765fbf6c17d520b3..dca530c66213e98d2c485999cfed3bb46c2ec37b 100644 (file)
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -12,9 +12,11 @@ What's New in Python 3.1 alpha 0
 Core and Builtins
 -----------------
 
-- Issue #1717: Remove builtin cmp() function, C-API functions
-  PyObject_Cmp and PyObject_Compare, and the support function
-  Py_CmpToRich.
+- Issue #1717: Removed builtin cmp() function, dropped tp_compare
+  slot, the C API functions PyObject_Compare and PyUnicode_Compare and
+  the type definition cmpfunc.  The tp_compare slot is reserved for
+  future usage.  An attempt to initialize a type with a nonzero
+  tp_compare slot will raise TypeError.
 
 - Issue #4707: round(x, n) now returns an integer if x is an integer.
   Previously it returned a float.

diff --git a/Objects/object.c b/Objects/object.c
index 85dbd280b1d3534641dfeed2da94c9058974e0dd..49c985261588e9b9e4dcae6fd4a76bf1c5bf8e08 100644 (file)
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -500,35 +500,19 @@ PyObject_Bytes(PyObject *v)
        return PyBytes_FromObject(v);
 }
 
-/* The new comparison philosophy is: we completely separate three-way
-   comparison from rich comparison.  That is, PyObject_Compare() and
-   PyObject_Cmp() *just* use the tp_compare slot.  And PyObject_RichCompare()
-   and PyObject_RichCompareBool() *just* use the tp_richcompare slot.
+/* For Python 3.0.1 and later, the old three-way comparison has been
+   completely removed in favour of rich comparisons.  PyObject_Compare() and
+   PyObject_Cmp() are gone, and the builtin cmp function no longer exists.
+   The old tp_compare slot will be renamed to tp_reserved, and should no
+   longer be used.  Use tp_richcompare instead.
 
    See (*) below for practical amendments.
 
-   IOW, only cmp() uses tp_compare; the comparison operators (==, !=, <=, <,
-   >=, >) only use tp_richcompare.  Note that list.sort() only uses <.
+   tp_richcompare gets called with a first argument of the appropriate type
+   and a second object of an arbitrary type.  We never do any kind of
+   coercion.
 
-   (And yes, eventually we'll rip out cmp() and tp_compare.)
-
-   The calling conventions are different: tp_compare only gets called with two
-   objects of the appropriate type; tp_richcompare gets called with a first
-   argument of the appropriate type and a second object of an arbitrary type.
-   We never do any kind of coercion.
-
-   The return conventions are also different.
-
-   The tp_compare slot should return a C int, as follows:
-
-     -1 if a < b or if an exception occurred
-      0 if a == b
-     +1 if a > b
-
-   No other return values are allowed.  PyObject_Compare() has the same
-   calling convention.
-
-  The tp_richcompare slot should return an object, as follows:
+   The tp_richcompare slot should return an object, as follows:
 
     NULL if an exception occurred
     NotImplemented if the requested comparison is not implemented
@@ -544,9 +528,6 @@ PyObject_Bytes(PyObject *v)
     comparing the object pointer (i.e. falling back to the base object
     implementation).
 
-  - If three-way comparison is not implemented, it falls back on rich
-    comparison (but not the other way around!).
-
 */
 
 /* Map rich comparison operators to their swapped version, e.g. LT <--> GT */

diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index 3f1df8dbc20b640798eb72d0dee3d0049414c670..c6d6fc8ec3d8741243a6f1b692a7f53586c7806d 100644 (file)
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -3662,7 +3662,7 @@ inherit_slots(PyTypeObject *type, PyTypeObject *base)
                type->tp_setattr = base->tp_setattr;
                type->tp_setattro = base->tp_setattro;
        }
-       /* tp_compare see tp_richcompare */
+       /* tp_compare is ignored, see tp_richcompare */
        COPYSLOT(tp_repr);
        /* tp_hash see tp_richcompare */
        COPYSLOT(tp_call);
@@ -3670,12 +3670,10 @@ inherit_slots(PyTypeObject *type, PyTypeObject *base)
        {
                /* Copy comparison-related slots only when
                   not overriding them anywhere */
-               if (type->tp_compare == NULL &&
-                   type->tp_richcompare == NULL &&
+               if (type->tp_richcompare == NULL &&
                    type->tp_hash == NULL &&
                    !overrides_hash(type))
                {
-                       type->tp_compare = base->tp_compare;
                        type->tp_richcompare = base->tp_richcompare;
                        type->tp_hash = base->tp_hash;
                }
@@ -3888,6 +3886,13 @@ PyType_Ready(PyTypeObject *type)
                        goto error;
        }
 
+       /* Check reserved slots */
+       if (type->tp_compare) {
+               PyErr_Format(PyExc_TypeError,
+                            "type %s has tp_compare",
+                            type->tp_name);
+       }
+
        /* All done -- set the ready flag */
        assert(type->tp_dict != NULL);
        type->tp_flags =