WIP Async2

[majocha]

Currently just replaces cancellable.
Features: cold start, multi-start, cancellable, trampolined binds for safe non-tail recursion, fast tail-recursion with ReturnFromFinal, exceptions cached in ExceptionDispatchInfo for fast recovery from deep call stacks.

Synchronous executions should be quite fast and low alloc when it's done, but there are some fixes needed:
Currently complex mut rec expressions are not statically compiled, see the nowarn in CheckDeclarations.fs.

Very initial work.

[github-actions]

❗ Release notes required

@majocha,

Caution

No release notes found for the changed paths (see table below).

Please make sure to add an entry with an informative description of the change as well as link to this pull request, issue and language suggestion if applicable. Release notes for this repository are based on Keep A Changelog format.

The following format is recommended for this repository:

* <Informative description>. ([PR #XXXXX](https://github.com/dotnet/fsharp/pull/XXXXX))

See examples in the files, listed in the table below or in th full documentation at https://fsharp.github.io/fsharp-compiler-docs/release-notes/About.html.

If you believe that release notes are not necessary for this PR, please add NO_RELEASE_NOTES label to the pull request.

You can open this PR in browser to add release notes: open in github.dev

Change path	Release notes path	Description
src/Compiler	docs/release-notes/.FSharp.Compiler.Service/10.0.200.md	No release notes found or release notes format is not correct
vsintegration/src	docs/release-notes/.VisualStudio/18.3.md	No release notes found or release notes format is not correct

[vzarytovskii]

To avoid confusion - it's not the same "async2" as in runtime-supported async. It's just different re-implementation of async, right?

[majocha]

To avoid confusion - it's not the same "async2" as in runtime-supported async. It's just different re-implementation of async, right?

Nope, no. I wasn't even aware this was a thing until now :) The goal is to possibly replace all the internal use of async and cancellable with one reasonably efficient resumable CE. I went with async2 name after the example in resumable code RFC.

LOL, probably before I ever finish this, the runtime async model will switch to https://github.com/dotnet/runtimelab/blob/feature/async2-experiment/docs/design/features/runtime-handled-tasks.md

I guess this is the fate, always catching up :)

[majocha]

I updated more places where previously async (and node before) where in use. Particularly the GraphNode async lazy type.
F# inlining makes it hard to test the internal types. InternalsVisibleTo will not work in such case.
I had to actually link the relevant source files from the FCS to the test project. Async2.fs and BuildGraph.fs are now compiled also inside the test project to make the types accessible in tests.

[majocha]

Linked sources like these seem to bring down VS to a crawl.

[majocha]

This is probably related to in memory cross proj references. Project options manager goes into a loop of invalidating projects and type checks everything endlessly.

[majocha]

I made the accessibility public for the whole thing for now, dealing with inline internal stuff across test projects is pita.

One usability advantage over the normal async I notice: there are no weird edge cases wrt AsyncLocal diagnostics loggers now. That's because the execution is driven by AsyncTaskMethodBuilder, we can be sure everything within the braces of async2 { ... } is isolated wrt to execution context.

[majocha]

Implementing fast tail call with ReturnFromFinal is tricky While we can abandon intermediate computations in a tail call chain, we cannot abandon the first one, we must return to it, because it is the one actually awaited.

One possible solution is to thread a IValueTaskSource context between tail calls. We can bind to a ValueTask in the initial ReturnFromFinal, set the value in the last call of the chain, dropping all the intermediate computations.

[majocha]

I went simply with TaskCompletionSource as a tail-call context. With ReturnFromFinal the overhead is now significantly lower.