diff --git a/Demo/classes/Rat.py b/Demo/classes/Rat.py
index 8caf1c5ff26..6a350e8a811 100755
--- a/Demo/classes/Rat.py
+++ b/Demo/classes/Rat.py
@@ -226,10 +226,6 @@ def __rcmp__(b, a):
     def __bool__(a):
         return a.__num != 0
 
-    # coercion
-    def __coerce__(a, b):
-        return a, Rat(b)
-
 def test():
     '''\
     Test function for rat module.
diff --git a/Demo/classes/bitvec.py b/Demo/classes/bitvec.py
index 227a5363a2b..ae8443960b8 100755
--- a/Demo/classes/bitvec.py
+++ b/Demo/classes/bitvec.py
@@ -311,13 +311,6 @@ def __invert__(self):
         return BitVec(~self._data & ((1 << self._len) - 1), \
                   self._len)
 
-    def __coerce__(self, otherseq, *rest):
-        #needed for *some* of the arithmetic operations
-        #rprt('%r.__coerce__%r\n' % (self, (otherseq,) + rest))
-        if type(otherseq) != type(self):
-            otherseq = bitvec(otherseq, *rest)
-        return self, otherseq
-
     def __int__(self):
         return int(self._data)
 
diff --git a/Doc/c-api/newtypes.rst b/Doc/c-api/newtypes.rst
index f1ab34ec511..7adf9693c4d 100644
--- a/Doc/c-api/newtypes.rst
+++ b/Doc/c-api/newtypes.rst
@@ -330,7 +330,7 @@ functionality.  The fields of the type object are examined in detail in this
 section.  The fields will be described in the order in which they occur in the
 structure.
 
-Typedefs: unaryfunc, binaryfunc, ternaryfunc, inquiry, coercion, intargfunc,
+Typedefs: unaryfunc, binaryfunc, ternaryfunc, inquiry, intargfunc,
 intintargfunc, intobjargproc, intintobjargproc, objobjargproc, destructor,
 freefunc, printfunc, getattrfunc, getattrofunc, setattrfunc, setattrofunc,
 cmpfunc, reprfunc, hashfunc
@@ -751,19 +751,6 @@ type objects) *must* have the :attr:`ob_size` field.
       :attr:`sq_inplace_repeat`.
 
 
-   .. data:: Py_TPFLAGS_CHECKTYPES
-
-      If this bit is set, the binary and ternary operations in the
-      :ctype:`PyNumberMethods` structure referenced by :attr:`tp_as_number` accept
-      arguments of arbitrary object types, and do their own type conversions if
-      needed.  If this bit is clear, those operations require that all arguments have
-      the current type as their type, and the caller is supposed to perform a coercion
-      operation first.  This applies to :attr:`nb_add`, :attr:`nb_subtract`,
-      :attr:`nb_multiply`, :attr:`nb_divide`, :attr:`nb_remainder`, :attr:`nb_divmod`,
-      :attr:`nb_power`, :attr:`nb_lshift`, :attr:`nb_rshift`, :attr:`nb_and`,
-      :attr:`nb_xor`, and :attr:`nb_or`.
-
-
    .. data:: Py_TPFLAGS_HAVE_RICHCOMPARE
 
       If this bit is set, the type object has the :attr:`tp_richcompare` field, as
diff --git a/Doc/glossary.rst b/Doc/glossary.rst
index 3b4d625d34d..5f0d4c013f7 100644
--- a/Doc/glossary.rst
+++ b/Doc/glossary.rst
@@ -32,19 +32,6 @@ Glossary
       One of the two flavors of classes in earlier Python versions.  Since
       Python 3.0, there are no classic classes anymore.
     
-   coercion
-      The implicit conversion of an instance of one type to another during an
-      operation which involves two arguments of the same type.  For example,
-      ``int(3.15)`` converts the floating point number to the integer ``3``, but
-      in ``3+4.5``, each argument is of a different type (one int, one float),
-      and both must be converted to the same type before they can be added or it
-      will raise a ``TypeError``.  Coercion between two operands can be
-      performed with the ``coerce`` builtin function; thus, ``3+4.5`` is
-      equivalent to calling ``operator.add(*coerce(3, 4.5))`` and results in
-      ``operator.add(3.0, 4.5)``.  Without coercion, all arguments of even
-      compatible types would have to be normalized to the same value by the
-      programmer, e.g., ``float(3)+4.5`` rather than just ``3+4.5``.
-    
    complex number
       An extension of the familiar real number system in which all numbers are
       expressed as a sum of a real part and an imaginary part.  Imaginary
@@ -168,14 +155,14 @@ Glossary
    integer division
       Mathematical division discarding any remainder.  For example, the
       expression ``11/4`` currently evaluates to ``2`` in contrast to the
-      ``2.75`` returned by float division.  Also called *floor division*.
-      When dividing two integers the outcome will always be another integer
-      (having the floor function applied to it). However, if one of the operands
-      is another numeric type (such as a :class:`float`), the result will be
-      coerced (see :term:`coercion`) to a common type.  For example, an integer
-      divided by a float will result in a float value, possibly with a decimal
-      fraction.  Integer division can be forced by using the ``//`` operator
-      instead of the ``/`` operator.  See also :term:`__future__`.
+      ``2.75`` returned by float division.  Also called *floor division*.  When
+      dividing two integers the outcome will always be another integer (having
+      the floor function applied to it). However, if the operands types are
+      different, one of them will be converted to the other's type.  For
+      example, an integer divided by a float will result in a float value,
+      possibly with a decimal fraction.  Integer division can be forced by using
+      the ``//`` operator instead of the ``/`` operator.  See also
+      :term:`__future__`.
     
    interactive
       Python has an interactive interpreter which means that you can try out
diff --git a/Doc/library/decimal.rst b/Doc/library/decimal.rst
index ee4aeecf024..16168482500 100644
--- a/Doc/library/decimal.rst
+++ b/Doc/library/decimal.rst
@@ -312,7 +312,7 @@ Decimal floating point objects share many properties with the other built-in
 numeric types such as :class:`float` and :class:`int`.  All of the usual math
 operations and special methods apply.  Likewise, decimal objects can be copied,
 pickled, printed, used as dictionary keys, used as set elements, compared,
-sorted, and coerced to another type (such as :class:`float` or :class:`long`).
+sorted, and converted to another type (such as :class:`float` or :class:`int`).
 
 In addition to the standard numeric properties, decimal floating point objects
 also have a number of specialized methods:
diff --git a/Include/object.h b/Include/object.h
index c4a5cba6dd5..d03c8889746 100644
--- a/Include/object.h
+++ b/Include/object.h
@@ -133,7 +133,6 @@ typedef PyObject * (*binaryfunc)(PyObject *, PyObject *);
 typedef PyObject * (*ternaryfunc)(PyObject *, PyObject *, PyObject *);
 typedef int (*inquiry)(PyObject *);
 typedef Py_ssize_t (*lenfunc)(PyObject *);
-typedef int (*coercion)(PyObject **, PyObject **);
 typedef PyObject *(*ssizeargfunc)(PyObject *, Py_ssize_t);
 typedef PyObject *(*ssizessizeargfunc)(PyObject *, Py_ssize_t, Py_ssize_t);
 typedef int(*ssizeobjargproc)(PyObject *, Py_ssize_t, PyObject *);
@@ -222,7 +221,7 @@ typedef struct {
 	binaryfunc nb_and;
 	binaryfunc nb_xor;
 	binaryfunc nb_or;
-	coercion nb_coerce;
+	int nb_reserved; /* unused, used to be nb_coerce */
 	unaryfunc nb_int;
 	unaryfunc nb_long;
 	unaryfunc nb_float;
diff --git a/Modules/datetimemodule.c b/Modules/datetimemodule.c
index b48385f4544..6f13a85bcaa 100644
--- a/Modules/datetimemodule.c
+++ b/Modules/datetimemodule.c
@@ -2082,7 +2082,7 @@ static PyNumberMethods delta_as_number = {
 	0,					/*nb_and*/
 	0,					/*nb_xor*/
 	0,					/*nb_or*/
-	0,					/*nb_coerce*/
+	0,					/*nb_reserved*/
 	0,					/*nb_int*/
 	0,					/*nb_long*/
 	0,					/*nb_float*/
diff --git a/Objects/boolobject.c b/Objects/boolobject.c
index 3674086fb66..dfea7f44ac7 100644
--- a/Objects/boolobject.c
+++ b/Objects/boolobject.c
@@ -108,7 +108,7 @@ static PyNumberMethods bool_as_number = {
 	bool_and,		/* nb_and */
 	bool_xor,		/* nb_xor */
 	bool_or,		/* nb_or */
-	0,			/* nb_coerce */
+	0,			/* nb_reserved */
 	0,			/* nb_int */
 	0,			/* nb_long */
 	0,			/* nb_float */
diff --git a/Objects/complexobject.c b/Objects/complexobject.c
index fa493d76e88..a22f22f3a37 100644
--- a/Objects/complexobject.c
+++ b/Objects/complexobject.c
@@ -963,7 +963,7 @@ static PyNumberMethods complex_as_number = {
 	0,					/* nb_and */
 	0,					/* nb_xor */
 	0,					/* nb_or */
-	(coercion)0,				/* nb_coerce */
+	0,					/* nb_reserved */
 	complex_int,				/* nb_int */
 	complex_long,				/* nb_long */
 	complex_float,				/* nb_float */
diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index eb540e691a7..3ef44f63955 100644
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -235,8 +235,7 @@ format_float(char *buf, size_t buflen, PyFloatObject *v, int precision)
 }
 
 /* Macro and helper that convert PyObject obj to a C double and store
-   the value in dbl; this replaces the functionality of the coercion
-   slot function.  If conversion to double raises an exception, obj is
+   the value in dbl.  If conversion to double raises an exception, obj is
    set to NULL, and the function invoking this macro returns NULL.  If
    obj is not of float, int or long type, Py_NotImplemented is incref'ed,
    stored in obj, and returned from the function invoking this macro.
@@ -1069,7 +1068,7 @@ static PyNumberMethods float_as_number = {
 	0,		/*nb_and*/
 	0,		/*nb_xor*/
 	0,		/*nb_or*/
-	(coercion)0,	/*nb_coerce*/
+	0,		/*nb_reserved*/
 	float_trunc,	/*nb_int*/
 	float_trunc,	/*nb_long*/
 	float_float,	/*nb_float*/
diff --git a/Objects/longobject.c b/Objects/longobject.c
index 7f09bb66bad..8ebc31cd949 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -3631,7 +3631,7 @@ static PyNumberMethods long_as_number = {
 			long_and,	/*nb_and*/
 			long_xor,	/*nb_xor*/
 			long_or,	/*nb_or*/
-			0,		/*nb_coerce*/
+			0,		/*nb_reserved*/
 			long_long,	/*nb_int*/
 			long_long,	/*nb_long*/
 			long_float,	/*nb_float*/
diff --git a/Objects/setobject.c b/Objects/setobject.c
index 079f404db8e..ba7d2c4763a 100644
--- a/Objects/setobject.c
+++ b/Objects/setobject.c
@@ -1881,7 +1881,7 @@ static PyNumberMethods set_as_number = {
 	(binaryfunc)set_and,		/*nb_and*/
 	(binaryfunc)set_xor,		/*nb_xor*/
 	(binaryfunc)set_or,		/*nb_or*/
-	0,				/*nb_coerce*/
+	0,				/*nb_reserved*/
 	0,				/*nb_int*/
 	0,				/*nb_long*/
 	0,				/*nb_float*/
diff --git a/Objects/weakrefobject.c b/Objects/weakrefobject.c
index c3d3ff092d6..0aa470386c5 100644
--- a/Objects/weakrefobject.c
+++ b/Objects/weakrefobject.c
@@ -589,7 +589,7 @@ static PyNumberMethods proxy_as_number = {
     proxy_and,              /*nb_and*/
     proxy_xor,              /*nb_xor*/
     proxy_or,               /*nb_or*/
-    0,                      /*nb_coerce*/
+    0,                      /*nb_reserved*/
     proxy_int,              /*nb_int*/
     proxy_long,             /*nb_long*/
     proxy_float,            /*nb_float*/
diff --git a/PC/_winreg.c b/PC/_winreg.c
index a1af710a024..5e5f2e55bef 100644
--- a/PC/_winreg.c
+++ b/PC/_winreg.c
@@ -430,7 +430,7 @@ static PyNumberMethods PyHKEY_NumberMethods =
 	PyHKEY_binaryFailureFunc,	/* nb_and */
 	PyHKEY_binaryFailureFunc,	/* nb_xor */
 	PyHKEY_binaryFailureFunc,	/* nb_or */
-	NULL,				/* nb_coerce */
+	0,				/* nb_reserved */
 	PyHKEY_intFunc,			/* nb_int */
 	PyHKEY_unaryFailureFunc,	/* nb_long */
 	PyHKEY_unaryFailureFunc,	/* nb_float */
diff --git a/Tools/modulator/Templates/object_tp_as_number b/Tools/modulator/Templates/object_tp_as_number
index e69aa9a556b..a3426c24311 100644
--- a/Tools/modulator/Templates/object_tp_as_number
+++ b/Tools/modulator/Templates/object_tp_as_number
@@ -103,13 +103,6 @@ $abbrev$_or($abbrev$object *v, $abbrev$object *w)
 	/* XXXX */
 }
 
-static int
-$abbrev$_coerce(PyObject **pv, PyObject **pw)
-{
-	/* XXXX I haven't a clue... */
-	return 1;
-}
-
 static PyObject *
 $abbrev$_int($abbrev$object *v)
 {