Check the type of values returned by __int__, __float__, __long__,

__oct__, and __hex__.  Raise TypeError if an invalid type is
returned.  Note that PyNumber_Int and PyNumber_Long can still
return ints or longs.  Fixes SF bug #966618.

diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py
index a37f2a47e37f6aacbbdd7b62e8e360ec64b38c34..a564f73985ad0efb26b7c9cb4bfcfb62f5bb47da 100644 (file)
--- a/Lib/test/test_class.py
+++ b/Lib/test/test_class.py
@@ -43,11 +43,6 @@ testmeths = [
     "neg",
     "pos",
     "abs",
-    "int",
-    "long",
-    "float",
-    "oct",
-    "hex",
 
 # generic operations
     "init",
@@ -58,6 +53,11 @@ testmeths = [
 #    "hash",
 #    "str",
 #    "repr",
+#    "int",
+#    "long",
+#    "float",
+#    "oct",
+#    "hex",
 
 # These are separate because they can influence the test of other methods.
 #    "getattr",
@@ -81,6 +81,26 @@ class AllTests:
         print "__repr__:", args
         return "AllTests"
 
+    def __int__(self, *args):
+        print "__int__:", args
+        return 1
+
+    def __float__(self, *args):
+        print "__float__:", args
+        return 1.0
+
+    def __long__(self, *args):
+        print "__long__:", args
+        return 1L
+
+    def __oct__(self, *args):
+        print "__oct__:", args
+        return '01'
+
+    def __hex__(self, *args):
+        print "__hex__:", args
+        return '0x1'
+
     def __cmp__(self, *args):
         print "__cmp__:", args
         return 0
@@ -195,21 +215,11 @@ else:
 -testme
 +testme
 abs(testme)
-if sys.platform[:4] != 'java':
-    int(testme)
-    long(testme)
-    float(testme)
-    oct(testme)
-    hex(testme)
-else:
-    # Jython enforced that these methods return
-    # a value of the expected type.
-    print "__int__: ()"
-    print "__long__: ()"
-    print "__float__: ()"
-    print "__oct__: ()"
-    print "__hex__: ()"
-
+int(testme)
+long(testme)
+float(testme)
+oct(testme)
+hex(testme)
 
 # And the rest...
 
@@ -254,6 +264,54 @@ testme.eggs = "spam, spam, spam and ham"
 del testme.cardinal
 
 
+# return values of some method are type-checked
+class BadTypeClass:
+    def __int__(self):
+        return None
+    __float__ = __int__
+    __long__ = __int__
+    __str__ = __int__
+    __repr__ = __int__
+    __oct__ = __int__
+    __hex__ = __int__
+
+def check_exc(stmt, exception):
+    """Raise TestFailed if executing 'stmt' does not raise 'exception'
+    """
+    try:
+        exec stmt
+    except exception:
+        pass
+    else:
+        raise TestFailed, "%s should raise %s" % (stmt, exception)
+
+check_exc("int(BadTypeClass())", TypeError)
+check_exc("float(BadTypeClass())", TypeError)
+check_exc("long(BadTypeClass())", TypeError)
+check_exc("str(BadTypeClass())", TypeError)
+check_exc("repr(BadTypeClass())", TypeError)
+check_exc("oct(BadTypeClass())", TypeError)
+check_exc("hex(BadTypeClass())", TypeError)
+
+# mixing up ints and longs is okay
+class IntLongMixClass:
+    def __int__(self):
+        return 0L
+
+    def __long__(self):
+        return 0
+
+try:
+    int(IntLongMixClass())
+except TypeError:
+    raise TestFailed, "TypeError should not be raised"
+
+try:
+    long(IntLongMixClass())
+except TypeError:
+    raise TestFailed, "TypeError should not be raised"
+
+
 # Test correct errors from hash() on objects with comparisons but no __hash__
 
 class C0:
@@ -264,17 +322,12 @@ hash(C0()) # This should work; the next two should raise TypeError
 class C1:
     def __cmp__(self, other): return 0
 
-try: hash(C1())
-except TypeError: pass
-else: raise TestFailed, "hash(C1()) should raise an exception"
+check_exc("hash(C1())", TypeError)
 
 class C2:
     def __eq__(self, other): return 1
 
-try: hash(C2())
-except TypeError: pass
-else: raise TestFailed, "hash(C2()) should raise an exception"
-
+check_exc("hash(C2())", TypeError)
 
 # Test for SF bug 532646
 

diff --git a/Misc/NEWS b/Misc/NEWS
index 29adb457b90be8ea0249bd6a3d2aa65058380094..c3955762af2266890ed282a948a2697227ae2e65 100644 (file)
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -28,6 +28,11 @@ Core and builtins
 
 - Compiler now treats None as a constant.
 
+- The type of values returned by __int__, __float__, __long__,
+  __oct__, and __hex__ are now checked.  Returning an invalid type
+  will cause a TypeError to be raised.  This matches the behavior of
+  Jython.
+
 Extension modules
 -----------------
 

diff --git a/Objects/abstract.c b/Objects/abstract.c
index 01e3e4c8bbb95ada64bfe537054f5d5f9b4819ec..bc36c6fdd4311ee3975f721162d8e01561269a44 100644 (file)
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -965,8 +965,17 @@ PyNumber_Int(PyObject *o)
                                         10);
 #endif
        m = o->ob_type->tp_as_number;
-       if (m && m->nb_int)
-               return m->nb_int(o);
+       if (m && m->nb_int) {
+               PyObject *res = m->nb_int(o);
+               if (res && (!PyInt_Check(res) && !PyLong_Check(res))) {
+                       PyErr_Format(PyExc_TypeError,
+                                    "__int__ returned non-int (type %.200s)",
+                                    res->ob_type->tp_name);
+                       Py_DECREF(res);
+                       return NULL;
+               }
+               return res;
+       }
        if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len))
                return int_from_string((char*)buffer, buffer_len);
 
@@ -1022,8 +1031,17 @@ PyNumber_Long(PyObject *o)
                                          10);
 #endif
        m = o->ob_type->tp_as_number;
-       if (m && m->nb_long)
-               return m->nb_long(o);
+       if (m && m->nb_long) {
+               PyObject *res = m->nb_long(o);
+               if (res && (!PyInt_Check(res) && !PyLong_Check(res))) {
+                       PyErr_Format(PyExc_TypeError,
+                                    "__long__ returned non-long (type %.200s)",
+                                    res->ob_type->tp_name);
+                       Py_DECREF(res);
+                       return NULL;
+               }
+               return res;
+       }
        if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len))
                return long_from_string(buffer, buffer_len);
 
@@ -1047,8 +1065,17 @@ PyNumber_Float(PyObject *o)
        }
        if (!PyString_Check(o)) {
                m = o->ob_type->tp_as_number;
-               if (m && m->nb_float)
-                       return m->nb_float(o);
+               if (m && m->nb_float) {
+                       PyObject *res = m->nb_float(o);
+                       if (res && !PyFloat_Check(res)) {
+                               PyErr_Format(PyExc_TypeError,
+                                 "__float__ returned non-float (type %.200s)",
+                                 res->ob_type->tp_name);
+                               Py_DECREF(res);
+                               return NULL;
+                       }
+                       return res;
+               }
        }
        return PyFloat_FromString(o, NULL);
 }

diff --git a/Objects/intobject.c b/Objects/intobject.c
index bdf7da364f37eb77f1c160e1f6cd000356e59fef..f52ef07e22452b970d15ef8208a18ad9a956375b 100644 (file)
--- a/Objects/intobject.c
+++ b/Objects/intobject.c
@@ -948,12 +948,6 @@ int_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
        if (tmp == NULL)
                return NULL;
        if (!PyInt_Check(tmp)) {
-               if (!PyLong_Check(tmp)) {
-                       PyErr_SetString(PyExc_ValueError,
-                                       "value can't be converted to int");
-                       Py_DECREF(tmp);
-                       return NULL;
-               }
                ival = PyLong_AsLong(tmp);
                if (ival == -1 && PyErr_Occurred()) {
                        Py_DECREF(tmp);

diff --git a/Python/bltinmodule.c b/Python/bltinmodule.c
index 10e59c958047cbe4c92407b2d2f274a92058c1db..4143681b8a318ecfa88ab9dd869cf06647606e95 100644 (file)
--- a/Python/bltinmodule.c
+++ b/Python/bltinmodule.c
@@ -962,6 +962,7 @@ static PyObject *
 builtin_hex(PyObject *self, PyObject *v)
 {
        PyNumberMethods *nb;
+       PyObject *res;
 
        if ((nb = v->ob_type->tp_as_number) == NULL ||
            nb->nb_hex == NULL) {
@@ -969,7 +970,15 @@ builtin_hex(PyObject *self, PyObject *v)
                           "hex() argument can't be converted to hex");
                return NULL;
        }
-       return (*nb->nb_hex)(v);
+       res = (*nb->nb_hex)(v);
+       if (res && !PyString_Check(res)) {
+               PyErr_Format(PyExc_TypeError,
+                            "__hex__ returned non-string (type %.200s)",
+                            res->ob_type->tp_name);
+               Py_DECREF(res);
+               return NULL;
+       }
+       return res;
 }
 
 PyDoc_STRVAR(hex_doc,
@@ -1178,6 +1187,7 @@ static PyObject *
 builtin_oct(PyObject *self, PyObject *v)
 {
        PyNumberMethods *nb;
+       PyObject *res;
 
        if (v == NULL || (nb = v->ob_type->tp_as_number) == NULL ||
            nb->nb_oct == NULL) {
@@ -1185,7 +1195,15 @@ builtin_oct(PyObject *self, PyObject *v)
                           "oct() argument can't be converted to oct");
                return NULL;
        }
-       return (*nb->nb_oct)(v);
+       res = (*nb->nb_oct)(v);
+       if (res && !PyString_Check(res)) {
+               PyErr_Format(PyExc_TypeError,
+                            "__oct__ returned non-string (type %.200s)",
+                            res->ob_type->tp_name);
+               Py_DECREF(res);
+               return NULL;
+       }
+       return res;
 }
 
 PyDoc_STRVAR(oct_doc,