PyPycLoader can't read cached .pyc files

Lib/importlib/abc.py

 """Abstract base classes related to import."""
 from . import _bootstrap
 from . import machinery
 try:
     import _frozen_importlib
 except ImportError as exc:
     if exc.name != '_frozen_importlib':
         raise
     _frozen_importlib = None
 import abc
@@ skipping 264 matching lines @@
             try:
                 magic = data[:4]
                 if len(magic) < 4:
                     raise ImportError(
                         "bad magic number in {}".format(fullname),
                         name=fullname, path=bytecode_path)
                 raw_timestamp = data[4:8]
                 if len(raw_timestamp) < 4:
                     raise EOFError("bad timestamp in {}".format(fullname))
                 pyc_timestamp = _bootstrap._r_long(raw_timestamp)
-                bytecode = data[8:]
+                raw_file_size = data[8:12]
+                if len(raw_file_size) < 4:
+                    raise EOFError("bad file size in {}".format(fullname))
+                file_size = _bootstrap._r_long(raw_file_size)
+                bytecode = data[12:]
                 # Verify that the magic number is valid.
                 if imp.get_magic() != magic:
                     raise ImportError(
                         "bad magic number in {}".format(fullname),
                         name=fullname, path=bytecode_path)
                 # Verify that the bytecode is not stale (only matters when
                 # there is source to fall back on.
                 if source_timestamp:
                     if pyc_timestamp < source_timestamp:
                         raise ImportError("bytecode is stale", name=fullname,
@@ skipping 13 matching lines @@
                               name=fullname)
         # Use the source.
         source_path = self.source_path(fullname)
         if source_path is None:
             message = "a source path must exist to load {0}".format(fullname)
             raise ImportError(message, name=fullname)
         source = self.get_data(source_path)
         code_object = compile(source, source_path, 'exec', dont_inherit=True)
         # Generate bytecode and write it out.
         if not sys.dont_write_bytecode:
+            bytecode = marshal.dumps(code_object)
             data = bytearray(imp.get_magic())
             data.extend(_bootstrap._w_long(source_timestamp))
-            data.extend(marshal.dumps(code_object))
+            data.extend(_bootstrap._w_long(len(bytecode)))

[brett.cannon, 2012/06/28 17:08:02]

It is the length of the source, not the bytecode; see
Lib/importlib/_bootstrap.py:SourceLoader.get_code() for how importlib already
does it.

+            data.extend(bytecode)
             self.write_bytecode(fullname, data)
         return code_object
 
     @abc.abstractmethod
     def source_mtime(self, fullname):
         """Abstract method. Accepts a str filename and returns an int
         modification time for the source of the module."""
         raise NotImplementedError
 
     @abc.abstractmethod
     def bytecode_path(self, fullname):
         """Abstract method. Accepts a str filename and returns the str pathname
         to the bytecode for the module."""
         raise NotImplementedError
 
     @abc.abstractmethod
     def write_bytecode(self, fullname, bytecode):
         """Abstract method.  Accepts a str filename and bytes object
         representing the bytecode for the module.  Returns a boolean
         representing whether the bytecode was written or not."""
         raise NotImplementedError