Skip to content

Improve static compilation of state machines#19297

Open
majocha wants to merge 26 commits intodotnet:mainfrom
majocha:resumable-fix-19296
Open

Improve static compilation of state machines#19297
majocha wants to merge 26 commits intodotnet:mainfrom
majocha:resumable-fix-19296

Conversation

@majocha
Copy link
Contributor

@majocha majocha commented Feb 16, 2026

Fixes #19296, #12839 also includes test cases from #14930.

Also fixes FS3511 The resumable code value(s) 'code' does not have a definition. we have no issue open for it, but it was suppressed in this repo.

Brazenly vibecoded, however I think the risk of changes here is under control, given that we have quite a few relevant projects and their tests in the regression matrix.

OK here goes AI summary:

This pull request improves the F# compiler's handling of state machine lowering, especially for cases involving resumable code and control flow constructs like if __useResumableCode. It fixes issues where inlined helpers or nested resumable code constructs could incorrectly fall back to dynamic branches at runtime, and adds comprehensive test coverage for these scenarios. The main focus is on ensuring that statically-compilable state machines are correctly recognized and optimized, and that code generation remains robust for complex patterns.

Key changes include:

Compiler logic improvements:

  • Enhanced the lowering pass in LowerStateMachines.fs to correctly handle resumable code bindings found inside debug points, ensuring that nested resumable code constructs are properly expanded.
  • Updated the reduction logic to track locally-bound resumable code continuations in the environment, allowing correct resolution and inlining of these continuations during optimization. [1] [2]
  • Modified the rewrite environment to avoid recursing into nested state machine expressions, preventing unintended modification of their internal logic and ensuring that only the appropriate static branches are taken for if __useResumableCode.

Test suite enhancements:

  • Added a new test module (FailingInlinedHelper) and test case to verify that inlined helpers containing if __useResumableCode are expanded correctly, addressing a real-world bug. [1] [2]
  • Expanded tests to cover additional scenarios involving for-loops over tuples and various statically-compilable task patterns, ensuring robust handling of these constructs.

Documentation/test comments:

@github-actions
Copy link
Contributor

github-actions bot commented Feb 16, 2026

❗ 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/FSharp.Core docs/release-notes/.FSharp.Core/10.0.300.md No release notes found or release notes format is not correct

✅ Found changes and release notes in following paths:

Change path Release notes path Description
src/Compiler docs/release-notes/.FSharp.Compiler.Service/10.0.300.md
vsintegration/src docs/release-notes/.VisualStudio/18.vNext.md

Improve reduction of resumable code in state machines

Enhance application reduction in state machine lowering for F# computation expressions by tracking let-bound resumable code in the environment and resolving references during reduction. This enables correct handling of optimizer-generated continuations and deeper reduction of nested applications. Also, update test comments to reflect resolved state machine compilation issues.
@majocha
Copy link
Contributor Author

majocha commented Feb 16, 2026

Looks like this now to some point reinvents #14930. I'll try to include some of the relevant repros in tests. Too bad they are scattered across issues and comments.

@majocha
Copy link
Contributor Author

majocha commented Feb 16, 2026

Another observation: Lack of FS3511 warning does not mean the state machine actually compiled statically. Sometimes the fallback to dynamic implementation gives no warning.

@majocha majocha changed the title Resumable state machines: fix #19296 Improve static compilation of state machines Feb 17, 2026
@majocha majocha marked this pull request as ready for review February 17, 2026 09:56
@majocha majocha requested a review from a team as a code owner February 17, 2026 09:56
// The tasks below used to fail state machine compilation. This failure was causing subsequent problems in code generation.
// See https://github.com/dotnet/fsharp/issues/13404

#nowarn "3511" // state machine not statically compilable - this is a separate issue, see https://github.com/dotnet/fsharp/issues/13404
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This issue is fixed now.

}
"""
|> compile
|> verifyIL [ ".override [runtime]System.Runtime.CompilerServices.IAsyncStateMachine::MoveNext" ]
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

State machines sometimes fallback to dynamic implmentation without FS3511 warning. Checking for generated MoveNext is more reliable.

@majocha
Copy link
Contributor Author

majocha commented Feb 18, 2026

I tried to include in tests as many old repros as I could find across the issues.
My methodology was: paste the repro in sharplab.io, if it does not statically compile, include it in StateMachineTests.fs

Turns out a lot of those repros already compile statically. If not in sharplab (no idea what version it uses) than with current compiler from main.

3 cases remained that are fixed specifically by this PR:

@T-Gro
Copy link
Member

T-Gro commented Feb 18, 2026

Is it right to close #12839 with this ? It looks like an umbrella issue for all sorts of problems.
I am definitely happy if all of them are resolved 👍 , well done.

I am also thinking if there is a way we could add an end2end test here, e.g. using the library regression testing pipeline?
We do have iced tasks in already, is there something we could run as verification or a special flag/prop/check/IL detection perhaps, to spot regressions ?
(regression = code still compiles, but will fallback to dynamic implementation)

@majocha
Copy link
Contributor Author

majocha commented Feb 18, 2026

Is it right to close #12839 with this ? It looks like an umbrella issue for all sorts of problems. I am definitely happy if all of them are resolved 👍 , well done.

As far as I can tell all of them are resolved now, few have been resolved for some time.

I am also thinking if there is a way we could add an end2end test here, e.g. using the library regression testing pipeline? We do have iced tasks in already, is there something we could run as verification or a special flag/prop/check/IL detection perhaps, to spot regressions ? (regression = code still compiles, but will fallback to dynamic implementation)

I have nothing apart from the few tests I added :)

One thing that comes to mind is to disable some of the #nowarn 3511 we have in this repo, or at least make them scoped to the exact place, like using let rec in tasks. But that depends on the warning being reliable.

@majocha
Copy link
Contributor Author

majocha commented Feb 18, 2026

OK, it seems removing nowarn 3511 in this repo uncovers some more cases that need fixing.

…es not have a definition.")

consider a Run(code: ResumableCode<...>) method. In some cases code can get optimized away resulting in warning 3511
"The resumable code value(s) 'code' does not have a definition."
@majocha
Copy link
Contributor Author

majocha commented Feb 19, 2026

I removed the few catch all nowarns 3511. This revealed a nice small repro of

The resumable code value(s) 'code' does not have a definition.

Let's see if it's fixed.

type IFSharpCodeFixProvider with

member private provider.FixAllAsync (fixAllCtx: FixAllContext) (doc: Document) (allDiagnostics: ImmutableArray<Diagnostic>) =
cancellableTask {
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This was previously giving FS3511 with The resumable code value(s) 'code' does not have a definition.

Comment on lines -21 to -22
<!-- Turn off 3511: state machine not compilable - expected for inlined functions defining state machine generators -->
<OtherFlags>$(OtherFlags) --nowarn:3511</OtherFlags>
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

this is the only change to FSharp.Core. I guess no release notes needed.

@T-Gro
Copy link
Member

T-Gro commented Feb 19, 2026

Removing the nowarns here is good dogfooding 👍 .

IcedTasks have 3 of them in tests https://github.com/search?q=repo%3ATheAngryByrd%2FIcedTasks%203511&type=code that appear to be intentionally dynamic (for testing), otherwise I do not see it - all good ( I will just check the regression pipeline outputs if there are any warnings from it)

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

Status: New

Development

Successfully merging this pull request may close these issues.

State machines: low-level resumable code not always expanded correctly, without warning

2 participants

Comments