Improve async stack traces

src/fsharp/FSharp.Core/async.fsi

@@ -25,9 +25,7 @@ namespace Microsoft.FSharp.Control
     /// computation expressions can check the cancellation condition regularly. Synchronous 
     /// computations within an asynchronous computation do not automatically check this condition.</remarks> 
 
-    [<Sealed>]
-    [<NoEquality; NoComparison>]
-    [<CompiledName("FSharpAsync`1")>]
+    [<Sealed; NoEquality; NoComparison; CompiledName("FSharpAsync`1")>]
     type Async<'T>
 
     /// <summary>This static class holds members for creating and manipulating asynchronous computations.</summary>
@@ -417,7 +415,6 @@ namespace Microsoft.FSharp.Control
         static member StartImmediate: 
             computation:Async<unit> * ?cancellationToken:CancellationToken-> unit
 
-
         /// <summary>Runs an asynchronous computation, starting immediately on the current operating system, 
         /// but also returns the execution as <c>System.Threading.Tasks.Task</c> 
         /// </summary>
@@ -435,6 +432,112 @@ namespace Microsoft.FSharp.Control
             computation:Async<'T> * ?cancellationToken:CancellationToken-> Task<'T>
 
 
+    /// <summary>The F# compiler emits references to this type to implement F# async expressions.</summary>
+    type AsyncReturn
+
+    /// <summary>The F# compiler emits references to this type to implement F# async expressions.</summary>
+    [<Struct; NoEquality; NoComparison>]
+    type AsyncActivation<'T> =
+
+        /// <summary>The F# compiler emits calls to this function to implement F# async expressions.</summary>
+        ///
+        /// <returns>A value indicating asynchronous execution.</returns>
+        member IsCancellationRequested: bool
+
+        /// <summary>The F# compiler emits calls to this function to implement F# async expressions.</summary>
+        ///
+        /// <returns>A value indicating asynchronous execution.</returns>
+        member OnSuccess: 'T -> AsyncReturn
+
+        /// <summary>The F# compiler emits calls to this function to implement F# async expressions.</summary>
+        member OnExceptionRaised: unit -> unit
+
+        /// <summary>The F# compiler emits calls to this function to implement F# async expressions.</summary>
+        ///
+        /// <returns>A value indicating asynchronous execution.</returns>
+        member OnCancellation: unit -> AsyncReturn
+
+        /// Used by MailboxProcessor
+        member internal QueueContinuationWithTrampoline: 'T -> AsyncReturn
+        /// Used by MailboxProcessor
+        member internal CallContinuation: 'T -> AsyncReturn
+
+    [<NoEquality; NoComparison>]
+    // Internals used by MailboxProcessor
+    type internal AsyncResult<'T>  =
+        | Ok of 'T
+        | Error of ExceptionDispatchInfo
+        | Canceled of OperationCanceledException
+
+    [<Sealed>]
+    /// <summary>Entry points for generated code</summary>
+    module AsyncPrimitives =
+
+        /// <summary>The F# compiler emits calls to this function to implement F# async expressions.</summary>
+        ///
+        /// <param name="body">The body of the async computation.</param>
+        ///
+        /// <returns>The async computation.</returns>
+        val MakeAsync: body:(AsyncActivation<'T> -> AsyncReturn) -> Async<'T>
+
+        /// <summary>The F# compiler emits calls to this function to implement constructs for F# async expressions.</summary>
+        ///
+        /// <param name="computation">The async computation.</param>
+        /// <param name="ctxt">The async activation.</param>
+        ///
+        /// <returns>A value indicating asynchronous execution.</returns>
+        val Invoke: computation: Async<'T> -> ctxt:AsyncActivation<'T> -> AsyncReturn
+
+        /// <summary>The F# compiler emits calls to this function to implement constructs for F# async expressions.</summary>
+        ///
+        /// <param name="ctxt">The async activation.</param>
+        /// <param name="result">The result of the first part of the computation.</param>
+        /// <param name="part2">A function returning the second part of the computation.</param>
+        ///
+        /// <returns>A value indicating asynchronous execution.</returns>
+        val CallThenInvoke: ctxt:AsyncActivation<'T> -> result1:'U -> part2:('U -> Async<'T>) -> AsyncReturn
+
+        /// <summary>The F# compiler emits calls to this function to implement the <c>let!</c> construct for F# async expressions.</summary>
+        ///
+        /// <param name="ctxt">The async activation.</param>
+        /// <param name="part2">A function returning the second part of the computation.</param>
+        ///
+        /// <returns>An async activation suitable for running part1 of the asynchronous execution.</returns>
+        val Bind: ctxt:AsyncActivation<'T> -> part1:Async<'U> -> part2:('U -> Async<'T>) -> AsyncReturn
+
+        /// <summary>The F# compiler emits calls to this function to implement the <c>try/finally</c> construct for F# async expressions.</summary>
+        ///
+        /// <param name="ctxt">The async activation.</param>
+        /// <param name="computation">The computation to protect.</param>
+        /// <param name="finallyFunction">The finally code.</param>
+        ///
+        /// <returns>A value indicating asynchronous execution.</returns>
+        val TryFinally: ctxt:AsyncActivation<'T> -> computation: Async<'T> -> finallyFunction: (unit -> unit) -> AsyncReturn
+
+        /// <summary>The F# compiler emits calls to this function to implement the <c>try/with</c> construct for F# async expressions.</summary>
+        ///
+        /// <param name="ctxt">The async activation.</param>
+        /// <param name="computation">The computation to protect.</param>
+        /// <param name="catchFunction">The exception filter.</param>
+        ///
+        /// <returns>A value indicating asynchronous execution.</returns>
+        val TryWith: ctxt:AsyncActivation<'T> -> computation: Async<'T> -> catchFunction: (Exception -> Async<'T> option) -> AsyncReturn
+
+        [<Sealed; AutoSerializable(false)>]        
+        // Internals used by MailboxProcessor
+        type internal ResultCell<'T> =
+            new : unit -> ResultCell<'T>
+            member GetWaitHandle: unit -> WaitHandle
+            member Close: unit -> unit
+            interface IDisposable
+            member RegisterResult: 'T * reuseThread: bool -> AsyncReturn
+            member GrabResult: unit -> 'T
+            member ResultAvailable : bool
+            member AwaitResult_NoDirectCancelOrTimeout : Async<'T>
+            member TryWaitForResultSynchronously: ?timeout: int -> 'T option
+
+        // Internals used by MailboxProcessor
+        val internal CreateAsyncResultAsync : AsyncResult<'T> -> Async<'T>
 
     [<CompiledName("FSharpAsyncBuilder")>]
     [<Sealed>]
@@ -473,7 +576,7 @@ namespace Microsoft.FSharp.Control
         /// <param name="computation1">The first part of the sequenced computation.</param>
         /// <param name="computation2">The second part of the sequenced computation.</param>
         /// <returns>An asynchronous computation that runs both of the computations sequentially.</returns>
-        member Combine : computation1:Async<unit> * computation2:Async<'T> -> Async<'T>
+        member inline Combine : computation1:Async<unit> * computation2:Async<'T> -> Async<'T>
 
         /// <summary>Creates an asynchronous computation that runs <c>computation</c> repeatedly 
         /// until <c>guard()</c> becomes false.</summary>
@@ -496,15 +599,15 @@ namespace Microsoft.FSharp.Control
         /// <c>async { ... }</c> computation expression syntax.</remarks>
         /// <param name="value">The value to return from the computation.</param>
         /// <returns>An asynchronous computation that returns <c>value</c> when executed.</returns>
-        member Return : value:'T -> Async<'T>
+        member inline Return : value:'T -> Async<'T>
 
         /// <summary>Delegates to the input computation.</summary>
         ///
         /// <remarks>The existence of this method permits the use of <c>return!</c> in the 
         /// <c>async { ... }</c> computation expression syntax.</remarks>
         /// <param name="computation">The input computation.</param>
         /// <returns>The input computation.</returns>
-        member ReturnFrom : computation:Async<'T> -> Async<'T>
+        member inline ReturnFrom : computation:Async<'T> -> Async<'T>
 
         /// <summary>Creates an asynchronous computation that runs <c>generator</c>.</summary>
         ///
@@ -538,7 +641,7 @@ namespace Microsoft.FSharp.Control
         /// <param name="binder">The function to bind the result of <c>computation</c>.</param>
         /// <returns>An asynchronous computation that performs a monadic bind on the result
         /// of <c>computation</c>.</returns>
-        member Bind: computation: Async<'T> * binder: ('T -> Async<'U>) -> Async<'U>
+        member inline Bind: computation: Async<'T> * binder: ('T -> Async<'U>) -> Async<'U>
 
         /// <summary>Creates an asynchronous computation that runs <c>computation</c>. The action <c>compensation</c> is executed 
         /// after <c>computation</c> completes, whether <c>computation</c> exits normally or by an exception. If <c>compensation</c> raises an exception itself
@@ -553,7 +656,7 @@ namespace Microsoft.FSharp.Control
         /// exception (including cancellation).</param>
         /// <returns>An asynchronous computation that executes computation and compensation afterwards or
         /// when an exception is raised.</returns>
-        member TryFinally : computation:Async<'T> * compensation:(unit -> unit) -> Async<'T>
+        member inline TryFinally : computation:Async<'T> * compensation:(unit -> unit) -> Async<'T>
 
         /// <summary>Creates an asynchronous computation that runs <c>computation</c> and returns its result.
         /// If an exception happens then <c>catchHandler(exn)</c> is called and the resulting computation executed instead.</summary>
@@ -562,11 +665,14 @@ namespace Microsoft.FSharp.Control
         ///
         /// The existence of this method permits the use of <c>try/with</c> in the 
         /// <c>async { ... }</c> computation expression syntax.</remarks>
+        ///
         /// <param name="computation">The input computation.</param>
         /// <param name="catchHandler">The function to run when <c>computation</c> throws an exception.</param>
         /// <returns>An asynchronous computation that executes <c>computation</c> and calls <c>catchHandler</c> if an
         /// exception is thrown.</returns>
-        member TryWith : computation:Async<'T> * catchHandler:(exn -> Async<'T>) -> Async<'T>
+        member inline TryWith : computation:Async<'T> * catchHandler:(exn -> Async<'T>) -> Async<'T>
+
+        // member inline TryWithFilter : computation:Async<'T> * catchHandler:(exn -> Async<'T> option) -> Async<'T>
 
         /// Generate an object used to build asynchronous computations using F# computation expressions. The value
         /// 'async' is a pre-defined instance of this type.
@@ -659,41 +765,6 @@ namespace Microsoft.FSharp.Control
 #endif
 
     // Internals used by MailboxProcessor
-    module internal AsyncImpl = 
+    module internal AsyncBuilderImpl = 
         val async : AsyncBuilder
 
-    [<Sealed>]        
-    // Internals used by MailboxProcessor
-    type internal AsyncReturn 
-
-    [<Sealed>]        
-    // Internals used by MailboxProcessor
-    type internal AsyncActivation<'T> =
-        member QueueContinuationWithTrampoline: 'T -> AsyncReturn
-        member CallContinuation: 'T -> AsyncReturn
-
-    [<NoEquality; NoComparison>]
-    // Internals used by MailboxProcessor
-    type internal AsyncResult<'T>  =
-        | Ok of 'T
-        | Error of ExceptionDispatchInfo
-        | Canceled of OperationCanceledException
-
-    // Internals used by MailboxProcessor
-    module internal AsyncPrimitives = 
-
-        [<Sealed; AutoSerializable(false)>]        
-        type internal ResultCell<'T> =
-            new : unit -> ResultCell<'T>
-            member GetWaitHandle: unit -> WaitHandle
-            member Close: unit -> unit
-            interface IDisposable
-            member RegisterResult: 'T * reuseThread: bool -> AsyncReturn
-            member GrabResult: unit -> 'T
-            member ResultAvailable : bool
-            member AwaitResult_NoDirectCancelOrTimeout : Async<'T>
-            member TryWaitForResultSynchronously: ?timeout: int -> 'T option
-
-        val CreateAsyncResultAsync : AsyncResult<'T> -> Async<'T>
-
-        val MakeAsync : (AsyncActivation<'T> -> AsyncReturn) -> Async<'T>

src/fsharp/FSharp.Core/mailbox.fs

@@ -7,7 +7,7 @@ namespace Microsoft.FSharp.Control
     open Microsoft.FSharp.Core
     open Microsoft.FSharp.Core.LanguagePrimitives.IntrinsicOperators
     open Microsoft.FSharp.Control
-    open Microsoft.FSharp.Control.AsyncImpl
+    open Microsoft.FSharp.Control.AsyncBuilderImpl
     open Microsoft.FSharp.Control.AsyncPrimitives
     open Microsoft.FSharp.Collections
 

src/fsharp/FSharp.Core/prim-types.fs

@@ -2764,17 +2764,17 @@ namespace Microsoft.FSharp.Core
     // Function Values
 
     [<AbstractClass>]
-    type FSharpTypeFunc() = 
+    type FSharpTypeFunc [<DebuggerHidden>] () = 
         abstract Specialize<'T> : unit -> obj
 
     [<AbstractClass>]
-    type FSharpFunc<'T,'Res>() = 
+    type FSharpFunc<'T,'Res> [<DebuggerHidden>] () = 
         abstract Invoke : 'T -> 'Res
 
     module OptimizedClosures = 
 
           [<AbstractClass>]
-          type FSharpFunc<'T,'U,'V>() = 
+          type FSharpFunc<'T,'U,'V> [<DebuggerHidden>] () = 
               inherit FSharpFunc<'T,('U -> 'V)>()
               abstract Invoke : 'T * 'U -> 'V
               override f.Invoke(t) = (fun u -> f.Invoke(t,u))
@@ -2787,7 +2787,7 @@ namespace Microsoft.FSharp.Core
                               member x.Invoke(t,u) = (retype func : FSharpFunc<'T,FSharpFunc<'U,'V>>).Invoke(t).Invoke(u) }
 
           [<AbstractClass>]
-          type FSharpFunc<'T,'U,'V,'W>() = 
+          type FSharpFunc<'T,'U,'V,'W> [<DebuggerHidden>] () = 
               inherit FSharpFunc<'T,('U -> 'V -> 'W)>()
               abstract Invoke : 'T * 'U * 'V -> 'W
               override f.Invoke(t) = (fun u v -> f.Invoke(t,u,v))
@@ -2805,7 +2805,7 @@ namespace Microsoft.FSharp.Core
                               member x.Invoke(t,u,v) = (retype func : FSharpFunc<'T,('U -> 'V -> 'W)>).Invoke(t) u v }
 
           [<AbstractClass>]
-          type FSharpFunc<'T,'U,'V,'W,'X>() = 
+          type FSharpFunc<'T,'U,'V,'W,'X> [<DebuggerHidden>] () = 
               inherit FSharpFunc<'T,('U -> 'V -> 'W -> 'X)>()
               abstract Invoke : 'T * 'U * 'V * 'W -> 'X
               static member Adapt(func : 'T -> 'U -> 'V -> 'W -> 'X) = 
@@ -2828,7 +2828,7 @@ namespace Microsoft.FSharp.Core
               override f.Invoke(t) = (fun u v w -> f.Invoke(t,u,v,w))
 
           [<AbstractClass>]
-          type FSharpFunc<'T,'U,'V,'W,'X,'Y>() =
+          type FSharpFunc<'T,'U,'V,'W,'X,'Y> [<DebuggerHidden>] () =
               inherit FSharpFunc<'T,('U -> 'V -> 'W -> 'X -> 'Y)>()
               abstract Invoke : 'T * 'U * 'V * 'W * 'X -> 'Y
               override f.Invoke(t) = (fun u v w x -> f.Invoke(t,u,v,w,x))

tests/FSharp.Core.UnitTests/SurfaceArea.coreclr.fs

@@ -567,6 +567,29 @@ Microsoft.FSharp.Collections.SetModule: TState FoldBack[T,TState](Microsoft.FSha
 Microsoft.FSharp.Collections.SetModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpSet`1[T])
 Microsoft.FSharp.Collections.SetModule: T[] ToArray[T](Microsoft.FSharp.Collections.FSharpSet`1[T])
 Microsoft.FSharp.Collections.SetModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Collections.FSharpSet`1[T])
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Boolean Equals(System.Object)
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Boolean IsCancellationRequested
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Boolean get_IsCancellationRequested()
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Int32 GetHashCode()
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnCancellation()
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Void OnExceptionRaised()
+Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnSuccess(T)
+Microsoft.FSharp.Control.AsyncActivation`1[T]: System.String ToString()
+Microsoft.FSharp.Control.AsyncActivation`1[T]: System.Type GetType()
+Microsoft.FSharp.Control.AsyncPrimitives: Boolean Equals(System.Object)
+Microsoft.FSharp.Control.AsyncPrimitives: Int32 GetHashCode()
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Bind[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn CallThenInvoke[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], TResult, Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Invoke[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Control.AsyncActivation`1[T])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn TryFinally[T](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn TryWith[T](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]])
+Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.FSharpAsync`1[T] MakeAsync[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.AsyncActivation`1[T],Microsoft.FSharp.Control.AsyncReturn])
+Microsoft.FSharp.Control.AsyncPrimitives: System.String ToString()
+Microsoft.FSharp.Control.AsyncPrimitives: System.Type GetType()
+Microsoft.FSharp.Control.AsyncReturn: Boolean Equals(System.Object)
+Microsoft.FSharp.Control.AsyncReturn: Int32 GetHashCode()
+Microsoft.FSharp.Control.AsyncReturn: System.String ToString()
+Microsoft.FSharp.Control.AsyncReturn: System.Type GetType()
 Microsoft.FSharp.Control.CommonExtensions: Boolean Equals(System.Object)
 Microsoft.FSharp.Control.CommonExtensions: Int32 GetHashCode()
 Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncWrite(System.IO.Stream, Byte[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32])