You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
{{ message }}
Repository navigation
fix(core): preserve optional F# async support without AOT warnings - #7526
C# applications without FSharp.Core now publish under Native AOT without unresolved optional-assembly warnings. Trimmed JIT applications that reference FSharp.Core continue to execute F# async values.
Removed the string-based DynamicDependency attributes and replaced them with a packaged linker descriptor preserving FSharpAsync.StartAsTask. TUnit.Core.targets adds that descriptor before PrepareForILLink only when PublishTrimmed is enabled, Native AOT is disabled, and the resolved references include FSharp.Core. Native AOT remains supported for C# test projects, as documented in engine-modes.md.
Validation on .NET SDK 10.0.403, macOS arm64:
TUnit.Core Release/net10.0 build: no warnings or errors.
Existing F# AsyncTests: 6/6 passed.
Focused trimmed F# regression application using the actual TUnit.Core assembly and targets: async side effect executed and async exception propagated. The same application without preservation fails because the body is skipped.
Focused C# Native AOT and trimmed JIT applications without FSharp.Core: published and executed; no IL2007 or IL2035 warnings.
MSBuild package-item evaluation confirms the descriptor under build/netstandard2.0 and buildTransitive/net10.0. Full package creation remains for CI because the local checkout lacks the separately built Roslyn analyzer variants.
The focused F# publish reports existing FSharp.Core IL2040 resource warnings, tracked in dotnet/fsharp#15261; reproduction details were added there. Publishing the complete F# test project with a global PublishTrimmed property cannot validate this configuration because that property also reaches netstandard2.0 analyzer dependencies (NETSDK1124), so the focused app isolates the relevant trimming path.
Summary by CodeRabbit
Documentation
Clarified that Native AOT is supported only for C# test projects, including in the compatibility guidance.
Bug Fixes
Improved F# async support in trimmed JIT applications when FSharp.Core is referenced. The required async functionality is now preserved during trimming, helping these applications continue to work as expected.
No actionable comments were generated in the recent review.
Walkthrough
The change adds conditional linker preservation for F# async support in trimmed, non-AOT publishes that reference FSharp.Core. It removes the string-based DynamicDependency attributes and clarifies that Native AOT publishing is supported only for C# test projects.
The package includes a linker descriptor that preserves FSharpAsync.StartAsTask. For trimmed, non-AOT publishes, the target adds the descriptor when resolved references include FSharp.Core.
F# async behavior and AOT guidance src/TUnit.Core/AsyncConvert.cs, docs/docs/execution/engine-modes.md
The F# async branch retains its existing call and removes the DynamicDependency attributes. Comments and documentation state that Native AOT publishing is supported only for C# test projects.
The change preserves supported trimmed F# async execution without introducing an actionable merge-blocking risk.
Pre-merge checks: 4 · 1
Failed checks: 1 warning
Check name
Status
Explanation
Resolution
Docstring Coverage
Docstring coverage is 50.00% which is insufficient. The required threshold is 80.00%. Docstring coverage is scoped to functions touched by this diff with cyclomatic complexity of at least 2. Documenta…
Write docstrings for the functions missing them to satisfy the coverage threshold.
Passed checks: 4 passed
Check name
Status
Explanation
Description Check
Check skipped - CodeRabbit’s high-level summary is enabled.
Title check
The title clearly describes the main change: preserving optional F# async support while preventing Native AOT warnings.
Linked Issues check
[#7523] Requirement 1: C# applications without FSharp.Core publish under Native AOT without IL2035. The head diff of src/TUnit.Core/AsyncConvert.cs removes both string-based DynamicDependency attribut…
Out of Scope Changes check
Each changed file connects to #7523. src/TUnit.Core/AsyncConvert.cs removes the warning-producing attributes and updates comments to state the new preservation mechanism and the Native AOT boundary. s…
Full details: Linked Issues check
Explanation
[#7523] Requirement 1: C# applications without FSharp.Core publish under Native AOT without IL2035. The head diff of src/TUnit.Core/AsyncConvert.cs removes both string-based DynamicDependency attributes that named FSharp.Core. No attribute now names the absent assembly. Requirement 2: Optional F# async support is preserved when FSharp.Core is present in trimmed JIT applications. src/TUnit.Core/TUnit.Core.targets adds _TUnitPreserveFSharpAsync before PrepareForILLink. It runs only when PublishTrimmed is true, PublishAot is not true, and FSharp.Core is in ManagedAssemblyToLink. It then adds TUnit.Core.FSharp.xml as a TrimmerRootDescriptor. That descriptor roots FSharpAsync.StartAsTask. The author reports a focused trimmed F# regression app that passes with the descriptor and fails without it, and 6/6 existing F# AsyncTests passing. Residual uncertainty: I did not inspect the reflection code in StartAsFSharpTask, so I cannot confirm that StartAsTask is the only FSharpAsync member it needs. I also did not inspect the csproj packaging path of TUnit.Core.targets relative to TUnit.Core.FSharp.xml. Package-layout behavior was confirmed only by MSBuild item evaluation, and full package creation is deferred to CI. These are residual risks, not demonstrated failures.
Full details: Out of Scope Changes check
Explanation
Each changed file connects to #7523. src/TUnit.Core/AsyncConvert.cs removes the warning-producing attributes and updates comments to state the new preservation mechanism and the Native AOT boundary. src/TUnit.Core/TUnit.Core.targets and src/TUnit.Core/TUnit.Core.FSharp.xml implement conditional preservation for trimmed applications that reference FSharp.Core. src/TUnit.Core/TUnit.Core.csproj packages the descriptor, which the targets file depends on. docs/docs/execution/engine-modes.md records the Native AOT restriction to C# test projects. That restriction is the boundary the descriptor's PublishAot exclusion relies on, so the documentation supports the change. No change in the reviewed summary is unrelated to #7523.
Full details: Docstring Coverage
Explanation
Docstring coverage is 50.00% which is insufficient. The required threshold is 80.00%. Docstring coverage is scoped to functions touched by this diff with cyclomatic complexity of at least 2. Documentation-only edits and deletions within surviving functions are included; unchanged diff context and fully deleted functions are excluded. Analyzed 2 functions across 1 files. (1 skipped: 1 unsupported.)
Resolution
Write docstrings for the functions missing them to satisfy the coverage threshold.
Finishing Touches
Generate unit tests (beta)
Commit to this branch
Create a new PR
Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts
Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.
A rabbit checks the linker trail, Where F# methods now prevail. If trimmed builds include their core, A descriptor keeps the method’s door. AOT notes C# tests alone.
Recent review info
Run configuration
Source mode: Auto
Repository: Unavailable
Branch: Unavailable
File: No configuration file from this repository applied
Commit: Unavailable
Layers: Organization UI
Review profile: CHILL
Plan: Advanced
Run ID: 4ad7314a-bdf6-4b48-9b6a-b3c6388b9419
Commits
Reviewing files that changed from the base of the PR and between 35d8a4d and e4c4769.
Files selected for processing: 1
src/TUnit.Core/TUnit.Core.targets
Included review availability: This review used your included allowance. Your plan provides up to 8 included reviews per hour; 6 remain after this review.
The change fixes the IL2035 warnings in #7523 by removing the two DynamicDependency attributes that named FSharp.Core. The docs now state that Native AOT is C#-only. The change is small and matches the stated policy. The UnconditionalSuppressMessage attributes still cover the remaining reflection warnings.
Two minor points, neither blocking:
Trimming without AOT: an F# project that uses PublishTrimmed but not AOT used to get FSharpAsync.StartAsTask preserved by those attributes. With them gone, trimming could remove it. StartAsFSharpTaskSafely may already catch the resulting failure, but I haven't checked. If trimmed F# is something you want to support, a better approach is to keep the preservation but make it conditional, for example by shipping the root in a build/ ILLink descriptor that applies only when FSharp.Core is referenced. That would avoid the IL2035 warning too. If trimming isn't supported for F# either, I'd say so in the docs.
Docs wording: the two added sentences in engine-modes.md say the same thing. One is enough.
Your validation covers an AOT publish with no IL2035 warnings and the F# async tests passing.
thomhurst
changed the title
Stop preserving FSharp.Core members for Native AOT (C#-only)
fix(core): preserve optional F# async support without AOT warnings
Nov 3, 2026
Codex, Claude, and CodeRabbit trimming concern: addressed with the conditional packaged descriptor in TUnit.Core.targets. The regression app fails without preservation and passes with the fix; F# AsyncTests pass 6/6. C# trimmed and Native AOT publishes without FSharp.Core both pass without optional-assembly warnings.
CodeRabbit linked-issue check: optional F# async preservation is restored for trimmed JIT. Native AOT F# test projects use reflection mode, which is already outside the supported Native AOT execution model; the documentation makes that limit explicit. This PR does not introduce support for executing F# test projects under Native AOT.
Claude docs repetition nit: retained the restriction in both the publishing instructions and the language compatibility section, so readers entering either section see the relevant constraint.
Validation details and limitations are recorded in the updated PR description. CI and fresh automated review are pending on the new head; auto-merge remains disabled.
The design is sound. A packaged linker descriptor, added only when trimming is on, AOT is off and FSharp.Core is referenced, fixes the IL2007/IL2035 warnings for C# AOT apps. It also keeps StartAsTask alive for trimmed F# JIT apps. This is better than the string-based DynamicDependency. I found no blocking issues, and the earlier Codex review had no findings.
Minor points, none blocking:
Package layout: the XML is packed to both build/ and buildTransitive/ through different item types (None and TfmSpecificPackageFile). The PR notes that full pack validation is left to CI. Please confirm the packed layout there, because a path mismatch would silently skip the descriptor. TrimmerRootDescriptor would then not be added, and F# async would break only under trimming.
Target ordering:DependsOnTargets="ResolveReferences" is usually already satisfied before PrepareForILLink, so it is harmless. Matching %(Filename) against ReferencePath only sees direct and transitive compile references. That is fine for FSharp.Core.
F# on Native AOT: this case is documented as unsupported. A short <Warning> or a doc note on the failure mode would help, but the docs change already covers it.
Regression test: the F# trimmed-app check was done by hand. If a cheap CI check is possible, such as a pack test asserting that the descriptor is in the nupkg, it would guard against layout regressions.
Looks good to merge once CI package validation passes.
Pushed e4c4769 to address the runtime-only FSharp.Core review finding; the inline reply records the regression and negative-control checks. Fresh CI and automated reviews are pending, and auto-merge remains disabled.
Claude follow-ups: the previous head's nuget-package-tests-windows job (run 41710901082) passed PackTUnitFilesModule and the F# package tests. This confirms package creation and consumption, but does not independently assert the descriptor archive entries; the earlier MSBuild package-item evaluation remains the direct layout evidence. A permanent package-layout regression test is a nonblocking follow-up suggestion. The existing documentation states the Native AOT support boundary; the additional failure-mode note is optional. CodeRabbit's docstring coverage advisory concerns existing code with removed attributes and does not require a functional change here.
The approach is sound. Replacing the string-based DynamicDependency with a linker descriptor that is only added when FSharp.Core is actually referenced removes the IL2035/IL2007 warnings for C# AOT apps. Trimmed F# JIT apps keep the StartAsTask root.
Checked:
The descriptor is packed next to the .targets in both build/netstandard2.0 and buildTransitive/<tfm>/, so $(MSBuildThisFileDirectory) resolves correctly in both layouts.
The target condition (PublishTrimmed and not PublishAot) with the FSharp.Core filename check on ManagedAssemblyToLink is appropriately narrow.
Minor points, none blocking:
_ComputeManagedAssemblyToLink is an SDK-private target. Depending on it is the usual pattern for ILLink-related targets, but it could change in a future SDK. The new F# trimming scenario has no CI test, so a break would go unnoticed. A small packaged-app smoke test (trimmed F# app executing an async test) would guard it.
Reflection-mode F# under AOT. The docs now say AOT is C#-only. If an F# project sets PublishAot, the descriptor is skipped and F# async silently does nothing. A short build warning or a clearer docs note would be friendlier than a silent skip.
The docs repeat the AOT restriction twice, in adjacent sections. One mention would be enough.
Claude and Codex have completed positive reviews of this head. All three inline findings have fixes and resolved threads; CodeRabbit explicitly accepted both preservation fixes.
The current nuget-package-tests-windows check passed. Claude verified that the descriptor is packed beside the targets in both layouts. Automated trimmed packaged-app coverage, including runtime-only FSharp.Core detection and the private SDK target dependency, is tracked in Add packaged trimmed-publish regression coverage for F# async execution #7533 as a nonblocking follow-up.
The suggested Native AOT warning is optional: F#/VB test projects already require reflection mode, and both publishing and language guidance now state the C# support boundary. Keep the restriction visible in both entry points. No further documentation change is needed for this fix.
CodeRabbit's docstring advisory counts existing methods touched by attribute removal; it identifies no missing documentation for a new API. No additional change is needed.
All current CI checks are successful or intentionally skipped. Proceeding through the repository merge wrapper.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
GitHub Actions
Error
![chatgpt-codex-connector[bot]](https://avatars.githubusercontent.com/in/1144995?s=60&v=4){kind=small}
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
Closes #7523.
C# applications without FSharp.Core now publish under Native AOT without unresolved optional-assembly warnings. Trimmed JIT applications that reference FSharp.Core continue to execute F# async values.
Removed the string-based DynamicDependency attributes and replaced them with a packaged linker descriptor preserving FSharpAsync.StartAsTask. TUnit.Core.targets adds that descriptor before PrepareForILLink only when PublishTrimmed is enabled, Native AOT is disabled, and the resolved references include FSharp.Core. Native AOT remains supported for C# test projects, as documented in engine-modes.md.
Validation on .NET SDK 10.0.403, macOS arm64:
The focused F# publish reports existing FSharp.Core IL2040 resource warnings, tracked in dotnet/fsharp#15261; reproduction details were added there. Publishing the complete F# test project with a global PublishTrimmed property cannot validate this configuration because that property also reaches netstandard2.0 analyzer dependencies (NETSDK1124), so the focused app isolates the relevant trimming path.
Summary by CodeRabbit
FSharp.Coreis referenced. The required async functionality is now preserved during trimming, helping these applications continue to work as expected.