Get rid of remnants of integer division

Include/object.h

@@ -158,7 +158,6 @@ typedef struct {
 	binaryfunc nb_add;
 	binaryfunc nb_subtract;
 	binaryfunc nb_multiply;
-	binaryfunc nb_divide;
 	binaryfunc nb_remainder;
 	binaryfunc nb_divmod;
 	ternaryfunc nb_power;
@@ -182,7 +181,6 @@ typedef struct {
 	binaryfunc nb_inplace_add;
 	binaryfunc nb_inplace_subtract;
 	binaryfunc nb_inplace_multiply;
-	binaryfunc nb_inplace_divide;
 	binaryfunc nb_inplace_remainder;
 	ternaryfunc nb_inplace_power;
 	binaryfunc nb_inplace_lshift;
@@ -192,7 +190,6 @@ typedef struct {
 	binaryfunc nb_inplace_or;
 
 	/* Added in release 2.2 */
-	/* The following require the Py_TPFLAGS_HAVE_CLASS flag */
 	binaryfunc nb_floor_divide;
 	binaryfunc nb_true_divide;
 	binaryfunc nb_inplace_floor_divide;

Lib/decimal.py

@@ -1135,10 +1135,9 @@ class Decimal(object):
         return ans
     __rmul__ = __mul__
 
-    def __div__(self, other, context=None):
+    def __truediv__(self, other, context=None):
         """Return self / other."""
         return self._divide(other, context=context)
-    __truediv__ = __div__
 
     def _divide(self, other, divmod = 0, context=None):
         """Return a / b, to context.prec precision.
@@ -1306,13 +1305,12 @@ class Decimal(object):
             ans = ans._fix(context)
         return ans
 
-    def __rdiv__(self, other, context=None):
+    def __rtruediv__(self, other, context=None):
-        """Swaps self/other and returns __div__."""
+        """Swaps self/other and returns __truediv__."""
         other = _convert_other(other)
         if other is NotImplemented:
             return other
-        return other.__div__(self, context=context)
+        return other.__truediv__(self, context=context)
-    __rtruediv__ = __rdiv__
 
     def __divmod__(self, other, context=None):
         """
@@ -1384,9 +1382,9 @@ class Decimal(object):
         rounding = context._set_rounding_decision(NEVER_ROUND)
 
         if other._sign:
-            comparison = other.__div__(Decimal(-2), context=context)
+            comparison = other.__truediv__(Decimal(-2), context=context)
         else:
-            comparison = other.__div__(Decimal(2), context=context)
+            comparison = other.__truediv__(Decimal(2), context=context)
 
         context._set_rounding_decision(rounding)
         context._regard_flags(*flags)
@@ -1751,7 +1749,7 @@ class Decimal(object):
         if n < 0:
             #n is a long now, not Decimal instance
             n = -n
-            mul = Decimal(1).__div__(mul, context=context)
+            mul = Decimal(1).__truediv__(mul, context=context)
 
         spot = 1
         while spot <= n:
@@ -1972,7 +1970,7 @@ class Decimal(object):
         rounding = context._set_rounding(ROUND_HALF_EVEN)
         while 1:
             context.prec = min(2*context.prec - 2, maxp)
-            ans = half.__mul__(ans.__add__(tmp.__div__(ans, context=context),
+            ans = half.__mul__(ans.__add__(tmp.__truediv__(ans, context=context),
                                            context=context), context=context)
             if context.prec == maxp:
                 break
@@ -2454,7 +2452,7 @@ class Context(object):
         >>> ExtendedContext.divide(Decimal('2.40E+6'), Decimal('2'))
         Decimal("1.20E+6")
         """
-        return a.__div__(b, context=self)
+        return a.__truediv__(b, context=self)
 
     def divide_int(self, a, b):
         """Divides two numbers and returns the integer part of the result.

Lib/test/test_augassign.py

@@ -5,7 +5,7 @@ x += 1
 x *= 2
 x **= 2
 x -= 8
-x //= 2
+x /= 2
 x //= 1
 x %= 12
 x &= 2
@@ -19,7 +19,7 @@ x[0] += 1
 x[0] *= 2
 x[0] **= 2
 x[0] -= 8
-x[0] //= 2
+x[0] /= 2
 x[0] //= 2
 x[0] %= 12
 x[0] &= 2
@@ -33,7 +33,7 @@ x[0] += 1
 x[0] *= 2
 x[0] **= 2
 x[0] -= 8
-x[0] //= 2
+x[0] /= 2
 x[0] //= 1
 x[0] %= 12
 x[0] &= 2
@@ -123,14 +123,6 @@ class testall:
         print "__imul__ called"
         return self
 
-    def __div__(self, val):
-        print "__div__ called"
-    def __rdiv__(self, val):
-        print "__rdiv__ called"
-    def __idiv__(self, val):
-        print "__idiv__ called"
-        return self
-
     def __floordiv__(self, val):
         print "__floordiv__ called"
         return self
@@ -147,6 +139,9 @@ class testall:
     def __itruediv__(self, val):
         print "__itruediv__ called"
         return self
+    def __rtruediv__(self, val):
+        print "__rtruediv__ called"
+        return self
 
     def __mod__(self, val):
         print "__mod__ called"
@@ -217,16 +212,9 @@ x * 1
 1 * x
 x *= 1
 
-if 1/2 == 0:
+x / 1
-    x / 1
+1 / x
-    1 / x
+x /= 1
-    x /= 1
-else:
-    # True division is in effect, so "/" doesn't map to __div__ etc;
-    # but the canned expected-output file requires that those get called.
-    x.__div__(1)
-    x.__rdiv__(1)
-    x.__idiv__(1)
 
 x // 1
 1 // x

Lib/test/test_binop.py

@@ -140,8 +140,6 @@ class Rat(object):
             return float(self) / other
         return NotImplemented
 
-    __div__ = __truediv__
-
     def __rtruediv__(self, other):
         """Divide two Rats, or a Rat and a number (reversed args)."""
         if isRat(other):
@@ -152,8 +150,6 @@ class Rat(object):
             return other / float(self)
         return NotImplemented
 
-    __rdiv__ = __rtruediv__
-
     def __floordiv__(self, other):
         """Divide two Rats, returning the floored result."""
         if isint(other):

Lib/test/test_class.py

@@ -11,8 +11,8 @@ testmeths = [
     "rsub",
     "mul",
     "rmul",
-    "div",
+    "truediv",
-    "rdiv",
+    "rtruediv",
     "mod",
     "rmod",
     "divmod",
@@ -134,16 +134,8 @@ testme - 1
 testme * 1
 1 * testme
 
-if 1/2 == 0:
+testme / 1
-    testme / 1
+1 / testme
-    1 / testme
-else:
-    # True division is in effect, so "/" doesn't map to __div__ etc; but
-    # the canned expected-output file requires that __div__ etc get called.
-    testme.__coerce__(1)
-    testme.__div__(1)
-    testme.__coerce__(1)
-    testme.__rdiv__(1)
 
 testme % 1
 1 % testme

Lib/test/test_coercion.py

@@ -44,10 +44,10 @@ class MethodNumber:
     def __rmul__(self,other):
         return other * self.arg
 
-    def __div__(self,other):
+    def __truediv__(self,other):
         return self.arg / other
 
-    def __rdiv__(self,other):
+    def __rtruediv__(self,other):
         return other / self.arg
 
     def __pow__(self,other):

Lib/test/test_complex.py

@@ -55,19 +55,15 @@ class ComplexTest(unittest.TestCase):
         if x != 0:
             q = z / x
             self.assertClose(q, y)
-            q = z.__div__(x)
-            self.assertClose(q, y)
             q = z.__truediv__(x)
             self.assertClose(q, y)
         if y != 0:
             q = z / y
             self.assertClose(q, x)
-            q = z.__div__(y)
-            self.assertClose(q, x)
             q = z.__truediv__(y)
             self.assertClose(q, x)
 
-    def test_div(self):
+    def test_truediv(self):
         simple_real = [float(i) for i in xrange(-5, 6)]
         simple_complex = [complex(x, y) for x in simple_real for y in simple_real]
         for x in simple_complex:
@@ -84,7 +80,7 @@ class ComplexTest(unittest.TestCase):
             self.check_div(complex(random(), random()),
                            complex(random(), random()))
 
-        self.assertRaises(ZeroDivisionError, complex.__div__, 1+1j, 0+0j)
+        self.assertRaises(ZeroDivisionError, complex.__truediv__, 1+1j, 0+0j)
         # FIXME: The following currently crashes on Alpha
         # self.assertRaises(OverflowError, pow, 1e200+1j, 1e200+1j)
 

Lib/test/test_decimal.py

@@ -507,7 +507,7 @@ class DecimalImplicitConstructionTest(unittest.TestCase):
                 ('+', '__add__', '__radd__'),
                 ('-', '__sub__', '__rsub__'),
                 ('*', '__mul__', '__rmul__'),
-                ('/', '__div__', '__rdiv__'),
+                ('/', '__truediv__', '__rtruediv__'),
                 ('%', '__mod__', '__rmod__'),
                 ('//', '__floordiv__', '__rfloordiv__'),
                 ('**', '__pow__', '__rpow__'),
@@ -975,7 +975,6 @@ class DecimalUsabilityTest(unittest.TestCase):
 
         checkSameDec("__abs__")
         checkSameDec("__add__", True)
-        checkSameDec("__div__", True)
         checkSameDec("__divmod__", True)
         checkSameDec("__cmp__", True)
         checkSameDec("__float__")
@@ -990,7 +989,6 @@ class DecimalUsabilityTest(unittest.TestCase):
         checkSameDec("__pos__")
         checkSameDec("__pow__", True)
         checkSameDec("__radd__", True)
-        checkSameDec("__rdiv__", True)
         checkSameDec("__rdivmod__", True)
         checkSameDec("__repr__")
         checkSameDec("__rfloordiv__", True)

Lib/test/test_descr.py

@@ -29,10 +29,6 @@ def testbinop(a, b, res, expr="a+b", meth="__add__"):
     if verbose: print "checking", expr
     dict = {'a': a, 'b': b}
 
-    # XXX Hack so this passes before 2.3 when -Qnew is specified.
-    if meth == "__div__" and 1/2 == 0.5:
-        meth = "__truediv__"
-
     vereq(eval(expr, dict), res)
     t = type(a)
     m = getattr(t, meth)
@@ -4044,9 +4040,8 @@ def notimplemented():
                 ('__add__',      'x + y',                   'x += y'),
                 ('__sub__',      'x - y',                   'x -= y'),
                 ('__mul__',      'x * y',                   'x *= y'),
-                ('__truediv__',  'operator.truediv(x, y)',  None),
+                ('__truediv__',  'x / y',                   None),
-                ('__floordiv__', 'operator.floordiv(x, y)', None),
+                ('__floordiv__', 'x // y',                  None),
-                ('__div__',      'x / y',                   'x /= y'),
                 ('__mod__',      'x % y',                   'x %= y'),
                 ('__divmod__',   'divmod(x, y)',            None),
                 ('__pow__',      'x ** y',                  'x **= y'),

Lib/test/test_operator.py

@@ -144,11 +144,6 @@ class OperatorTestCase(unittest.TestCase):
         self.failUnless(operator.delslice(a, 2, 8) is None)
         self.assert_(a == [0, 1, 8, 9])
 
-    def test_div(self):
-        self.failUnlessRaises(TypeError, operator.div, 5)
-        self.failUnlessRaises(TypeError, operator.div, None, None)
-        self.failUnless(operator.floordiv(5, 2) == 2)
-
     def test_floordiv(self):
         self.failUnlessRaises(TypeError, operator.floordiv, 5)
         self.failUnlessRaises(TypeError, operator.floordiv, None, None)
@@ -416,7 +411,6 @@ class OperatorTestCase(unittest.TestCase):
         class C(object):
             def __iadd__     (self, other): return "iadd"
             def __iand__     (self, other): return "iand"
-            def __idiv__     (self, other): return "idiv"
             def __ifloordiv__(self, other): return "ifloordiv"
             def __ilshift__  (self, other): return "ilshift"
             def __imod__     (self, other): return "imod"
@@ -431,7 +425,6 @@ class OperatorTestCase(unittest.TestCase):
         c = C()
         self.assertEqual(operator.iadd     (c, 5), "iadd")
         self.assertEqual(operator.iand     (c, 5), "iand")
-        self.assertEqual(operator.idiv     (c, 5), "idiv")
         self.assertEqual(operator.ifloordiv(c, 5), "ifloordiv")
         self.assertEqual(operator.ilshift  (c, 5), "ilshift")
         self.assertEqual(operator.imod     (c, 5), "imod")
@@ -446,7 +439,6 @@ class OperatorTestCase(unittest.TestCase):
         self.assertEqual(operator.irepeat  (c, 5), "imul")
         self.assertEqual(operator.__iadd__     (c, 5), "iadd")
         self.assertEqual(operator.__iand__     (c, 5), "iand")
-        self.assertEqual(operator.__idiv__     (c, 5), "idiv")
         self.assertEqual(operator.__ifloordiv__(c, 5), "ifloordiv")
         self.assertEqual(operator.__ilshift__  (c, 5), "ilshift")
         self.assertEqual(operator.__imod__     (c, 5), "imod")

Misc/NEWS

@@ -40,6 +40,14 @@ Core and Builtins
 - Exceptions *must* derive from BaseException.
 
 - Integer division always returns a float.  The -Q option is no more.
+  All the following are gone:
+   * PyNumber_Divide and PyNumber_InPlaceDivide
+   * __div__, __rdiv__, and __idiv__
+   * nb_divide, nb_inplace_divide
+   * operator.div, operator.idiv, operator.__div__, operator.__idiv__
+  (Only __truediv__ and __floordiv__ remain, not sure how to handle them
+   if we want to re-use __div__ and friends.  If we do, it will make
+   it harder to write code for both 2.x and 3.x.)
 
 - 'as' and 'with' are keywords.
 

Modules/_ctypes/_ctypes.c

@@ -3812,7 +3812,6 @@ static PyNumberMethods Simple_as_number = {
 	0, /* nb_add */
 	0, /* nb_subtract */
 	0, /* nb_multiply */
-	0, /* nb_divide */
 	0, /* nb_remainder */
 	0, /* nb_divmod */
 	0, /* nb_power */
@@ -4165,7 +4164,6 @@ static PyNumberMethods Pointer_as_number = {
 	0, /* nb_add */
 	0, /* nb_subtract */
 	0, /* nb_multiply */
-	0, /* nb_divide */
 	0, /* nb_remainder */
 	0, /* nb_divmod */
 	0, /* nb_power */

Modules/datetimemodule.c

@@ -2080,7 +2080,6 @@ static PyNumberMethods delta_as_number = {
 	delta_add,				/* nb_add */
 	delta_subtract,				/* nb_subtract */
 	delta_multiply,				/* nb_multiply */
-	delta_divide,				/* nb_divide */
 	0,					/* nb_remainder */
 	0,					/* nb_divmod */
 	0,					/* nb_power */
@@ -2103,7 +2102,6 @@ static PyNumberMethods delta_as_number = {
 	0,					/*nb_inplace_add*/
 	0,					/*nb_inplace_subtract*/
 	0,					/*nb_inplace_multiply*/
-	0,					/*nb_inplace_divide*/
 	0,					/*nb_inplace_remainder*/
 	0,					/*nb_inplace_power*/
 	0,					/*nb_inplace_lshift*/
@@ -2665,7 +2663,6 @@ static PyNumberMethods date_as_number = {
 	date_add,					/* nb_add */
 	date_subtract,					/* nb_subtract */
 	0,						/* nb_multiply */
-	0,						/* nb_divide */
 	0,						/* nb_remainder */
 	0,						/* nb_divmod */
 	0,						/* nb_power */
@@ -3441,7 +3438,6 @@ static PyNumberMethods time_as_number = {
 	0,					/* nb_add */
 	0,					/* nb_subtract */
 	0,					/* nb_multiply */
-	0,					/* nb_divide */
 	0,					/* nb_remainder */
 	0,					/* nb_divmod */
 	0,					/* nb_power */
@@ -4526,7 +4522,6 @@ static PyNumberMethods datetime_as_number = {
 	datetime_add,				/* nb_add */
 	datetime_subtract,			/* nb_subtract */
 	0,					/* nb_multiply */
-	0,					/* nb_divide */
 	0,					/* nb_remainder */
 	0,					/* nb_divmod */
 	0,					/* nb_power */

Modules/mathmodule.c

@@ -266,7 +266,7 @@ math_log(PyObject *self, PyObject *args)
 		return NULL;
 	}
 
-	ans = PyNumber_Divide(num, den);
+	ans = PyNumber_TrueDivide(num, den);
 	Py_DECREF(num);
 	Py_DECREF(den);
 	return ans;

Modules/operator.c

@@ -65,7 +65,6 @@ spami(truth            , PyObject_IsTrue)
 spam2(op_add           , PyNumber_Add)
 spam2(op_sub           , PyNumber_Subtract)
 spam2(op_mul           , PyNumber_Multiply)
-spam2(op_div           , PyNumber_Divide)
 spam2(op_floordiv      , PyNumber_FloorDivide)
 spam2(op_truediv       , PyNumber_TrueDivide)
 spam2(op_mod           , PyNumber_Remainder)
@@ -83,7 +82,6 @@ spam2(op_or_           , PyNumber_Or)
 spam2(op_iadd          , PyNumber_InPlaceAdd)
 spam2(op_isub          , PyNumber_InPlaceSubtract)
 spam2(op_imul          , PyNumber_InPlaceMultiply)
-spam2(op_idiv          , PyNumber_InPlaceDivide)
 spam2(op_ifloordiv     , PyNumber_InPlaceFloorDivide)
 spam2(op_itruediv      , PyNumber_InPlaceTrueDivide)
 spam2(op_imod          , PyNumber_InPlaceRemainder)
@@ -247,9 +245,8 @@ spam2(index, __index__, "index(a) -- Same as a.__index__()")
 spam2(add,__add__, "add(a, b) -- Same as a + b.")
 spam2(sub,__sub__, "sub(a, b) -- Same as a - b.")
 spam2(mul,__mul__, "mul(a, b) -- Same as a * b.")
-spam2(div,__div__, "div(a, b) -- Same as a / b when __future__.division is not in effect.")
 spam2(floordiv,__floordiv__, "floordiv(a, b) -- Same as a // b.")
-spam2(truediv,__truediv__, "truediv(a, b) -- Same as a / b when __future__.division is in effect.")
+spam2(truediv,__truediv__, "truediv(a, b) -- Same as a / b.")
 spam2(mod,__mod__, "mod(a, b) -- Same as a % b.")
 spam2o(neg,__neg__, "neg(a) -- Same as -a.")
 spam2o(pos,__pos__, "pos(a) -- Same as +a.")
@@ -265,9 +262,8 @@ spam2(or_,__or__, "or_(a, b) -- Same as a | b.")
 spam2(iadd,__iadd__, "iadd(a, b) -- Same as a += b.")
 spam2(isub,__isub__, "isub(a, b) -- Same as a -= b.")
 spam2(imul,__imul__, "imul(a, b) -- Same as a *= b.")
-spam2(idiv,__idiv__, "idiv(a, b) -- Same as a /= b when __future__.division is not in effect.")
 spam2(ifloordiv,__ifloordiv__, "ifloordiv(a, b) -- Same as a //= b.")
-spam2(itruediv,__itruediv__, "itruediv(a, b) -- Same as a /= b when __future__.division is in effect.")
+spam2(itruediv,__itruediv__, "itruediv(a, b) -- Same as a /= b.")
 spam2(imod,__imod__, "imod(a, b) -- Same as a %= b.")
 spam2(ilshift,__ilshift__, "ilshift(a, b) -- Same as a <<= b.")
 spam2(irshift,__irshift__, "irshift(a, b) -- Same as a >>= b.")

Objects/abstract.c

@@ -625,7 +625,6 @@ BINARY_FUNC(PyNumber_And, nb_and, "&")
 BINARY_FUNC(PyNumber_Lshift, nb_lshift, "<<")
 BINARY_FUNC(PyNumber_Rshift, nb_rshift, ">>")
 BINARY_FUNC(PyNumber_Subtract, nb_subtract, "-")
-BINARY_FUNC(PyNumber_Divide, nb_divide, "/")
 BINARY_FUNC(PyNumber_Divmod, nb_divmod, "divmod()")
 
 PyObject *
@@ -765,7 +764,6 @@ INPLACE_BINOP(PyNumber_InPlaceAnd, nb_inplace_and, nb_and, "&=")
 INPLACE_BINOP(PyNumber_InPlaceLshift, nb_inplace_lshift, nb_lshift, "<<=")
 INPLACE_BINOP(PyNumber_InPlaceRshift, nb_inplace_rshift, nb_rshift, ">>=")
 INPLACE_BINOP(PyNumber_InPlaceSubtract, nb_inplace_subtract, nb_subtract, "-=")
-INPLACE_BINOP(PyNumber_InPlaceDivide, nb_inplace_divide, nb_divide, "/=")
 
 PyObject *
 PyNumber_InPlaceFloorDivide(PyObject *v, PyObject *w)

Objects/boolobject.c

@@ -106,7 +106,6 @@ static PyNumberMethods bool_as_number = {
 	0,					/* nb_add */
 	0,					/* nb_subtract */
 	0,					/* nb_multiply */
-	0,					/* nb_divide */
 	0,					/* nb_remainder */
 	0,					/* nb_divmod */
 	0,					/* nb_power */
@@ -129,7 +128,6 @@ static PyNumberMethods bool_as_number = {
 	0,					/* nb_inplace_add */
 	0,					/* nb_inplace_subtract */
 	0,					/* nb_inplace_multiply */
-	0,					/* nb_inplace_divide */
 	0,					/* nb_inplace_remainder */
 	0,					/* nb_inplace_power */
 	0,					/* nb_inplace_lshift */

Objects/classobject.c

@@ -1551,7 +1551,6 @@ BINARY(instance_rshift, "rshift", PyNumber_Rshift)
 BINARY(instance_add, "add", PyNumber_Add)
 BINARY(instance_sub, "sub", PyNumber_Subtract)
 BINARY(instance_mul, "mul", PyNumber_Multiply)
-BINARY(instance_div, "div", PyNumber_Divide)
 BINARY(instance_mod, "mod", PyNumber_Remainder)
 BINARY(instance_divmod, "divmod", PyNumber_Divmod)
 BINARY(instance_floordiv, "floordiv", PyNumber_FloorDivide)
@@ -1565,7 +1564,6 @@ BINARY_INPLACE(instance_irshift, "rshift", PyNumber_InPlaceRshift)
 BINARY_INPLACE(instance_iadd, "add", PyNumber_InPlaceAdd)
 BINARY_INPLACE(instance_isub, "sub", PyNumber_InPlaceSubtract)
 BINARY_INPLACE(instance_imul, "mul", PyNumber_InPlaceMultiply)
-BINARY_INPLACE(instance_idiv, "div", PyNumber_InPlaceDivide)
 BINARY_INPLACE(instance_imod, "mod", PyNumber_InPlaceRemainder)
 BINARY_INPLACE(instance_ifloordiv, "floordiv", PyNumber_InPlaceFloorDivide)
 BINARY_INPLACE(instance_itruediv, "truediv", PyNumber_InPlaceTrueDivide)
@@ -2054,7 +2052,6 @@ static PyNumberMethods instance_as_number = {
 	(binaryfunc)instance_add,		/* nb_add */
 	(binaryfunc)instance_sub,		/* nb_subtract */
 	(binaryfunc)instance_mul,		/* nb_multiply */
-	(binaryfunc)instance_div,		/* nb_divide */
 	(binaryfunc)instance_mod,		/* nb_remainder */
 	(binaryfunc)instance_divmod,		/* nb_divmod */
 	(ternaryfunc)instance_pow,		/* nb_power */
@@ -2077,7 +2074,6 @@ static PyNumberMethods instance_as_number = {
 	(binaryfunc)instance_iadd,		/* nb_inplace_add */
 	(binaryfunc)instance_isub,		/* nb_inplace_subtract */
 	(binaryfunc)instance_imul,		/* nb_inplace_multiply */
-	(binaryfunc)instance_idiv,		/* nb_inplace_divide */
 	(binaryfunc)instance_imod,		/* nb_inplace_remainder */
 	(ternaryfunc)instance_ipow,		/* nb_inplace_power */
 	(binaryfunc)instance_ilshift,		/* nb_inplace_lshift */

Objects/complexobject.c

@@ -381,27 +381,6 @@ complex_div(PyComplexObject *v, PyComplexObject *w)
 	return PyComplex_FromCComplex(quot);
 }
 
-static PyObject *
-complex_classic_div(PyComplexObject *v, PyComplexObject *w)
-{
-	Py_complex quot;
-
-	if (Py_DivisionWarningFlag >= 2 &&
-	    PyErr_Warn(PyExc_DeprecationWarning,
-		       "classic complex division") < 0)
-		return NULL;
-
-	PyFPE_START_PROTECT("complex_classic_div", return 0)
-	errno = 0;
-	quot = c_quot(v->cval,w->cval);
-	PyFPE_END_PROTECT(quot)
-	if (errno == EDOM) {
-		PyErr_SetString(PyExc_ZeroDivisionError, "complex division");
-		return NULL;
-	}
-	return PyComplex_FromCComplex(quot);
-}
-
 static PyObject *
 complex_remainder(PyComplexObject *v, PyComplexObject *w)
 {
@@ -948,7 +927,6 @@ static PyNumberMethods complex_as_number = {
 	(binaryfunc)complex_add, 		/* nb_add */
 	(binaryfunc)complex_sub, 		/* nb_subtract */
 	(binaryfunc)complex_mul, 		/* nb_multiply */
-	(binaryfunc)complex_classic_div,	/* nb_divide */
 	(binaryfunc)complex_remainder,		/* nb_remainder */
 	(binaryfunc)complex_divmod,		/* nb_divmod */
 	(ternaryfunc)complex_pow,		/* nb_power */
@@ -971,7 +949,6 @@ static PyNumberMethods complex_as_number = {
 	0,					/* nb_inplace_add */
 	0,					/* nb_inplace_subtract */
 	0,					/* nb_inplace_multiply*/
-	0,					/* nb_inplace_divide */
 	0,					/* nb_inplace_remainder */
 	0, 					/* nb_inplace_power */
 	0,					/* nb_inplace_lshift */

Objects/floatobject.c

@@ -641,25 +641,6 @@ float_div(PyObject *v, PyObject *w)
 	return PyFloat_FromDouble(a);
 }
 
-static PyObject *
-float_classic_div(PyObject *v, PyObject *w)
-{
-	double a,b;
-	CONVERT_TO_DOUBLE(v, a);
-	CONVERT_TO_DOUBLE(w, b);
-	if (Py_DivisionWarningFlag >= 2 &&
-	    PyErr_Warn(PyExc_DeprecationWarning, "classic float division") < 0)
-		return NULL;
-	if (b == 0.0) {
-		PyErr_SetString(PyExc_ZeroDivisionError, "float division");
-		return NULL;
-	}
-	PyFPE_START_PROTECT("divide", return 0)
-	a = a / b;
-	PyFPE_END_PROTECT(a)
-	return PyFloat_FromDouble(a);
-}
-
 static PyObject *
 float_rem(PyObject *v, PyObject *w)
 {
@@ -1128,7 +1109,6 @@ static PyNumberMethods float_as_number = {
 	(binaryfunc)float_add, /*nb_add*/
 	(binaryfunc)float_sub, /*nb_subtract*/
 	(binaryfunc)float_mul, /*nb_multiply*/
-	(binaryfunc)float_classic_div, /*nb_divide*/
 	(binaryfunc)float_rem, /*nb_remainder*/
 	(binaryfunc)float_divmod, /*nb_divmod*/
 	(ternaryfunc)float_pow, /*nb_power*/
@@ -1151,7 +1131,6 @@ static PyNumberMethods float_as_number = {
 	0,		/* nb_inplace_add */
 	0,		/* nb_inplace_subtract */
 	0,		/* nb_inplace_multiply */
-	0,		/* nb_inplace_divide */
 	0,		/* nb_inplace_remainder */
 	0, 		/* nb_inplace_power */
 	0,		/* nb_inplace_lshift */

Objects/intobject.c

@@ -580,28 +580,7 @@ int_div(PyIntObject *x, PyIntObject *y)
 	case DIVMOD_OK:
 		return PyInt_FromLong(d);
 	case DIVMOD_OVERFLOW:
-		return PyLong_Type.tp_as_number->nb_divide((PyObject *)x,
+		return PyLong_Type.tp_as_number->nb_floor_divide((PyObject *)x,
-							   (PyObject *)y);
-	default:
-		return NULL;
-	}
-}
-
-static PyObject *
-int_classic_div(PyIntObject *x, PyIntObject *y)
-{
-	long xi, yi;
-	long d, m;
-	CONVERT_TO_LONG(x, xi);
-	CONVERT_TO_LONG(y, yi);
-	if (Py_DivisionWarningFlag &&
-	    PyErr_Warn(PyExc_DeprecationWarning, "classic int division") < 0)
-		return NULL;
-	switch (i_divmod(xi, yi, &d, &m)) {
-	case DIVMOD_OK:
-		return PyInt_FromLong(d);
-	case DIVMOD_OVERFLOW:
-		return PyLong_Type.tp_as_number->nb_divide((PyObject *)x,
 							         (PyObject *)y);
 	default:
 		return NULL;
@@ -1034,7 +1013,6 @@ static PyNumberMethods int_as_number = {
 	(binaryfunc)int_add,	/*nb_add*/
 	(binaryfunc)int_sub,	/*nb_subtract*/
 	(binaryfunc)int_mul,	/*nb_multiply*/
-	(binaryfunc)int_classic_div, /*nb_divide*/
 	(binaryfunc)int_mod,	/*nb_remainder*/
 	(binaryfunc)int_divmod,	/*nb_divmod*/
 	(ternaryfunc)int_pow,	/*nb_power*/
@@ -1057,7 +1035,6 @@ static PyNumberMethods int_as_number = {
 	0,			/*nb_inplace_add*/
 	0,			/*nb_inplace_subtract*/
 	0,			/*nb_inplace_multiply*/
-	0,			/*nb_inplace_divide*/
 	0,			/*nb_inplace_remainder*/
 	0,			/*nb_inplace_power*/
 	0,			/*nb_inplace_lshift*/

Objects/longobject.c

@@ -2354,22 +2354,6 @@ long_div(PyObject *v, PyObject *w)
 	return (PyObject *)div;
 }
 
-static PyObject *
-long_classic_div(PyObject *v, PyObject *w)
-{
-	PyLongObject *a, *b, *div;
-
-	CONVERT_BINOP(v, w, &a, &b);
-	if (Py_DivisionWarningFlag &&
-	    PyErr_Warn(PyExc_DeprecationWarning, "classic long division") < 0)
-		div = NULL;
-	else if (l_divmod(a, b, &div, NULL) < 0)
-		div = NULL;
-	Py_DECREF(a);
-	Py_DECREF(b);
-	return (PyObject *)div;
-}
-
 static PyObject *
 long_true_divide(PyObject *v, PyObject *w)
 {
@@ -3130,7 +3114,6 @@ static PyNumberMethods long_as_number = {
 	(binaryfunc)	long_add,	/*nb_add*/
 	(binaryfunc)	long_sub,	/*nb_subtract*/
 	(binaryfunc)	long_mul,	/*nb_multiply*/
-	(binaryfunc)	long_classic_div, /*nb_divide*/
 	(binaryfunc)	long_mod,	/*nb_remainder*/
 	(binaryfunc)	long_divmod,	/*nb_divmod*/
 	(ternaryfunc)	long_pow,	/*nb_power*/
@@ -3153,7 +3136,6 @@ static PyNumberMethods long_as_number = {
 	0,				/* nb_inplace_add */
 	0,				/* nb_inplace_subtract */
 	0,				/* nb_inplace_multiply */
-	0,				/* nb_inplace_divide */
 	0,				/* nb_inplace_remainder */
 	0,				/* nb_inplace_power */
 	0,				/* nb_inplace_lshift */

Objects/setobject.c

@@ -1755,7 +1755,6 @@ static PyNumberMethods set_as_number = {
 	0,				/*nb_add*/
 	(binaryfunc)set_sub,		/*nb_subtract*/
 	0,				/*nb_multiply*/
-	0,				/*nb_divide*/
 	0,				/*nb_remainder*/
 	0,				/*nb_divmod*/
 	0,				/*nb_power*/
@@ -1778,7 +1777,6 @@ static PyNumberMethods set_as_number = {
 	0,				/*nb_inplace_add*/
 	(binaryfunc)set_isub,		/*nb_inplace_subtract*/
 	0,				/*nb_inplace_multiply*/
-	0,				/*nb_inplace_divide*/
 	0,				/*nb_inplace_remainder*/
 	0,				/*nb_inplace_power*/
 	0,				/*nb_inplace_lshift*/
@@ -1867,7 +1865,6 @@ static PyNumberMethods frozenset_as_number = {
 	0,				/*nb_add*/
 	(binaryfunc)set_sub,		/*nb_subtract*/
 	0,				/*nb_multiply*/
-	0,				/*nb_divide*/
 	0,				/*nb_remainder*/
 	0,				/*nb_divmod*/
 	0,				/*nb_power*/

Objects/stringobject.c

@@ -3408,7 +3408,6 @@ static PyNumberMethods string_as_number = {
 	0,			/*nb_add*/
 	0,			/*nb_subtract*/
 	0,			/*nb_multiply*/
-	0, 			/*nb_divide*/
 	string_mod,		/*nb_remainder*/
 };
 

Objects/typeobject.c

@@ -3014,7 +3014,6 @@ inherit_slots(PyTypeObject *type, PyTypeObject *base)
 		COPYNUM(nb_add);
 		COPYNUM(nb_subtract);
 		COPYNUM(nb_multiply);
-		COPYNUM(nb_divide);
 		COPYNUM(nb_remainder);
 		COPYNUM(nb_divmod);
 		COPYNUM(nb_power);
@@ -3037,7 +3036,6 @@ inherit_slots(PyTypeObject *type, PyTypeObject *base)
 		COPYNUM(nb_inplace_add);
 		COPYNUM(nb_inplace_subtract);
 		COPYNUM(nb_inplace_multiply);
-		COPYNUM(nb_inplace_divide);
 		COPYNUM(nb_inplace_remainder);
 		COPYNUM(nb_inplace_power);
 		COPYNUM(nb_inplace_lshift);
@@ -3045,12 +3043,11 @@ inherit_slots(PyTypeObject *type, PyTypeObject *base)
 		COPYNUM(nb_inplace_and);
 		COPYNUM(nb_inplace_xor);
 		COPYNUM(nb_inplace_or);
-		if (base->tp_flags & Py_TPFLAGS_CHECKTYPES) {
 		COPYNUM(nb_true_divide);
 		COPYNUM(nb_floor_divide);
 		COPYNUM(nb_inplace_true_divide);
 		COPYNUM(nb_inplace_floor_divide);
-		}
+		/* XXX(nnorwitz): we don't need to check flags do we? */
 		if (base->tp_flags & Py_TPFLAGS_HAVE_INDEX) {
 			COPYNUM(nb_index);
 		}
@@ -4291,7 +4288,6 @@ slot_mp_ass_subscript(PyObject *self, PyObject *key, PyObject *value)
 SLOT1BIN(slot_nb_add, nb_add, "__add__", "__radd__")
 SLOT1BIN(slot_nb_subtract, nb_subtract, "__sub__", "__rsub__")
 SLOT1BIN(slot_nb_multiply, nb_multiply, "__mul__", "__rmul__")
-SLOT1BIN(slot_nb_divide, nb_divide, "__div__", "__rdiv__")
 SLOT1BIN(slot_nb_remainder, nb_remainder, "__mod__", "__rmod__")
 SLOT1BIN(slot_nb_divmod, nb_divmod, "__divmod__", "__rdivmod__")
 
@@ -4470,7 +4466,6 @@ SLOT0(slot_nb_hex, "__hex__")
 SLOT1(slot_nb_inplace_add, "__iadd__", PyObject *, "O")
 SLOT1(slot_nb_inplace_subtract, "__isub__", PyObject *, "O")
 SLOT1(slot_nb_inplace_multiply, "__imul__", PyObject *, "O")
-SLOT1(slot_nb_inplace_divide, "__idiv__", PyObject *, "O")
 SLOT1(slot_nb_inplace_remainder, "__imod__", PyObject *, "O")
 SLOT1(slot_nb_inplace_power, "__ipow__", PyObject *, "O")
 SLOT1(slot_nb_inplace_lshift, "__ilshift__", PyObject *, "O")
@@ -5077,10 +5072,6 @@ static slotdef slotdefs[] = {
 		"*"),
 	RBINSLOT("__rmul__", nb_multiply, slot_nb_multiply,
 		 "*"),
-	BINSLOT("__div__", nb_divide, slot_nb_divide,
-		"/"),
-	RBINSLOT("__rdiv__", nb_divide, slot_nb_divide,
-		 "/"),
 	BINSLOT("__mod__", nb_remainder, slot_nb_remainder,
 		"%"),
 	RBINSLOT("__rmod__", nb_remainder, slot_nb_remainder,
@@ -5130,8 +5121,6 @@ static slotdef slotdefs[] = {
 	       wrap_binaryfunc, "-"),
 	IBSLOT("__imul__", nb_inplace_multiply, slot_nb_inplace_multiply,
 	       wrap_binaryfunc, "*"),
-	IBSLOT("__idiv__", nb_inplace_divide, slot_nb_inplace_divide,
-	       wrap_binaryfunc, "/"),
 	IBSLOT("__imod__", nb_inplace_remainder, slot_nb_inplace_remainder,
 	       wrap_binaryfunc, "%"),
 	IBSLOT("__ipow__", nb_inplace_power, slot_nb_inplace_power,

Objects/unicodeobject.c

@@ -6445,7 +6445,6 @@ static PyNumberMethods unicode_as_number = {
 	0,				/*nb_add*/
 	0,				/*nb_subtract*/
 	0,				/*nb_multiply*/
-	0,				/*nb_divide*/
 	unicode_mod,			/*nb_remainder*/
 };
 

Objects/weakrefobject.c

@@ -471,7 +471,6 @@ proxy_compare(PyObject *proxy, PyObject *v)
 WRAP_BINARY(proxy_add, PyNumber_Add)
 WRAP_BINARY(proxy_sub, PyNumber_Subtract)
 WRAP_BINARY(proxy_mul, PyNumber_Multiply)
-WRAP_BINARY(proxy_div, PyNumber_Divide)
 WRAP_BINARY(proxy_mod, PyNumber_Remainder)
 WRAP_BINARY(proxy_divmod, PyNumber_Divmod)
 WRAP_TERNARY(proxy_pow, PyNumber_Power)
@@ -490,7 +489,6 @@ WRAP_UNARY(proxy_float, PyNumber_Float)
 WRAP_BINARY(proxy_iadd, PyNumber_InPlaceAdd)
 WRAP_BINARY(proxy_isub, PyNumber_InPlaceSubtract)
 WRAP_BINARY(proxy_imul, PyNumber_InPlaceMultiply)
-WRAP_BINARY(proxy_idiv, PyNumber_InPlaceDivide)
 WRAP_BINARY(proxy_imod, PyNumber_InPlaceRemainder)
 WRAP_TERNARY(proxy_ipow, PyNumber_InPlacePower)
 WRAP_BINARY(proxy_ilshift, PyNumber_InPlaceLshift)
@@ -591,7 +589,6 @@ static PyNumberMethods proxy_as_number = {
     (binaryfunc)proxy_add,      /*nb_add*/
     (binaryfunc)proxy_sub,      /*nb_subtract*/
     (binaryfunc)proxy_mul,      /*nb_multiply*/
-    (binaryfunc)proxy_div,      /*nb_divide*/
     (binaryfunc)proxy_mod,      /*nb_remainder*/
     (binaryfunc)proxy_divmod,   /*nb_divmod*/
     (ternaryfunc)proxy_pow,     /*nb_power*/
@@ -614,7 +611,6 @@ static PyNumberMethods proxy_as_number = {
     (binaryfunc)proxy_iadd,     /*nb_inplace_add*/
     (binaryfunc)proxy_isub,     /*nb_inplace_subtract*/
     (binaryfunc)proxy_imul,     /*nb_inplace_multiply*/
-    (binaryfunc)proxy_idiv,     /*nb_inplace_divide*/
     (binaryfunc)proxy_imod,     /*nb_inplace_remainder*/
     (ternaryfunc)proxy_ipow,    /*nb_inplace_power*/
     (binaryfunc)proxy_ilshift,  /*nb_inplace_lshift*/

PC/_winreg.c

@@ -431,7 +431,6 @@ static PyNumberMethods PyHKEY_NumberMethods =
 	PyHKEY_binaryFailureFunc,	/* nb_add */
 	PyHKEY_binaryFailureFunc,	/* nb_subtract */
 	PyHKEY_binaryFailureFunc,	/* nb_multiply */
-	PyHKEY_binaryFailureFunc,	/* nb_divide */
 	PyHKEY_binaryFailureFunc,	/* nb_remainder */
 	PyHKEY_binaryFailureFunc,	/* nb_divmod */
 	PyHKEY_ternaryFailureFunc,	/* nb_power */