fix(asyncio): await __aexit__ once; split using/tryUsing

Restructure AsyncContextManager so __aexit__ is awaited exactly once on
every path. The success-path exit now runs outside the body's try, so a
raising __aexit__ propagates instead of triggering a second call.

Replace the silent Unchecked.defaultof on suppression with two combinators:
- using: always re-raises after __aexit__, returning a plain 'U
- tryUsing: honors __aexit__'s suppression signal, returning 'U option

Add a hand-written TrackingCm to cover the branches asyncio.Lock can't
reach: suppression via tryUsing, using re-raising despite a truthy exit,
and no double-exit when the success-path __aexit__ raises.

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

Author: dbrattli

src/stdlib/asyncio/ContextManager.fs

@@ -32,13 +32,45 @@ type IAsyncContextManager<'T> =
 [<RequireQualifiedAccess>]
 module AsyncContextManager =
 
+    /// Acquire the resource, run the body, and await `__aexit__` exactly once.
+    /// Returns `Ok result` when the body succeeds, or `Error (error, suppress)`
+    /// when it raises — where `suppress` is the truthy/falsy value `__aexit__`
+    /// returned for that error.
+    ///
+    /// The body's outcome is captured in an inner `task` so that `__aexit__` is
+    /// awaited *outside* the `try`. Awaiting the success-path `__aexit__` inside
+    /// the `try` would route an exception it raises into the error branch and
+    /// call `__aexit__` a second time — Python's `async with` never does this.
+    let private run (manager: IAsyncContextManager<'T>) (body: 'T -> Task<'U>) : Task<Result<'U, exn * bool>> =
+        task {
+            let! resource = manager.AEnter()
+
+            let! outcome =
+                task {
+                    try
+                        let! result = body resource
+                        return Ok result
+                    with error ->
+                        return Error error
+                }
+
+            match outcome with
+            | Ok result ->
+                let! _ = manager.AExit()
+                return Ok result
+            | Error error ->
+                let! suppress = manager.AExit(error)
+                return Error(error, suppress)
+        }
+
     /// Run the body within a Python asynchronous context manager, mirroring
     /// Python's `async with manager as resource: ...`.
     ///
     /// `__aenter__()` is awaited to acquire the resource, `body` is run with it,
     /// and `__aexit__(...)` is awaited afterwards on both the success and error
-    /// paths. If the body raises and `__aexit__` returns a truthy value the
-    /// exception is suppressed (as `async with` does); otherwise it is re-raised.
+    /// paths. If the body raises, the exception is **always re-raised** after
+    /// `__aexit__` runs — a truthy `__aexit__` return is ignored so the result
+    /// type stays a plain `'U`. Use `tryUsing` if you need to honor suppression.
     ///
     /// ```fsharp
     /// task {
@@ -50,17 +82,28 @@ module AsyncContextManager =
     /// ```
     let using (manager: IAsyncContextManager<'T>) (body: 'T -> Task<'U>) : Task<'U> =
         task {
-            let! resource = manager.AEnter()
+            let! outcome = run manager body
 
-            try
-                let! result = body resource
-                let! _ = manager.AExit()
-                return result
-            with error ->
-                let! suppress = manager.AExit(error)
+            match outcome with
+            | Ok result -> return result
+            | Error(error, _) -> return raise error
+        }
+
+    /// Like `using`, but honors `__aexit__`'s suppression signal — matching the
+    /// full `async with` contract.
+    ///
+    /// Returns `Some result` when the body succeeds. If the body raises and
+    /// `__aexit__` returns a truthy value (the exception is handled), returns
+    /// `None`; otherwise the exception is re-raised.
+    let tryUsing (manager: IAsyncContextManager<'T>) (body: 'T -> Task<'U>) : Task<'U option> =
+        task {
+            let! outcome = run manager body
 
+            match outcome with
+            | Ok result -> return Some result
+            | Error(error, suppress) ->
                 if suppress then
-                    return Unchecked.defaultof<'U>
+                    return None
                 else
                     return raise error
         }

test/TestAsyncIO.fs

@@ -11,6 +11,26 @@ type private Lock() =
     [<Emit("$0.locked()")>]
     member _.locked() : bool = nativeOnly
 
+/// A minimal hand-written async context manager used to exercise the branches
+/// that stdlib's asyncio.Lock never hits: __aexit__ returning a truthy value
+/// (suppress the exception) and __aexit__ raising on the success path.
+/// `exits` counts how many times __aexit__ was awaited.
+[<AttachMembers>]
+type private TrackingCm(suppress: bool, raiseOnSuccessExit: bool) =
+    member val exits = 0 with get, set
+
+    member this.``__aenter__``() : System.Threading.Tasks.Task<obj> = task { return box this }
+
+    member this.``__aexit__``(excType: obj, exc: obj, tb: obj) : System.Threading.Tasks.Task<bool> =
+        task {
+            this.exits <- this.exits + 1
+
+            if raiseOnSuccessExit && isNull (box exc) then
+                failwith "exit boom"
+
+            return suppress
+        }
+
 [<Fact>]
 let ``test builder run zero works`` () =
     let tsk = task { () }
@@ -155,3 +175,66 @@ let ``test async context manager exits on error`` () =
         }
 
     asyncio.run tsk |> equal true
+
+[<Fact>]
+let ``test tryUsing suppresses error when exit returns true`` () =
+    let manager = TrackingCm(suppress = true, raiseOnSuccessExit = false)
+    let cm = unbox<IAsyncContextManager<obj>> manager
+
+    let tsk =
+        task {
+            // Body raises, but __aexit__ returns true: tryUsing honors the
+            // suppression and yields None instead of re-raising.
+            let! result =
+                AsyncContextManager.tryUsing cm (fun _ ->
+                    task {
+                        do failwith "boom"
+                        return 0
+                    })
+
+            return result, manager.exits
+        }
+
+    // No exception escapes, result is None, and __aexit__ ran exactly once.
+    asyncio.run tsk |> equal (None, 1)
+
+[<Fact>]
+let ``test using re-raises even when exit returns true`` () =
+    let manager = TrackingCm(suppress = true, raiseOnSuccessExit = false)
+    let cm = unbox<IAsyncContextManager<obj>> manager
+
+    let tsk =
+        task {
+            try
+                // `using` always re-raises, ignoring the truthy __aexit__ return.
+                let! _ =
+                    AsyncContextManager.using cm (fun _ ->
+                        task {
+                            do failwith "boom"
+                            return 0
+                        })
+
+                return -1
+            with _ ->
+                return manager.exits
+        }
+
+    asyncio.run tsk |> equal 1
+
+[<Fact>]
+let ``test async context manager does not exit twice when success exit raises`` () =
+    let manager = TrackingCm(suppress = false, raiseOnSuccessExit = true)
+    let cm = unbox<IAsyncContextManager<obj>> manager
+
+    let tsk =
+        task {
+            try
+                // Body succeeds; the success-path __aexit__ raises. That error must
+                // propagate without __aexit__ being invoked a second time.
+                let! _ = AsyncContextManager.using cm (fun _ -> task { return 0 })
+                return -1
+            with _ ->
+                return manager.exits
+        }
+
+    asyncio.run tsk |> equal 1