Refactor argument verification logic from _multicall to HookImpl

Move the duplicated argument extraction and error handling logic from
_multicall into a private _get_call_args() method on HookImpl. This
eliminates code duplication between wrapper and normal hook implementation
processing paths and centralizes the argument verification logic.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: RonnyPfannschmidt

src/pluggy/_callers.py

@@ -13,7 +13,6 @@
 
 from ._hook_callers import HookImpl
 from ._hook_callers import WrapperImpl
-from ._result import HookCallError
 from ._result import Result
 from ._warnings import PluggyTeardownRaisedWarning
 
@@ -94,15 +93,7 @@ def _multicall(
         teardowns: list[Teardown] = []
         try:
             for hook_impl in reversed(wrapper_impls):
-                try:
-                    args = [caller_kwargs[argname] for argname in hook_impl.argnames]
-                except KeyError as e:
-                    # coverage bug - this is tested
-                    for argname in hook_impl.argnames:  # pragma: no cover
-                        if argname not in caller_kwargs:
-                            raise HookCallError(
-                                f"hook call must provide argument {argname!r}"
-                            ) from e
+                args = hook_impl._get_call_args(caller_kwargs)
 
                 if hook_impl.hookwrapper:
                     function_gen = run_old_style_hookwrapper(hook_impl, hook_name, args)
@@ -122,15 +113,7 @@ def _multicall(
             # Process normal implementations (in reverse order for correct execution)
             # Caller ensures normal_impls contains only non-wrapper implementations
             for normal_impl in reversed(normal_impls):
-                try:
-                    args = [caller_kwargs[argname] for argname in normal_impl.argnames]
-                except KeyError as e:
-                    # coverage bug - this is tested
-                    for argname in normal_impl.argnames:  # pragma: no cover
-                        if argname not in caller_kwargs:
-                            raise HookCallError(
-                                f"hook call must provide argument {argname!r}"
-                            ) from e
+                args = normal_impl._get_call_args(caller_kwargs)
 
                 res = normal_impl.function(*args)
                 if res is not None:

src/pluggy/_hook_callers.py

@@ -28,6 +28,7 @@
 from ._hook_config import HookspecOpts
 from ._hook_markers import HookSpec
 from ._hook_markers import varnames
+from ._result import HookCallError
 
 
 _T_HookImpl = TypeVar("_T_HookImpl", bound="HookImpl")
@@ -668,6 +669,30 @@ def __init__(
         #: <callorder>`.
         self.trylast = hook_impl_config.trylast
 
+    def _get_call_args(self, caller_kwargs: Mapping[str, object]) -> list[object]:
+        """Extract arguments for calling this hook implementation.
+
+        Args:
+            caller_kwargs: Keyword arguments passed to the hook call
+
+        Returns:
+            List of arguments in the order expected by the hook implementation
+
+        Raises:
+            HookCallError: If required arguments are missing
+        """
+        try:
+            return [caller_kwargs[argname] for argname in self.argnames]
+        except KeyError as e:
+            # Find the first missing argument for a clearer error message
+            for argname in self.argnames:  # pragma: no cover
+                if argname not in caller_kwargs:
+                    raise HookCallError(
+                        f"hook call must provide argument {argname!r}"
+                    ) from e
+            # This should never be reached but keep the original exception just in case
+            raise  # pragma: no cover
+
     def __repr__(self) -> str:
         return (
             f"<{self.__class__.__name__} "