F# code generation foundation harness (GH-2969)

[jeremydmiller]

Foundation PR for the phased F# code-generation audit (#2969). This lands the scaffolding every phase depends on — without any of the Phase A frame rework — and proves the regenerate → compile pipeline end-to-end against real Wolverine frames.

The #384 emitter infrastructure (Frame.GenerateFSharpCode seam, FSharpSourceWriter, GeneratedAssembly.GenerateFSharpCode(), Type.FSharpName()) already ships in the pinned JasperFx, so this needs zero JasperFx changes.

What's here

Production (src/Wolverine)

• [FSharpEmit(Skip, Reason)] marker attribute (Configuration/FSharpEmitAttribute.cs) for frames that are deliberately not applicable in F#. An attribute rather than an override because JasperFx's base Frame is a nuget type and Wolverine frames inherit SyncFrame/MethodCall directly (no shared Wolverine base).
• wolverine-diagnostics fsharp-coverage (Diagnostics/WolverineDiagnosticsCommand.cs) — reflects over loaded Wolverine.* assemblies and buckets every Frame into implemented / intentionally-skipped / remaining. Classification is precise: a frame that overrides GenerateCode (custom C#) but not GenerateFSharpCode stays remaining rather than silently inheriting a generic base rendering.
• First real override: MessageContextFrame.GenerateFSharpCode → let messageContext = MessageContext(runtime).

Harness (src/Testing/, 3 projects mirroring the #384 fixture pattern)

• Wolverine.Core.FSharpContracts (C#) — shared contract the generated adapter implements.
• Wolverine.Core.FSharpFixture (F#) — checked-in Generated.fs; FSharp.Core pinned (DisableImplicitFSharpCoreReference + explicit ref) to dodge the documented CS1705/FS0193 version mismatch.
• Wolverine.Core.FSharpTests (C# xUnit) — compile-gate that regenerates Generated.fs from real frames and shells dotnet build on the fixture (one-time FS0193 retry), plus an fsharp-coverage smoke test.

Solution + CI

• wolverine_fsharp.slnx at the repo root — not in wolverine.slnx/wolverine_slim.slnx (per the issue: too many projects in the main solution).
• .github/workflows/fsharp.yml — path-filtered to Frame/Wolverine/Http/Persistence changes + the F# projects. Intended to be made required-for-merge via branch protection on those paths.

Generated F# (the committed fixture)

namespace Wolverine.Core.FSharpFixture.Generated

type GeneratedFoundationProbe() =
    interface Wolverine.Core.FSharpContracts.IFoundationProbe with
        member _.Run(runtime: Wolverine.Runtime.IWolverineRuntime) : unit =
            // Generated by Wolverine F# code generation (GH-2969 foundation probe)
            let messageContext = Wolverine.Runtime.MessageContext(runtime)
            ()

Verification

• dotnet build wolverine_fsharp.slnx -c Release — clean.
• Compile-gate test — generated F# compiles via dotnet build.
• fsharp-coverage — 8 implemented / 0 skipped / 36 remaining / 44 loaded (Wolverine.dll), no throw.
• Full dotnet build wolverine.slnx -c Release regression — 0 warnings, 0 errors.

Not in this PR (next steps)

• Phase A coverage: F# emit on the handler/middleware frames. The real work is the mid-chain return rework in HandlerContinuationFrame / SimpleValidationHandlerFrame / RequirementResultHandlerFrame (F#'s expression-body model has no early return — Next must render inside an if/else branch). The two "hard" frames the issue names (ReadEnvelopeHeaderFrame, TryCatchFinallyFrame) are unreachable in a minimal chain and will be skip-marked.
• Phases B–E (sagas/persistence, Http, Grpc, long tail), the behavioural run-under-host depth, the F# sample, and the docs page.

Part of #2969.

🤖 Generated with Claude Code