Fix marshal's incorrect handling of subclasses of builtin types (backport candidate).

raymond.hettinger · raymond.hettinger · commit 8520f4c0f105 · 2007-11-07T01:13:09.000Z
git-svn-id: http://svn.python.org/projects/python/trunk@58893 6015fed2-1504-0410-9fe1-9d1591cc4771
diff --git a/Doc/library/marshal.rst b/Doc/library/marshal.rst
@@ -44,12 +44,6 @@ and dictionaries are only supported as long as the values contained therein are
 themselves supported; and recursive lists and dictionaries should not be written
 (they will cause infinite loops).
 
-.. warning::
-
-   Some unsupported types such as subclasses of builtins will appear to marshal
-   and unmarshal correctly, but in fact, their type will change and the
-   additional subclass functionality and instance attributes will be lost.
-
 .. warning::
    
    On machines where C's ``long int`` type has more than 32 bits (such as the
diff --git a/Lib/test/test_marshal.py b/Lib/test/test_marshal.py
@@ -244,6 +244,17 @@ def test_recursion_limit(self):
         last.append([0])
         self.assertRaises(ValueError, marshal.dumps, head)
 
+    def test_exact_type_match(self):
+        # Former bug:
+        #   >>> class Int(int): pass
+        #   >>> type(loads(dumps(Int())))
+        #   <type 'int'>
+        for typ in (int, long, float, complex, tuple, list, dict, set, frozenset):
+            # Note: str and unicode sublclasses are not tested because they get handled
+            # by marshal's routines for objects supporting the buffer API.
+            subtyp = type('subtyp', (typ,), {})
+            self.assertRaises(ValueError, marshal.dumps, subtyp())
+
 def test_main():
     test_support.run_unittest(IntTestCase,
                               FloatTestCase,
diff --git a/Misc/NEWS b/Misc/NEWS
@@ -812,6 +812,10 @@ Library
 Extension Modules
 -----------------
 
+- Marshal.dumps() now expects exact type matches for int, long, float, complex,
+  tuple, list, dict, set, and frozenset.  Formerly, it would silently miscode
+  subclasses of those types.  Now, it raises a ValueError instead.
+
 - Patch #1388440: Add set_completion_display_matches_hook and
   get_completion_type to readline.
 
diff --git a/Python/marshal.c b/Python/marshal.c
@@ -144,7 +144,7 @@ w_object(PyObject *v, WFILE *p)
 	else if (v == Py_True) {
 	        w_byte(TYPE_TRUE, p);
 	}
-	else if (PyInt_Check(v)) {
+	else if (PyInt_CheckExact(v)) {
 		long x = PyInt_AS_LONG((PyIntObject *)v);
 #if SIZEOF_LONG > 4
 		long y = Py_ARITHMETIC_RIGHT_SHIFT(long, x, 31);
@@ -159,7 +159,7 @@ w_object(PyObject *v, WFILE *p)
 			w_long(x, p);
 		}
 	}
-	else if (PyLong_Check(v)) {
+	else if (PyLong_CheckExact(v)) {
 		PyLongObject *ob = (PyLongObject *)v;
 		w_byte(TYPE_LONG, p);
 		n = ob->ob_size;
@@ -169,7 +169,7 @@ w_object(PyObject *v, WFILE *p)
 		for (i = 0; i < n; i++)
 			w_short(ob->ob_digit[i], p);
 	}
-	else if (PyFloat_Check(v)) {
+	else if (PyFloat_CheckExact(v)) {
 		if (p->version > 1) {
 			unsigned char buf[8];
 			if (_PyFloat_Pack8(PyFloat_AsDouble(v), 
@@ -190,7 +190,7 @@ w_object(PyObject *v, WFILE *p)
 		}
 	}
 #ifndef WITHOUT_COMPLEX
-	else if (PyComplex_Check(v)) {
+	else if (PyComplex_CheckExact(v)) {
 		if (p->version > 1) {
 			unsigned char buf[8];
 			if (_PyFloat_Pack8(PyComplex_RealAsDouble(v),
@@ -236,7 +236,7 @@ w_object(PyObject *v, WFILE *p)
 		}
 	}
 #endif
-	else if (PyString_Check(v)) {
+	else if (PyString_CheckExact(v)) {
 		if (p->strings && PyString_CHECK_INTERNED(v)) {
 			PyObject *o = PyDict_GetItem(p->strings, v);
 			if (o) {
@@ -273,7 +273,7 @@ w_object(PyObject *v, WFILE *p)
 		w_string(PyString_AS_STRING(v), (int)n, p);
 	}
 #ifdef Py_USING_UNICODE
-	else if (PyUnicode_Check(v)) {
+	else if (PyUnicode_CheckExact(v)) {
 	        PyObject *utf8;
 		utf8 = PyUnicode_AsUTF8String(v);
 		if (utf8 == NULL) {
@@ -293,23 +293,23 @@ w_object(PyObject *v, WFILE *p)
 		Py_DECREF(utf8);
 	}
 #endif
-	else if (PyTuple_Check(v)) {
+	else if (PyTuple_CheckExact(v)) {
 		w_byte(TYPE_TUPLE, p);
 		n = PyTuple_Size(v);
 		w_long((long)n, p);
 		for (i = 0; i < n; i++) {
 			w_object(PyTuple_GET_ITEM(v, i), p);
 		}
 	}
-	else if (PyList_Check(v)) {
+	else if (PyList_CheckExact(v)) {
 		w_byte(TYPE_LIST, p);
 		n = PyList_GET_SIZE(v);
 		w_long((long)n, p);
 		for (i = 0; i < n; i++) {
 			w_object(PyList_GET_ITEM(v, i), p);
 		}
 	}
-	else if (PyDict_Check(v)) {
+	else if (PyDict_CheckExact(v)) {
 		Py_ssize_t pos;
 		PyObject *key, *value;
 		w_byte(TYPE_DICT, p);
@@ -321,7 +321,7 @@ w_object(PyObject *v, WFILE *p)
 		}
 		w_object((PyObject *)NULL, p);
 	}
-	else if (PyAnySet_Check(v)) {
+	else if (PyAnySet_CheckExact(v)) {
 		PyObject *value, *it;
 
 		if (PyObject_TypeCheck(v, &PySet_Type))

Original file line number	Diff line number	Diff line change
`@@ -144,7 +144,7 @@ w_object(PyObject v, WFILE p)`
`144`	`144`	`else if (v == Py_True) {`
`145`	`145`	`w_byte(TYPE_TRUE, p);`
`146`	`146`	`}`
`147`		`- else if (PyInt_Check(v)) {`
	`147`	`+ else if (PyInt_CheckExact(v)) {`
`148`	`148`	`long x = PyInt_AS_LONG((PyIntObject *)v);`
`149`	`149`	`#if SIZEOF_LONG > 4`
`150`	`150`	`long y = Py_ARITHMETIC_RIGHT_SHIFT(long, x, 31);`
`@@ -159,7 +159,7 @@ w_object(PyObject v, WFILE p)`
`159`	`159`	`w_long(x, p);`
`160`	`160`	`}`
`161`	`161`	`}`
`162`		`- else if (PyLong_Check(v)) {`
	`162`	`+ else if (PyLong_CheckExact(v)) {`
`163`	`163`	`PyLongObject ob = (PyLongObject )v;`
`164`	`164`	`w_byte(TYPE_LONG, p);`
`165`	`165`	`n = ob->ob_size;`
`@@ -169,7 +169,7 @@ w_object(PyObject v, WFILE p)`
`169`	`169`	`for (i = 0; i < n; i++)`
`170`	`170`	`w_short(ob->ob_digit[i], p);`
`171`	`171`	`}`
`172`		`- else if (PyFloat_Check(v)) {`
	`172`	`+ else if (PyFloat_CheckExact(v)) {`
`173`	`173`	`if (p->version > 1) {`
`174`	`174`	`unsigned char buf[8];`
`175`	`175`	`if (_PyFloat_Pack8(PyFloat_AsDouble(v),`
`@@ -190,7 +190,7 @@ w_object(PyObject v, WFILE p)`
`190`	`190`	`}`
`191`	`191`	`}`
`192`	`192`	`#ifndef WITHOUT_COMPLEX`
`193`		`- else if (PyComplex_Check(v)) {`
	`193`	`+ else if (PyComplex_CheckExact(v)) {`
`194`	`194`	`if (p->version > 1) {`
`195`	`195`	`unsigned char buf[8];`
`196`	`196`	`if (_PyFloat_Pack8(PyComplex_RealAsDouble(v),`
`@@ -236,7 +236,7 @@ w_object(PyObject v, WFILE p)`
`236`	`236`	`}`
`237`	`237`	`}`
`238`	`238`	`#endif`
`239`		`- else if (PyString_Check(v)) {`
	`239`	`+ else if (PyString_CheckExact(v)) {`
`240`	`240`	`if (p->strings && PyString_CHECK_INTERNED(v)) {`
`241`	`241`	`PyObject *o = PyDict_GetItem(p->strings, v);`
`242`	`242`	`if (o) {`
`@@ -273,7 +273,7 @@ w_object(PyObject v, WFILE p)`
`273`	`273`	`w_string(PyString_AS_STRING(v), (int)n, p);`
`274`	`274`	`}`
`275`	`275`	`#ifdef Py_USING_UNICODE`
`276`		`- else if (PyUnicode_Check(v)) {`
	`276`	`+ else if (PyUnicode_CheckExact(v)) {`
`277`	`277`	`PyObject *utf8;`
`278`	`278`	`utf8 = PyUnicode_AsUTF8String(v);`
`279`	`279`	`if (utf8 == NULL) {`
`@@ -293,23 +293,23 @@ w_object(PyObject v, WFILE p)`
`293`	`293`	`Py_DECREF(utf8);`
`294`	`294`	`}`
`295`	`295`	`#endif`
`296`		`- else if (PyTuple_Check(v)) {`
	`296`	`+ else if (PyTuple_CheckExact(v)) {`
`297`	`297`	`w_byte(TYPE_TUPLE, p);`
`298`	`298`	`n = PyTuple_Size(v);`
`299`	`299`	`w_long((long)n, p);`
`300`	`300`	`for (i = 0; i < n; i++) {`
`301`	`301`	`w_object(PyTuple_GET_ITEM(v, i), p);`
`302`	`302`	`}`
`303`	`303`	`}`
`304`		`- else if (PyList_Check(v)) {`
	`304`	`+ else if (PyList_CheckExact(v)) {`
`305`	`305`	`w_byte(TYPE_LIST, p);`
`306`	`306`	`n = PyList_GET_SIZE(v);`
`307`	`307`	`w_long((long)n, p);`
`308`	`308`	`for (i = 0; i < n; i++) {`
`309`	`309`	`w_object(PyList_GET_ITEM(v, i), p);`
`310`	`310`	`}`
`311`	`311`	`}`
`312`		`- else if (PyDict_Check(v)) {`
	`312`	`+ else if (PyDict_CheckExact(v)) {`
`313`	`313`	`Py_ssize_t pos;`
`314`	`314`	`PyObject key, value;`
`315`	`315`	`w_byte(TYPE_DICT, p);`
`@@ -321,7 +321,7 @@ w_object(PyObject v, WFILE p)`
`321`	`321`	`}`
`322`	`322`	`w_object((PyObject *)NULL, p);`
`323`	`323`	`}`
`324`		`- else if (PyAnySet_Check(v)) {`
	`324`	`+ else if (PyAnySet_CheckExact(v)) {`
`325`	`325`	`PyObject value, it;`
`326`	`326`
`327`	`327`	`if (PyObject_TypeCheck(v, &PySet_Type))`