Give IAsyncDisposable a higher precedence than IDisposable, part of #97

Author: abelbraaksma

src/FSharp.Control.TaskSeq.Test/TaskSeq.Using.Tests.fs

@@ -26,10 +26,10 @@ type private MultiDispose(disposed: int ref) =
     inherit OneGetter()
 
     interface IDisposable with
-        member _.Dispose() = disposed.Value <- !disposed + 1
+        member _.Dispose() = disposed.Value <- 1
 
     interface IAsyncDisposable with
-        member _.DisposeAsync() = ValueTask(task { do disposed.Value <- !disposed + 1 })
+        member _.DisposeAsync() = ValueTask(task { do disposed.Value <- -1 })
 
 let private check = TaskSeq.length >> Task.map (should equal 1)
 
@@ -67,7 +67,7 @@ let ``CE task: Using when type implements IDisposable and IAsyncDisposable`` ()
     }
 
     check ts
-    |> Task.map (fun _ -> disposed.Value |> should equal 1) // only one of the two dispose method should fire
+    |> Task.map (fun _ -> disposed.Value |> should equal -1) // should prefer IAsyncDisposable, which returns -1
 
 [<Fact>]
 let ``CE task: Using! when type implements IDisposable`` () =
@@ -103,4 +103,4 @@ let ``CE task: Using! when type implements IDisposable and IAsyncDisposable`` ()
     }
 
     check ts
-    |> Task.map (fun _ -> disposed.Value |> should equal 1) // only one of the two dispose method should fire
+    |> Task.map (fun _ -> disposed.Value |> should equal -1) // should prefer IAsyncDisposable, which returns -1

src/FSharp.Control.TaskSeq/TaskSeqBuilder.fs

@@ -482,26 +482,18 @@ type TaskSeqBuilder() =
                 true)
         )
 
-    member inline this.Using(disp: #IDisposable, body: #IDisposable -> TaskSeqCode<'T>) : TaskSeqCode<'T> =
+    member inline this.Using(disp: #IAsyncDisposable, body: #IAsyncDisposable -> TaskSeqCode<'T>) : TaskSeqCode<'T> =
 
         // A using statement is just a try/finally with the finally block disposing if non-null.
-        this.TryFinally(
+        this.TryFinallyAsync(
             (fun sm -> (body disp).Invoke(&sm)),
             (fun () ->
-                // yes, this can be null from time to time
                 if not (isNull (box disp)) then
-                    disp.Dispose())
-        )
-
-    member inline this.For(sequence: seq<'TElement>, body: 'TElement -> TaskSeqCode<'T>) : TaskSeqCode<'T> =
-        // A for loop is just a using statement on the sequence's enumerator...
-        this.Using(
-            sequence.GetEnumerator(),
-            // ... and its body is a while loop that advances the enumerator and runs the body on each element.
-            (fun e -> this.While((fun () -> e.MoveNext()), (fun sm -> (body e.Current).Invoke(&sm))))
+                    disp.DisposeAsync().AsTask()
+                else
+                    Task.CompletedTask)
         )
 
-
     member inline _.Yield(v: 'T) : TaskSeqCode<'T> =
         TaskSeqCode<'T>(fun sm ->
             // This will yield with __stack_fin = false
@@ -513,8 +505,6 @@ type TaskSeqBuilder() =
             sm.Data.awaiter <- null
             __stack_fin)
 
-    member inline this.YieldFrom(source: seq<'T>) : TaskSeqCode<'T> = this.For(source, (fun v -> this.Yield(v)))
-
     member inline _.Bind(task: Task<'TResult1>, continuation: ('TResult1 -> TaskSeqCode<'T>)) : TaskSeqCode<'T> =
         TaskSeqCode<'T>(fun sm ->
             let mutable awaiter = task.GetAwaiter()
@@ -581,22 +571,27 @@ type TaskSeqBuilder() =
 module MediumPriority =
     type TaskSeqBuilder with
 
-        member inline this.Using
-            (
-                disp: #IAsyncDisposable,
-                body: #IAsyncDisposable -> TaskSeqCode<'T>
-            ) : TaskSeqCode<'T> =
+        member inline this.Using(disp: #IDisposable, body: #IDisposable -> TaskSeqCode<'T>) : TaskSeqCode<'T> =
 
             // A using statement is just a try/finally with the finally block disposing if non-null.
-            this.TryFinallyAsync(
+            this.TryFinally(
                 (fun sm -> (body disp).Invoke(&sm)),
                 (fun () ->
+                    // yes, this can be null from time to time
                     if not (isNull (box disp)) then
-                        disp.DisposeAsync().AsTask()
-                    else
-                        Task.CompletedTask)
+                        disp.Dispose())
             )
 
+        member inline this.For(sequence: seq<'TElement>, body: 'TElement -> TaskSeqCode<'T>) : TaskSeqCode<'T> =
+            // A for loop is just a using statement on the sequence's enumerator...
+            this.Using(
+                sequence.GetEnumerator(),
+                // ... and its body is a while loop that advances the enumerator and runs the body on each element.
+                (fun e -> this.While((fun () -> e.MoveNext()), (fun sm -> (body e.Current).Invoke(&sm))))
+            )
+
+        member inline this.YieldFrom(source: seq<'T>) : TaskSeqCode<'T> = this.For(source, (fun v -> this.Yield(v)))
+
         member inline this.For
             (
                 source: #IAsyncEnumerable<'TElement>,