F# code generation for the pre-generated code model (#383) — Milestone 1

[jeremydmiller]

Implements Milestone 1 of #383 and several follow-on increments: emit F# as an alternative to C# for the pre-generated (static) code model only (never in-memory Roslyn). The C# path is untouched — every new per-frame member is virtual with a default-throw NotSupportedException, so existing frames keep compiling and working.

Writer + seam (Phase 1)

• CodeGeneration/FSharp/FSharpSourceWriter.cs : ISourceWriter — BLOCK:/END/FinishBlock indent/dedent without braces (F# significant whitespace); line writing + backtick→" identical to the C# writer.
• Frame.GenerateFSharpCode(...) — virtual, default-throws naming the frame.
• Variable.FSharpAssignmentUsage + Mutable flag (let vs let mutable).
• Type.FSharpName() — F# primitive aliases (double→float, void→unit, …), arrays, closed generics; throws loudly on open generics / tuples / by-ref.

Outer emit layers (Phase 2)

• GeneratedAssembly.GenerateFSharpCode (namespace + open + types at column 0)
• GeneratedType.WriteFSharp (primary ctor, let _x = x fields, interface-member grouping, base-class inherit)
• GeneratedMethod.WriteFSharpMethod (member signature; drives the same arranged frame chain)

Frames

• Statement frames: CommentFrame, CodeFrame, ConstructorFrame, MethodCall, ReturnFrame. F# is expression-oriented, so ReturnFrame emits a bare trailing expression outside a task block and return x inside one.
• Control-flow frames: CompositeFrame (parallel F# chaining + a generateFSharpCode hook), IfBlock (if cond then), IfElseNullGuardFrame (if isNull x then … else …) + its IfNullGuardFrame (if not (isNull x) then), and TryFinallyWrapperFrame (try … finally …).

Async-mode matrix & emit refinements

A task { } block is emitted iff AsyncMode == AsyncTask:

• AsyncTask → task { … let! … return … }
• ReturnFromLastNode → the trailing Task is returned directly (member _.M(...) = svc.FooAsync(args)) — no task { } / return!
• None + non-generic Task return → side-effect frames then a trailing Task.CompletedTask (the synchronous-handler-with-a-Task-signature shape)
• let mutable → MethodCall.AssignResultTo marks its target Mutable, so a reassigned local renders let mutable x = … then x <- … (no-op on the C# path and for args/injected fields)
• open coverage → derived from injected fields plus base/interface/return/argument types (recursing into generic args), via an F#-only AllReferencedFSharpNamespaces

Fixtures + command + gate (Phase 4)

• FSharpCodegenTarget (C# contracts), CodegenTests.FSharpFixture (checked-in .fsproj + committed Generated.fs), CodegenTests.FSharp (the codegen-fsharp command, sample builder, and the integration test that regenerates Generated.fs and shells out to dotnet build).
• The integration-test project is intentionally not wired into ./build.sh / Nuke test targets. Run it with dotnet test src/CodegenTests.FSharp. The gate retries once on a transient internal F# compiler crash (FS0193) — a real error in Generated.fs is deterministic and still fails.
• The fixture gates 9 generated types: sync, task { } async, direct-async (ReturnFromLastNode), sync-Task (Task.CompletedTask), let mutable reassignment, if/then, if/else null guard, try/finally, and a Wolverine-shaped async handler (construct → do! save → sync factory → return).

Acceptance criteria

• All generated F# fixture types compile via dotnet build (exit 0)
• Full C# suite stays green — CodegenTests 389, CoreTests 439, CommandLineTests 285, EventTests 302 (net9/net10), + AOT smoke
• Every unimplemented frame throws a clear NotSupportedException naming itself

Still deferred (guarded by the default-throw seam)

• Constructor property setters, value-tuples, ActivityEvents
• Task<T> returned from a synchronous body (would need Task.FromResult)
• Generics-heavy frames and the full Wolverine frame set — to be exercised against Wolverine via a local project reference before any nuget

Commits

1. M1 — F# code generation
2. async task { } gate
3. let mutable + idiomatic ReturnFromLastNode
4. control-flow frames (if / if-else null guard / try-finally)
5. broaden open coverage
6. Wolverine-shaped async handler fixture
7. synchronous Task-returning methods (Task.CompletedTask) + gate hardening

🤖 Generated with Claude Code