refactor: Move arguments node-parsing logic into its own module (used…

… by visitor and lambda expressions)

src/griffe/agents/nodes/__init__.py

@@ -17,7 +17,7 @@
 from griffe.agents.nodes._docstrings import get_docstring
 from griffe.agents.nodes._imports import relative_to_absolute
 from griffe.agents.nodes._names import get_instance_names, get_name, get_names
-from griffe.agents.nodes._parameters import get_call_keyword_arguments
+from griffe.agents.nodes._parameters import get_call_keyword_arguments, get_parameters
 from griffe.agents.nodes._runtime import ObjectNode
 from griffe.agents.nodes._values import get_value, safe_get_value
 from griffe.enumerations import ObjectKind
@@ -52,6 +52,7 @@
     "get_instance_names",
     "get_name",
     "get_names",
+    "get_parameters",
     "get_value",
     "ObjectKind",
     "ObjectNode",

src/griffe/agents/nodes/_parameters.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from itertools import zip_longest
+from typing import TYPE_CHECKING, Any, Iterable
 
-from griffe.expressions import safe_get_expression
+from griffe.enumerations import ParameterKind
 from griffe.logger import get_logger
 
 if TYPE_CHECKING:
@@ -16,6 +17,74 @@
 logger = get_logger(__name__)
 
 
+def get_parameters(node: ast.arguments) -> list[tuple[str, ast.AST, ParameterKind, str | ast.AST]]:
+    parameters = []
+
+    # TODO: probably some optimizations to do here
+    args_kinds_defaults: Iterable = reversed(
+        (
+            *zip_longest(
+                reversed(
+                    (
+                        *zip_longest(
+                            node.posonlyargs,
+                            [],
+                            fillvalue=ParameterKind.positional_only,
+                        ),
+                        *zip_longest(node.args, [], fillvalue=ParameterKind.positional_or_keyword),
+                    ),
+                ),
+                reversed(node.defaults),
+                fillvalue=None,
+            ),
+        ),
+    )
+    arg: ast.arg
+    kind: ParameterKind
+    arg_default: ast.AST | None
+    for (arg, kind), arg_default in args_kinds_defaults:
+        parameters.append((arg.arg, arg.annotation, kind, arg_default))
+
+    if node.vararg:
+        parameters.append(
+            (
+                node.vararg.arg,
+                node.vararg.annotation,
+                ParameterKind.var_positional,
+                "()",
+            ),
+        )
+
+    # TODO: probably some optimizations to do here
+    kwargs_defaults: Iterable = reversed(
+        (
+            *zip_longest(
+                reversed(node.kwonlyargs),
+                reversed(node.kw_defaults),
+                fillvalue=None,
+            ),
+        ),
+    )
+    kwarg: ast.arg
+    kwarg_default: ast.AST | None
+    for kwarg, kwarg_default in kwargs_defaults:
+        parameters.append(
+            (kwarg.arg, kwarg.annotation, ParameterKind.keyword_only, kwarg_default),
+        )
+
+    if node.kwarg:
+        parameters.append(
+            (
+                node.kwarg.arg,
+                node.kwarg.annotation,
+                ParameterKind.var_keyword,
+                "{}",
+            ),
+        )
+
+    return parameters
+
+
 def get_call_keyword_arguments(node: ast.Call, parent: Module | Class) -> dict[str, Any]:
     """Get the list of keyword argument names and values from a Call node.
 

src/griffe/agents/visitor.py

@@ -10,8 +10,7 @@
 
 import ast
 from contextlib import suppress
-from itertools import zip_longest
-from typing import TYPE_CHECKING, Any, Iterable
+from typing import TYPE_CHECKING, Any
 
 from griffe.agents.nodes import (
     ast_children,
@@ -20,6 +19,7 @@
     get_docstring,
     get_instance_names,
     get_names,
+    get_parameters,
     relative_to_absolute,
     safe_get__all__,
 )
@@ -361,78 +361,19 @@ def handle_function(self, node: ast.AsyncFunctionDef | ast.FunctionDef, labels:
             return
 
         # handle parameters
-        parameters = Parameters()
-        annotation: str | Expr | None
-
-        posonlyargs = node.args.posonlyargs
-
-        # TODO: probably some optimizations to do here
-        args_kinds_defaults: Iterable = reversed(
-            (
-                *zip_longest(
-                    reversed(
-                        (
-                            *zip_longest(
-                                posonlyargs,
-                                [],
-                                fillvalue=ParameterKind.positional_only,
-                            ),
-                            *zip_longest(node.args.args, [], fillvalue=ParameterKind.positional_or_keyword),
-                        ),
-                    ),
-                    reversed(node.args.defaults),
-                    fillvalue=None,
-                ),
-            ),
-        )
-        arg: ast.arg
-        kind: ParameterKind
-        arg_default: ast.AST | None
-        for (arg, kind), arg_default in args_kinds_defaults:
-            annotation = safe_get_annotation(arg.annotation, parent=self.current)
-            default = safe_get_expression(arg_default, parent=self.current, parse_strings=False)
-            parameters.add(Parameter(arg.arg, annotation=annotation, kind=kind, default=default))
-
-        if node.args.vararg:
-            annotation = safe_get_annotation(node.args.vararg.annotation, parent=self.current)
-            parameters.add(
+        parameters = Parameters(
+            *[
                 Parameter(
-                    node.args.vararg.arg,
-                    annotation=annotation,
-                    kind=ParameterKind.var_positional,
-                    default="()",
-                ),
-            )
-
-        # TODO: probably some optimizations to do here
-        kwargs_defaults: Iterable = reversed(
-            (
-                *zip_longest(
-                    reversed(node.args.kwonlyargs),
-                    reversed(node.args.kw_defaults),
-                    fillvalue=None,
-                ),
-            ),
+                    name,
+                    kind=kind,
+                    annotation=safe_get_annotation(annotation, parent=self.current),
+                    default=default
+                    if isinstance(default, str)
+                    else safe_get_expression(default, parent=self.current, parse_strings=False),
+                )
+                for name, annotation, kind, default in get_parameters(node.args)
+            ],
         )
-        kwarg: ast.arg
-        kwarg_default: ast.AST | None
-        for kwarg, kwarg_default in kwargs_defaults:
-            annotation = safe_get_annotation(kwarg.annotation, parent=self.current)
-            default = safe_get_expression(kwarg_default, parent=self.current, parse_strings=False)
-            parameters.add(
-                Parameter(kwarg.arg, annotation=annotation, kind=ParameterKind.keyword_only, default=default),
-            )
-
-        if node.args.kwarg:
-            annotation = safe_get_annotation(node.args.kwarg.annotation, parent=self.current)
-            parameters.add(
-                Parameter(
-                    node.args.kwarg.arg,
-                    annotation=annotation,
-                    kind=ParameterKind.var_keyword,
-                    default="{}",
-                ),
-            )
 
         function = Function(
             name=node.name,