[thomhurst]

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:

• 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.

[chatgpt-codex-connector]

Codex Review Summary

This comment shows the latest Codex review activity on this pull request.

Review	Status	Commit	Review trigger
📝 Code Review	✅ Completed 2026-11-03T23:54:38.019414Z	e4c4769	New commits

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.

[coderabbitai]

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.

Changes: F# async support and AOT guidance

Layer / File(s)	Summary
Conditional F# linker preservation src/TUnit.Core/TUnit.Core.FSharp.xml, src/TUnit.Core/TUnit.Core.csproj, src/TUnit.Core/TUnit.Core.targets	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.

Estimated code review effort: 2 (Simple) | ~10 minutes

Change: Bug fix · Severity of issue fixed: Low

Merge Risk: Minimal · up to e4c47

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.

Share

• X
• Mastodon
• Reddit
• LinkedIn

_{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.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: bdb39953fa

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[greptile-apps]

Confidence Score: 5/5

[Medium impact] The PR appears safe to merge; no actionable new issues were found.

Summary

Preserves optional F# async support through a packaged linker descriptor instead of string-based DynamicDependency attributes.

• Trimmed JIT tests keep F# async support without optional-assembly warnings in C# AOT publishes.

_{Reviews (3) · Last reviewed commit: "fix(core): preserve runtime-only FSharp ..." · Reviewed by Greptile}

[coderabbitai]

• Fix comments: Fix CodeRabbit comments on this PR

[github-actions]

Review: looks good.

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]

Review dispositions for 35d8a4d:

• 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.

[github-actions]

Review of #7526

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.

[coderabbitai]

• Fix comments: Fix CodeRabbit comments on this PR

[thomhurst]

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.

[github-actions]

Review

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:

1. _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.
2. 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.
3. The docs repeat the AOT restriction twice, in adjacent sections. One mention would be enough.

Looks good to merge once CI is green.

[thomhurst]

Final review disposition for e4c4769:

• 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.