Merged the int/long unification branch, by very crude means (sorry Thomas!).

I banged on the code (beyond what's in that branch) to make fewer tests fail;
the only tests that fail now are:
  test_descr -- can't pickle ints?!
  test_pickletools -- ???
  test_socket -- See python.org/sf/1619659
  test_sqlite -- ???
I'll deal with those later.

Lib/pickle.py

@@ -456,9 +456,29 @@ class Pickler:
                 return
         # Text pickle, or int too big to fit in signed 4-byte format.
         self.write(INT + repr(obj) + '\n')
-    dispatch[IntType] = save_int
+    # XXX save_int is merged into save_long
+    # dispatch[IntType] = save_int
 
     def save_long(self, obj, pack=struct.pack):
+        if self.bin:
+            # If the int is small enough to fit in a signed 4-byte 2's-comp
+            # format, we can store it more efficiently than the general
+            # case.
+            # First one- and two-byte unsigned ints:
+            if obj >= 0:
+                if obj <= 0xff:
+                    self.write(BININT1 + chr(obj))
+                    return
+                if obj <= 0xffff:
+                    self.write("%c%c%c" % (BININT2, obj&0xff, obj>>8))
+                    return
+            # Next check for 4-byte signed ints:
+            high_bits = obj >> 31  # note that Python shift sign-extends
+            if high_bits == 0 or high_bits == -1:
+                # All high bits are copies of bit 2**31, so the value
+                # fits in a 4-byte signed int.
+                self.write(BININT + pack("<i", obj))
+                return
         if self.proto >= 2:
             bytes = encode_long(obj)
             n = len(bytes)

Lib/test/output/test_class

@@ -44,7 +44,7 @@ __neg__: ()
 __pos__: ()
 __abs__: ()
 __int__: ()
-__long__: ()
+__int__: ()
 __float__: ()
 __oct__: ()
 __hex__: ()

Lib/test/test_builtin.py

@@ -1081,10 +1081,12 @@ class BuiltinTest(unittest.TestCase):
 
         self.assertEqual(long(Foo0()), 42L)
         self.assertEqual(long(Foo1()), 42L)
-        self.assertEqual(long(Foo2()), 42L)
+	# XXX invokes __int__ now
+        # self.assertEqual(long(Foo2()), 42L)
         self.assertEqual(long(Foo3()), 0)
-        self.assertEqual(long(Foo4()), 42)
-        self.assertRaises(TypeError, long, Foo5())
+	# XXX likewise
+        # self.assertEqual(long(Foo4()), 42)
+        # self.assertRaises(TypeError, long, Foo5())
 
     def test_map(self):
         self.assertEqual(

Lib/test/test_descr.py

@@ -430,13 +430,6 @@ def ints():
         pass
     else:
         raise TestFailed, "NotImplemented should have caused TypeError"
-    import sys
-    try:
-        C(sys.maxint+1)
-    except OverflowError:
-        pass
-    else:
-        raise TestFailed, "should have raised OverflowError"
 
 def longs():
     if verbose: print "Testing long operations..."

Lib/test/test_marshal.py

@@ -204,7 +204,7 @@ class BugsTestCase(unittest.TestCase):
     def test_patch_873224(self):
         self.assertRaises(Exception, marshal.loads, '0')
         self.assertRaises(Exception, marshal.loads, 'f')
-        self.assertRaises(Exception, marshal.loads, marshal.dumps(5L)[:-1])
+        self.assertRaises(Exception, marshal.loads, marshal.dumps(2**65L)[:-1])
 
     def test_version_argument(self):
         # Python 2.4.0 crashes for any call to marshal.dumps(x, y)

Lib/test/test_optparse.py

@@ -1600,7 +1600,7 @@ class TestParseNumber(BaseTest):
         self.assertRaises(
             _parse_num, ("0xOoops", long), {},
             ValueError,
-            re.compile(r"invalid literal for long().*: '?0xOoops'?"))
+            re.compile(r"invalid literal for int().*: '?0xOoops'?"))
 
     def test_parse_num_ok(self):
         self.assertEqual(_parse_num("0", int), 0)
@@ -1618,9 +1618,9 @@ class TestParseNumber(BaseTest):
         self.assertParseFail(["-n008"],
                              "option -n: invalid integer value: '008'")
         self.assertParseFail(["-l0b0123"],
-                             "option -l: invalid long integer value: '0b0123'")
+                             "option -l: invalid integer value: '0b0123'")
         self.assertParseFail(["-l", "0x12x"],
-                             "option -l: invalid long integer value: '0x12x'")
+                             "option -l: invalid integer value: '0x12x'")
 
 
 def _testclasses():