gh-157146: Accept relative archive paths and tighten the lookup

zipimporter does not absolutize its sys.path entry, so a relative entry
gives its modules a relative __file__ and a relative key in
sys.path_importer_cache; the isabs() guard made linecache skip exactly
that case.  Build the cache entry once for both the loader and the
archive lookups, and only import importlib.util once there is data to
decode.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016oQeaTzLMBouqehAe3W2EU

Author: gpshead

Lib/linecache.py

@@ -144,6 +144,7 @@ def updatecache(filename, module_globals=None):
         lazy_entry = entry if entry is not None and len(entry) == 1 else None
         if lazy_entry is None:
             lazy_entry = _make_lazycache_entry(filename, module_globals)
+        data = None
         if lazy_entry is not None:
             try:
                 data = lazy_entry[0]()
@@ -154,18 +155,10 @@ def updatecache(filename, module_globals=None):
                     # No luck, the PEP302 loader cannot find the source
                     # for this module.
                     return []
-                entry = (
-                    len(data),
-                    None,
-                    [line + '\n' for line in data.splitlines()],
-                    fullname
-                )
-                cache[filename] = entry
-                return entry[2]
-
-        # The file may be inside an archive on the module search path, such
-        # as a zip file.
-        data = _read_from_archive(fullname)
+        if data is None:
+            # The file may be inside an archive on the module search path,
+            # such as a zip file.
+            data = _read_from_archive(fullname)
         if data is not None:
             entry = (
                 len(data),
@@ -220,11 +213,8 @@ def _read_from_archive(filename):
     look for a finder registered for one of them.  Return None if the file
     is not in such an archive.
     """
-    import importlib.util
     import os
     import sys
-    if not os.path.isabs(filename):
-        return None
     path = filename
     while True:
         parent = os.path.dirname(path)
@@ -239,6 +229,7 @@ def _read_from_archive(filename):
             data = get_data(filename)
         except (ImportError, OSError):
             continue
+        import importlib.util
         try:
             return importlib.util.decode_source(data)
         except (UnicodeDecodeError, SyntaxError):

Lib/test/test_linecache.py

@@ -444,12 +444,24 @@ def test_getlines_without_module_globals(self):
         self.assertEqual(linecache.getline(filename, 4),
                          '    return "from the zip"\n')
         self.assertEqual(linecache.getline(filename, 5), '')
-
-    def test_getline_from_code_object(self):
         code = self.zipmod.f.__code__
-        self.assertEqual(
-            linecache.getline(code.co_filename, code.co_firstlineno),
-            'def f():\n')
+        self.assertEqual(code.co_filename, filename)
+        self.assertEqual(linecache.getline(filename, code.co_firstlineno),
+                         'def f():\n')
+
+    def test_relative_archive_path(self):
+        # A relative sys.path entry gives its modules a relative __file__.
+        tmpdir, zip_base = os.path.split(self.zip_name)
+        self.addCleanup(sys.path_importer_cache.pop, zip_base, None)
+        self.addCleanup(zipimport._zip_directory_cache.pop, zip_base, None)
+        sys.path.insert(0, zip_base)
+        self.addCleanup(sys.path.remove, zip_base)
+        with os_helper.change_cwd(tmpdir):
+            zippkg = importlib.import_module('zippkg')
+            self.assertEqual(zippkg.__file__,
+                             os.path.join(zip_base, 'zippkg', '__init__.py'))
+            self.assertEqual(linecache.getlines(zippkg.__file__),
+                             ['value = 42\n'])
 
     def test_package(self):
         zippkg = importlib.import_module('zippkg')