perf: Stop patching AST, use functions instead

Previously we were patching AST classes,
adding our own class to their base classes.
This allowed us to extend these classes,
by adding properties such as `kind`, `children`, etc.

Now we stop patching classes,
and re-define these properties
as simple functions that take
an AST node as argument.

Their result isn't cached anymore,
and we refactor them as iterators/generators.

We also stop using classes for AST nodes
unparsing into values / expressions when feasible.

Finally, we explode the node utilities
into different submodules, in the new `nodes` folder.

The result is:

- increased performance: for some reason, benchmarks
  show that performance is better without cached properties.
  Maybe MRO and cached values access was more costly.
- increased memory efficiency: without so many cached properties,
  we consume a less memory. This is not super impactful
  because `compile` and file reads represent almost
  all our memory consumption.
- better static typing: the AST patch would have required
  a mypy plugin to be understood correctly by mypy.
  We don't need that anymore.
- easier-to-use library: we don't have to hardcode the call
  to `patch_ast` anywhere anymore, and users won't have to either.

Author: pawamoy

CHANGELOG.md

@@ -16,7 +16,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
     - [`GriffeLoader.resolve_aliases(only_exported)`][griffe.loader.GriffeLoader.resolve_aliases]: Deprecated parameter was removed and replaced by `implicit` (inverse semantics)
     - [`GriffeLoader.resolve_aliases(only_known_modules)`][griffe.loader.GriffeLoader.resolve_aliases]: Deprecated parameter was removed and replaced by `external` (inverse semantics)
     - [`LinesCollection.tokens`][griffe.collections.LinesCollection]: Public object was removed (Python 3.7)
-    - [`ASTNode.end_lineno`][griffe.agents.nodes.ASTNode]: Public object was removed (Python 3.7)
+    - `ASTNode.end_lineno`: Public object was removed (Python 3.7)
     - [`griffe.agents.extensions`][griffe.agents] Deprecated module was removed and replaced by [`griffe.extensions`][]
 
 ### Features

src/griffe/agents/inspector.py

@@ -24,7 +24,7 @@
 
 import ast
 from inspect import Parameter as SignatureParameter
-from inspect import Signature, cleandoc, getmodule, ismodule
+from inspect import Signature, cleandoc
 from inspect import signature as getsignature
 from typing import TYPE_CHECKING, Any
 
@@ -51,8 +51,6 @@
     from griffe.expressions import Expression, Name
 
 
-from functools import cached_property
-
 empty = Signature.empty
 
 
@@ -99,58 +97,6 @@ def inspect(
     ).get_module(import_paths)
 
 
-_cyclic_relationships = {
-    ("os", "nt"),
-    ("os", "posix"),
-    ("numpy.core._multiarray_umath", "numpy.core.multiarray"),
-    ("pymmcore._pymmcore_swig", "pymmcore.pymmcore_swig"),
-}
-
-
-def _should_create_alias(parent: ObjectNode, child: ObjectNode, current_module_path: str) -> str | None:
-    # the whole point of the following logic is to deal with these cases:
-    # - parent object has a module member
-    # - if this module is not a submodule of the parent, alias it
-    # - but break special cycles coming from builtin modules
-    #   like ast -> _ast -> ast (here we inspect _ast)
-    #   or os -> posix/nt -> os (here we inspect posix/nt)
-
-    child_obj = child.obj
-    if isinstance(child_obj, cached_property):
-        child_obj = child_obj.func
-
-    try:
-        child_module = getmodule(child_obj)
-    except Exception:  # noqa: BLE001
-        return None
-    if not child_module:
-        return None
-
-    if ismodule(parent.obj):
-        parent_module = parent.obj
-    else:
-        parent_module = getmodule(parent.obj)  # type: ignore[assignment]
-        if not parent_module:
-            return None
-
-    parent_module_path = getattr(parent_module.__spec__, "name", parent_module.__name__)
-    child_module_path = getattr(child_module.__spec__, "name", child_module.__name__)
-    parent_base_name = parent_module_path.split(".")[-1]
-    child_base_name = child_module_path.split(".")[-1]
-
-    # special cases: inspect.getmodule does not return the real modules
-    # for those, but rather the "user-facing" ones - we prevent that
-    # and use the real parent module
-    if (parent_module_path, child_module_path) in _cyclic_relationships or parent_base_name == f"_{child_base_name}":
-        child_module = parent_module
-        child_module_path = getattr(child_module.__spec__, "name", child_module.__name__)
-
-    is_submodule = child_module_path == current_module_path or child_module_path.startswith(current_module_path + ".")
-    if not is_submodule:
-        return child_module_path.lstrip("_")
-    return None
-
-
 class Inspector:
     """This class is used to instantiate an inspector.
 
@@ -254,13 +200,8 @@ def generic_inspect(self, node: ObjectNode) -> None:
             before_inspector.inspect(node)
 
         for child in node.children:
-            child_module_path = _should_create_alias(node, child, self.current.module.path)
-            if child_module_path:
-                if child.kind is ObjectKind.MODULE:
-                    target_path = child_module_path
-                else:
-                    child_name = getattr(child.obj, "__name__", child.name)
-                    target_path = f"{child_module_path}.{child_name}"
+            target_path = child.alias_target_path
+            if target_path:
                 self.current.set_member(child.name, Alias(child.name, target_path))
             else:
                 self.inspect(child)