Stop storing the marshaled data in spec.loader_state.

Author: ericsnowcurrently

Lib/importlib/_bootstrap.py

@@ -838,7 +838,6 @@ def _fix_up_module(cls, module):
             assert _imp.is_frozen_package(module.__name__) == ispkg, ispkg
             filename, pkgdir = cls._resolve_filename(origname, spec.name, ispkg)
             spec.loader_state = state = type(sys.implementation)(
-                data=None,
                 filename=filename,
                 origname=origname,
             )
@@ -866,8 +865,7 @@ def _fix_up_module(cls, module):
             # These checks ensure that _fix_up_module() is only called
             # in the right places.
             assert state is not None
-            assert sorted(vars(state)) == ['data', 'filename', 'origname'], state
-            assert state.data is None, state.data
+            assert sorted(vars(state)) == ['filename', 'origname'], state
             assert state.origname
             __path__ = spec.submodule_search_locations
             ispkg = __path__ is not None
@@ -917,13 +915,12 @@ def find_spec(cls, fullname, path=None, target=None):
         info = _call_with_frames_removed(_imp.find_frozen, fullname)
         if info is None:
             return None
-        data, ispkg, origname = info
+        _, ispkg, origname = info
         spec = spec_from_loader(fullname, cls,
                                 origin=cls._ORIGIN,
                                 is_package=ispkg)
         filename, pkgdir = cls._resolve_filename(origname, fullname, ispkg)
         spec.loader_state = type(sys.implementation)(
-            data=data,
             filename=filename,
             origname=origname,
         )
@@ -960,20 +957,7 @@ def create_module(spec):
     def exec_module(module):
         spec = module.__spec__
         name = spec.name
-        try:
-            data = spec.loader_state.data
-        except AttributeError:
-            if not _imp.is_frozen(name):
-                raise ImportError('{!r} is not a frozen module'.format(name),
-                                  name=name)
-            data = None
-        else:
-            # We clear the extra data we got from the finder, to save memory.
-            # Note that if this method is called again (e.g. by
-            # importlib.reload()) then _imp.get_frozen_object() will notice
-            # no data was provided and will look it up.
-            spec.loader_state.data = None
-        code = _call_with_frames_removed(_imp.get_frozen_object, name, data)
+        code = _call_with_frames_removed(_imp.get_frozen_object, name)
         exec(code, module.__dict__)
 
     @classmethod

Lib/test/test_importlib/frozen/test_finder.py

@@ -48,17 +48,6 @@ def check_loader_state(self, spec, origname=None, filename=None):
 
         actual = dict(vars(spec.loader_state))
 
-        # Check the code object used to import the frozen module.
-        # We can't compare the marshaled data directly because
-        # marshal.dumps() would mark "expected" (below) as a ref,
-        # which slightly changes the output.
-        # (See https://bugs.python.org/issue34093.)
-        data = actual.pop('data')
-        with import_helper.frozen_modules():
-            expected = _imp.get_frozen_object(spec.name)
-        code = marshal.loads(data)
-        self.assertEqual(code, expected)
-
         # Check the rest of spec.loader_state.
         expected = dict(
             origname=origname,

Lib/test/test_importlib/frozen/test_loader.py

@@ -44,14 +44,12 @@ class ExecModuleTests(abc.LoaderTests):
     def exec_module(self, name, origname=None):
         with import_helper.frozen_modules():
             is_package = self.machinery.FrozenImporter.is_package(name)
-            code = _imp.get_frozen_object(name)
         spec = self.machinery.ModuleSpec(
             name,
             self.machinery.FrozenImporter,
             origin='frozen',
             is_package=is_package,
             loader_state=types.SimpleNamespace(
-                data=marshal.dumps(code),
                 origname=origname or name,
                 filename=resolve_stdlib_file(origname or name, is_package),
             ),
@@ -78,7 +76,6 @@ def test_module(self):
             self.assertEqual(getattr(module, attr), value)
         self.assertEqual(output, 'Hello world!\n')
         self.assertTrue(hasattr(module, '__spec__'))
-        self.assertIsNone(module.__spec__.loader_state.data)
         self.assertEqual(module.__spec__.loader_state.origname, name)
 
     def test_package(self):
@@ -92,7 +89,6 @@ def test_package(self):
                                  name=name, attr=attr, given=attr_value,
                                  expected=value))
         self.assertEqual(output, 'Hello world!\n')
-        self.assertIsNone(module.__spec__.loader_state.data)
         self.assertEqual(module.__spec__.loader_state.origname, name)
 
     def test_lacking_parent(self):

Python/clinic/import.c.h

@@ -2050,6 +2050,8 @@ _imp.find_frozen
 
     name: unicode
     /
+    *
+    withdata: bool = False
 
 Return info about the corresponding frozen module (if there is one) or None.
 
@@ -2063,8 +2065,8 @@ The returned info (a 2-tuple):
 [clinic start generated code]*/
 
 static PyObject *
-_imp_find_frozen_impl(PyObject *module, PyObject *name)
-/*[clinic end generated code: output=3fd17da90d417e4e input=6aa7b9078a89280a]*/
+_imp_find_frozen_impl(PyObject *module, PyObject *name, int withdata)
+/*[clinic end generated code: output=8c1c3c7f925397a5 input=22a8847c201542fd]*/
 {
     struct frozen_info info;
     frozen_status status = find_frozen(name, &info);
@@ -2079,10 +2081,12 @@ _imp_find_frozen_impl(PyObject *module, PyObject *name)
         return NULL;
     }
 
-    PyObject *data = PyMemoryView_FromMemory((char *)info.data, info.size,
-                                             PyBUF_READ);
-    if (data == NULL) {
-        return NULL;
+    PyObject *data = NULL;
+    if (withdata) {
+        data = PyMemoryView_FromMemory((char *)info.data, info.size, PyBUF_READ);
+        if (data == NULL) {
+            return NULL;
+        }
     }
 
     PyObject *origname = NULL;
@@ -2094,11 +2098,11 @@ _imp_find_frozen_impl(PyObject *module, PyObject *name)
         }
     }
 
-    PyObject *result = PyTuple_Pack(3, data,
+    PyObject *result = PyTuple_Pack(3, data ? data : Py_None,
                                     info.is_package ? Py_True : Py_False,
                                     origname ? origname : Py_None);
     Py_XDECREF(origname);
-    Py_DECREF(data);
+    Py_XDECREF(data);
     return result;
 }