Lazy Imports

This implements Lazy Imports (PEP 690) on CPython main branch.

Most significant changes are in the following files:

Python/import.c - ~800 changes
Objects/dictobject.c - 600 changes
Python/ceval.c - ~300 changes
Objects/lazyimportobject.c - ~200 new lines

Python/import.c

• Implements the lazy imports basic functions for resolving objects and creatingPyLazyImportObject objects.
• Implements:_PyImport_LazyImportName(),_PyImport_EagerImportName(),_PyImport_ImportFrom(),PyImport_LoadLazyImport() and_imp._maybe_set_submodule_attribute()
• Adds the C API and Python (_imp) API:PyImport_SetLazyImports(),PyImport_SetLazyImportsInModule(),PyImport_IsLazyImportsEnabled()

Objects/dictobject.c

• Makes necessary changes to dictionary internals to support lazy values.
• Resolved objects from a dictionary immediately and automatically replace the lazy objects that represented them in the dictionary (as long as it's possible). In the case where the value in the dictionary can't be immediately replaced by the resolved object (because maybe the resolution of the object triggered a dictionary mutation), the next time the lazy value it's accessed it'll use an internal cached version of the resolved object and attempt substituting the lazy value with the resolved one again.
• Values in a dictionary are resolvedonly when is needed, otherwise they remain lazy for as long as possible.
  • Merging, copying,dict.keys(), etc. all maintain lazy values inside a dictionary.
• _Py_dict_lookup() can now returnDKIX_VALUE_ERROR in case the resolution of a lazy object resulted in an error.
• Adds*_keep_lazy/*KeepLazy (e.g._Py_dict_lookup_keep_lazy(),_PyDict_GetItemKeepLazy()) to force returning lazy objects without being resolved.
• AddsPyDict_NextWithError(), which works the same way asPyDict_Next() with the exception it propagates any errors to the caller by returning0 and setting an exception. Caller should useif (PyErr_Ocurred()) to check for any errors.
• Implements_PyDict_HasLazyImports()
• PyDict_Next() andPyDict_NextWithError() resolve all the lazy objects in the dictionary if it has them and if the passedpos is zero. Returns0 on errors or if objects can't be resolved.
• ImplementsPyDict_ResolveLazyImports() to resolve all lazy values in a dictionary.
  • If there are no lazy objects in a dictionary it does nothing, otherwise it walks the whole dictionary trying to resolve each value and retrying if the dictionary mutated halfway.
  • It's used by dictionary views,PyDict_Next(),dict.values(),dict.items() before starting to iterate through the dictionary, to ensure returned values are all resolved and that the dictionary doesn't mutate midway due to import side effects produced by resolving the values.
  • The primary reason we needdk_lazy_imports is to be able to make this call efficient for dictionaries without lazy values.
• ImplementsPyDict_IsLazyImport() to check if a given key in a dictionary is a lazy object.

Python/ceval.c

• ImplementsEAGER_IMPORT_NAME andIMPORT_NAME to createPyLazyImportObject objects when the feature is enabled.
• It also resolves some lazy import objects on specialized opcodes.
• import_name() andimport_from() were moved toPython/import.c, and mostly only renamed to_PyImport_EagerImportName() and_PyImport_ImportFrom(), respectively.

Objects/lazyimportobject.c

• Adds the implementation forPyLazyImportObject object viaPyLazyImport_Type.
• Adds_PyLazyImport_NewModule(),_PyLazyImport_NewObject(),_PyLazyImport_GetName(),PyLazyImport_CheckExact()