Rarely hash

- We use id(code) to key into _moduleless - this is cheap to resolve, and
  there is minimal chance of collision.
- We store hash(code) into a list as value.  In the rare event we store
  the same id for different code objects over time, this hash should
  distinguish.
  Note: 'is' comparison to a weakref would be always correct and
  cleaner.  However, tests show such implementations have worse
  performance, O(N) where N = len(sys.modules).  The implementation
  here is O(1).

Author: mdeck

Lib/inspect.py

@@ -151,7 +151,7 @@
 import builtins
 from keyword import iskeyword
 from operator import attrgetter
-from collections import namedtuple, OrderedDict
+from collections import defaultdict, namedtuple, OrderedDict
 
 # Create constants for the compiler flags in Include/code.h
 # We try to get them from dis to avoid duplication
@@ -974,7 +974,7 @@ def getabsfile(object, _filename=None):
 
 modulesbyfile = {}
 _filesbymodname = {}
-_moduleless = set()
+_moduleless = defaultdict(set)
 
 def getmodule(object, _filename=None):
     """Return the module an object was defined in, or None if not found."""
@@ -985,19 +985,21 @@ def getmodule(object, _filename=None):
     # Try the filename to modulename cache
     if _filename is not None and _filename in modulesbyfile:
         return sys.modules.get(modulesbyfile[_filename])
-    # Compute hash to track moduleless objects
+    # Check for moduleless objects
     code = _getcode(object)
-    hashcode = id(code) ^ hash(code) if code else None
-    if hashcode and hashcode in _moduleless:
-        return None
+    if hashes := _moduleless.get(id(code)):
+        if hash(code) in hashes:
+            return None
     # Try the cache again with the absolute file name
     try:
         file = getabsfile(object, _filename)
     except (TypeError, FileNotFoundError):
-        _moduleless.add(hashcode)
-        return None
-    if hashcode and hashcode in _moduleless:
+        if code:
+            _moduleless[id(code)].add(hash(code))
         return None
+    if hashes := _moduleless.get(id(code)):
+        if hash(code) in hashes:
+            return None
     if file in modulesbyfile:
         return sys.modules.get(modulesbyfile[file])
     _update_module_file_name_cache()
@@ -1006,7 +1008,8 @@ def getmodule(object, _filename=None):
     # Check the main module
     main = sys.modules['__main__']
     if not hasattr(object, '__name__'):
-        _moduleless.add(hashcode)
+        if code:
+            _moduleless[id(code)].add(hash(code))
         return None
     if hasattr(main, object.__name__):
         mainobject = getattr(main, object.__name__)
@@ -1018,7 +1021,8 @@ def getmodule(object, _filename=None):
         builtinobject = getattr(builtin, object.__name__)
         if builtinobject is object:
             return builtin
-    _moduleless.add(hashcode)
+    if code:
+        _moduleless[id(code)].add(hash(code))
     return None
 
 def _update_module_file_name_cache():