gh-92041: Verify frame ownership and retain safe cached module hits

Preflight the ownership-only revision before updating #160254.
Keep source retrieval unchanged and preserve linecache.getlines overrides.

Developed and tested with Codex (AI assistance).

Author: mdeck

Doc/library/inspect.rst

@@ -772,14 +772,10 @@ Retrieving source code
    if the module cannot be determined.
 
    .. versionchanged:: 3.16
-      On a filename-cache miss, frames and tracebacks may be resolved from
-      a registered module whose global namespace and canonical filename match
-      the frame. Existing filename-cache entries retain precedence. If multiple
-      modules share a filename, the result may differ from earlier Python
-      versions and can depend on previous lookups: the frame's globals owner
-      is not guaranteed to take precedence. Code objects continue to use
-      filename-based lookup and can also be affected by earlier frame or
-      traceback lookups.
+      Frames and tracebacks are first matched to a module in :data:`sys.modules`
+      using the frame's global namespace and normalized filename.
+      Code objects still use filename-based lookup, which can identify a
+      different module when multiple modules share a filename.
 
 
 .. function:: getsourcefile(object)

Lib/inspect.py

@@ -929,32 +929,93 @@ def getabsfile(object, _filename=None):
 modulesbyfile = {}
 _filesbymodname = {}
 
-def _getframemodule(frame, filename):
-    """Resolve a frame's registered globals owner with a matching origin."""
+def _getframemodule(frame, explicit_filename):
+    """Return a matching globals owner and a reusable fallback filename.
+
+    The filename is only returned if the owner does not match and the
+    filename-based lookup can reuse the normalized frame filename.
+    """
     namespace = frame.f_globals
-    name = namespace.get('__name__')
+    name = dict.get(namespace, '__name__')
     if type(name) is not str:
-        return None
+        return None, None
     module = sys.modules.get(name)
-    # Leave module subclasses and dynamically supplied filenames to the fallback.
+    # Leave subclasses and dynamic filenames to the existing lookup.
     if (type(module) is not types.ModuleType
-        or module.__dict__ is not namespace
-        or type(namespace.get('__file__')) is not str):
-        return None
+            or module.__dict__ is not namespace):
+        return None, None
+    module_filename = namespace.get('__file__')
+    filename = frame.f_code.co_filename
+    # Avoid invoking user-defined comparisons when matching filenames.
+    if type(module_filename) is not str or type(filename) is not str:
+        return None, None
+    if explicit_filename is not None and explicit_filename != filename:
+        return None, None
+    # Equal filenames need no normalization. An explicit bytecode
+    # filename must retain the source/bytecode distinction.
+    if module_filename == filename and (
+            explicit_filename is None or not filename.endswith(
+                tuple(importlib.machinery.BYTECODE_SUFFIXES))):
+        return module, None
+    bytecode_suffixes = tuple(importlib.machinery.BYTECODE_SUFFIXES)
+    is_bytecode = filename.endswith(bytecode_suffixes)
     try:
-        if filename == getabsfile(module):
-            return module
-    except FileNotFoundError, TypeError:
+        # Resolve bytecode aliases using the owner's loader to avoid
+        # looking up the frame recursively through getsourcefile().
+        if explicit_filename is None and is_bytecode:
+            source = (os.path.splitext(filename)[0]
+                      + importlib.machinery.SOURCE_SUFFIXES[0])
+            if (source in linecache.cache or os.path.exists(source)
+                    or getattr(module, '__loader__', None) is not None
+                    or getattr(getattr(module, '__spec__', None),
+                               'loader', None) is not None):
+                filename = source
+        if module_filename.endswith(bytecode_suffixes):
+            source = (os.path.splitext(module_filename)[0]
+                      + importlib.machinery.SOURCE_SUFFIXES[0])
+            if source == filename and namespace.get('__loader__') is not None:
+                return module, None
+            origin = getabsfile(module)
+        else:
+            origin = getabsfile(module, module_filename)
+        file = getabsfile(frame, filename)
+        if origin == file:
+            return module, None
+        # Reuse the path only if it preserves explicit-filename
+        # precedence and bytecode source resolution.
+        if explicit_filename is None and not is_bytecode:
+            return None, file
+    except (FileNotFoundError, TypeError):
         pass
-    return None
+    return None, None
 
 
 def getmodule(object, _filename=None):
     """Return the module an object was defined in, or None if not found."""
-    if ismodule(object):
-        return object
-    if hasattr(object, '__module__'):
-        return sys.modules.get(object.__module__)
+    object_type = type(object)
+    if object_type is types.FrameType:
+        frame = object
+    elif object_type is types.TracebackType:
+        frame = object.tb_frame
+    else:
+        if isinstance(object, types.ModuleType):
+            return object
+        if hasattr(object, '__module__'):
+            return sys.modules.get(object.__module__)
+        frame = None
+    if frame is not None:
+        # A module with these exact globals is the only possible globals
+        # owner. Otherwise verify ownership before using a cached result.
+        if _filename is not None and _filename in modulesbyfile:
+            module = sys.modules.get(modulesbyfile[_filename])
+            if (type(module) is types.ModuleType
+                    and module.__dict__ is frame.f_globals):
+                return module
+        module, fallback_filename = _getframemodule(frame, _filename)
+        if module is not None:
+            return module
+        if fallback_filename is not None:
+            _filename = fallback_filename
 
     # Try the filename to modulename cache
     if _filename is not None and _filename in modulesbyfile:
@@ -966,19 +1027,6 @@ def getmodule(object, _filename=None):
         return None
     if file in modulesbyfile:
         return sys.modules.get(modulesbyfile[file])
-    if isframe(object):
-        frame = object
-    elif istraceback(object):
-        frame = object.tb_frame
-    else:
-        frame = None
-    if frame is not None and (
-            _filename is None or _filename == frame.f_code.co_filename):
-        module = _getframemodule(frame, file)
-        if module is not None:
-            modulesbyfile[file] = module.__name__
-            return module
-
     # Update the filename to module name cache and check yet again
     # Copy sys.modules in order to cope with changes while iterating
     for modname, module in sys.modules.copy().items():