fix(async): close awaitables require_await declines to await

require_await raised before awaiting, so the awaitable handed to it was
never awaited and never closed. async_generator_to_sync calls it as
require_await(async_gen.__anext__()), which meant the orphaned coroutine
was created inside the library and no caller could reach it to clean up.

CPython emitted "RuntimeWarning: coroutine method 'asend' ... was never
awaited" while finalizing the async generator; the pytest config's
filterwarnings = error turned that into an exception inside __del__,
surfacing as an unraisable that failed the 3.13 and 3.14 jobs.

require_await now takes ownership of the awaitable either way, closing it
before raising when inactive. This matches maybe_submit, which hands the
awaitable back to the caller when inactive rather than dropping it. Use
getattr for close since Awaitable does not guarantee it.

test_require_await_outside_context papered over this with a manual
close(); it now asserts the coroutine was closed, which fails without the
fix on every supported version rather than only on 3.13+.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Co-Authored-By: Claude Code <noreply@anthropic.com>

Author: RonnyPfannschmidt

src/pluggy/_async.py

@@ -67,12 +67,22 @@ def maybe_submit(self, coro: Awaitable[_T]) -> _T | Awaitable[_T]:
             return coro
 
     def require_await(self, coro: Awaitable[_T]) -> _T:
-        """Await an awaitable, raising an error if not in async context."""
+        """Await an awaitable, raising an error if not in async context.
+
+        Ownership of ``coro`` is taken either way: when inactive it is closed
+        before raising, so callers never leak a coroutine that would later
+        warn about never having been awaited.
+        """
         active = self._active_submitter
         if active is not None:
             res: _T = active.switch(coro)
             return res
         else:
+            # Not going to await it, so dispose of it rather than let it be
+            # collected unawaited (a RuntimeWarning raised inside __del__).
+            close = getattr(coro, "close", None)
+            if close is not None:
+                close()
             raise RuntimeError("require_await called outside of async context")
 
     async def run(self, sync_func: Callable[[], _T]) -> _T:

testing/test_async.py

@@ -8,6 +8,7 @@
 from collections.abc import AsyncGenerator
 from collections.abc import Awaitable
 from collections.abc import Coroutine
+import inspect
 from typing import Any
 from typing import cast
 
@@ -179,7 +180,10 @@ async def coro() -> None:
     awaitable = coro()
     with pytest.raises(RuntimeError, match="outside of async context"):
         submitter.require_await(awaitable)
-    awaitable.close()
+    # require_await takes ownership either way: an awaitable it declines to
+    # await is closed, not left to warn about never being awaited when
+    # collected.
+    assert inspect.getcoroutinestate(awaitable) == inspect.CORO_CLOSED
 
 
 def test_maybe_submit_outside_context_returns_awaitable() -> None: