Emit class-form resumable state machines under hot reload (EnC)

Add an Edit-and-Continue codegen mode (--test:HotReloadClassStateMachines)
that lowers task/taskSeq/user resumable computation expressions to
reference-type (class) state machines instead of structs, so adding,
removing, or reordering a let!/do!/yield becomes an
AddInstanceFieldToExistingType + method update at runtime rather than a
forbidden value-type re-layout. This mirrors Roslyn's struct->class flip
under EnC, generalized to the resumable-code substrate (the gate lives in
the shared GenStructStateMachine).

- IlxGen: boxity threaded through TemplateReplacement; class type-def
  (parameterless ctor, newobj, reference-based capture init); a byref-this
  bridge (spill 'this' to a byref local via ldarga + ldobj deref before
  field access) so the byref-threaded resumable ABI works on a reference type.
- TypedTreeDiff: under class mode a resumable-member shape change is an
  allowed, capability-gated method/field update rather than a
  StateMachineShapeChange rude edit.
- IlxDeltaEmitter: a fresh instance field on an existing compiler-generated
  class state machine is emitted as an added field
  (AddInstanceFieldToExistingType) instead of being skipped.
- TcGlobals/TcConfig: the flag drives codegen and the classifier consistently
  across the baseline and delta compiles.
- Tests: runtime ApplyUpdate parity tests (add/remove let!, add inside a loop,
  backgroundTask) for the edits Roslyn allows.

Flag-off is byte-identical (mkILValueTy = mkILNamedTy AsValue); the deref and
spill only fire under an active class-state-machine template replacement.

Author: NatElkins

src/Compiler/CodeGen/IlxDeltaEmitter.fs

@@ -3773,6 +3773,23 @@ let emitDeltaWithDebugData (freshDebugPdb: byte[] option) (request: IlxDeltaRequ
                         $"Edit adds instance field '{fieldDisplay}' to a struct; struct layouts cannot change under hot reload. Please rebuild."
 
                 raise (HotReloadUnsupportedEditException message)
+            | None when
+                not fieldDef.IsStatic
+                && not typeDef.IsStructOrEnum
+                && request.Baseline.TypeTokens |> Map.containsKey baselineDeclaringType
+                ->
+                // A fresh instance field on an EXISTING compiler-generated CLASS: a class-form
+                // resumable state machine (hot reload) that gained a hoisted local / awaiter
+                // when a let!/do!/yield was added. Unlike a struct, a reference type CAN grow at
+                // runtime (AddInstanceFieldToExistingType), so the field must be emitted rather
+                // than dropped by the synthesized-name skip below - the patched MoveNext
+                // references it, and dropping it crashes at runtime with an invalid field token.
+                // (Must run before the synthesized-name skip and after the struct-layout gate.)
+                if not (addedFieldTokens.ContainsKey fieldKey) then
+                    let newFieldToken =
+                        emittedTokenMappings.FieldDefTokenMap (enclosing, typeDef) fieldDef
+
+                    addedFieldTokens[fieldKey] <- newFieldToken
             | None when synthesizedBuckets.IsSome && IsCompilerGeneratedName typeDef.Name -> ()
             | None when
                 (fieldDef.IsStatic || not typeDef.IsStructOrEnum)

src/Compiler/CodeGen/IlxGen.fs

@@ -741,6 +741,8 @@ type TcConfigBuilder =
 
         mutable realsig: bool
 
+        mutable emitHotReloadClassStateMachines: bool
+
         mutable compilationMode: TcGlobals.CompilationMode
     }
 
@@ -942,6 +944,7 @@ type TcConfigBuilder =
                 }
             dumpSignatureData = false
             realsig = false
+            emitHotReloadClassStateMachines = false
             strictIndentation = None
             compilationMode = TcGlobals.CompilationMode.Unset
         }
@@ -1487,6 +1490,7 @@ type TcConfig private (data: TcConfigBuilder, validate: bool) =
     member _.typeCheckingConfig = data.typeCheckingConfig
     member _.dumpSignatureData = data.dumpSignatureData
     member _.realsig = data.realsig
+    member _.emitHotReloadClassStateMachines = data.emitHotReloadClassStateMachines
     member _.compilationMode = data.compilationMode
 
     static member Create(builder, validate) =

src/Compiler/Driver/CompilerConfig.fs

@@ -590,6 +590,8 @@ type TcConfigBuilder =
 
         mutable realsig: bool
 
+        mutable emitHotReloadClassStateMachines: bool
+
         mutable compilationMode: TcGlobals.CompilationMode
     }
 
@@ -965,6 +967,8 @@ type TcConfig =
 
     member realsig: bool
 
+    member emitHotReloadClassStateMachines: bool
+
     member compilationMode: TcGlobals.CompilationMode
 
 /// Represents a computation to return a TcConfig. Normally this is just a constant immutable TcConfig,

src/Compiler/Driver/CompilerConfig.fsi

@@ -2602,6 +2602,7 @@ and [<Sealed>] TcImports
                     tcConfig.pathMap,
                     tcConfig.langVersion,
                     tcConfig.realsig,
+                    tcConfig.emitHotReloadClassStateMachines,
                     tcConfig.compilationMode
                 )
 

src/Compiler/Driver/CompilerImports.fs

@@ -1469,6 +1469,13 @@ let testFlag tcConfigB =
                 // Hook-only replay mode: keeps synthesized-name replay active for hot reload sessions
                 // without enabling baseline-capture emission for the current compilation.
                 configureHotReloadEmitHook tcConfigB
+            | "HotReloadClassStateMachines" ->
+                // Emit resumable (task/taskSeq/user CE) state machines as reference types
+                // (classes) so adding/removing a let!/do!/yield is an
+                // AddInstanceFieldToExistingType + method update (Roslyn parity) rather than a
+                // forbidden struct re-layout. Must be set on BOTH the baseline and the delta
+                // compile so they agree on the state machine shape.
+                tcConfigB.emitHotReloadClassStateMachines <- true
 #if DEBUG
             | "ShowParserStackOnParseError" -> showParserStackOnParseError <- true
 #endif

src/Compiler/Driver/CompilerOptions.fs

@@ -563,7 +563,8 @@ type FrameworkImportsCache(size) =
         // and updated realsig and langversion
         let tcGlobals =
             if tcGlobals.langVersion <> tcConfig.langVersion
-                || tcGlobals.realsig <> tcConfig.realsig then
+                || tcGlobals.realsig <> tcConfig.realsig
+                || tcGlobals.emitHotReloadClassStateMachines <> tcConfig.emitHotReloadClassStateMachines then
                     TcGlobals(
                         tcGlobals.compilingFSharpCore,
                         tcGlobals.ilg,
@@ -578,6 +579,7 @@ type FrameworkImportsCache(size) =
                         tcGlobals.pathMap,
                         tcConfig.langVersion,
                         tcConfig.realsig,
+                        tcConfig.emitHotReloadClassStateMachines,
                         tcConfig.compilationMode
                     )
 

src/Compiler/Service/IncrementalBuild.fs

@@ -969,6 +969,7 @@ type internal TransparentCompiler
                     if
                         tcGlobals.langVersion <> tcConfig.langVersion
                         || tcGlobals.realsig <> tcConfig.realsig
+                        || tcGlobals.emitHotReloadClassStateMachines <> tcConfig.emitHotReloadClassStateMachines
                     then
                         TcGlobals(
                             tcGlobals.compilingFSharpCore,
@@ -984,6 +985,7 @@ type internal TransparentCompiler
                             tcGlobals.pathMap,
                             tcConfig.langVersion,
                             tcConfig.realsig,
+                            tcConfig.emitHotReloadClassStateMachines,
                             tcConfig.compilationMode
                         )
                     else

src/Compiler/Service/TransparentCompiler.fs

@@ -197,6 +197,7 @@ type TcGlobals(
     pathMap: PathMap,
     langVersion: LanguageVersion,
     realsig: bool,
+    emitHotReloadClassStateMachines: bool,
     compilationMode: CompilationMode) =
 
   let v_langFeatureNullness = langVersion.SupportsFeature LanguageFeature.NullnessChecking
@@ -1145,6 +1146,11 @@ type TcGlobals(
 
   member _.realsig = realsig
 
+  /// Hot reload: emit resumable (task/taskSeq/user CE) state machines as reference types
+  /// (classes) so adding/removing a let!/do!/yield is an AddInstanceFieldToExistingType +
+  /// method update rather than a forbidden struct re-layout. Set by --test:HotReloadClassStateMachines.
+  member _.emitHotReloadClassStateMachines = emitHotReloadClassStateMachines
+
   member _.unionCaseRefEq x y = primUnionCaseRefEq compilingFSharpCore fslibCcu x y
 
   member _.valRefEq x y = primValRefEq compilingFSharpCore fslibCcu x y

src/Compiler/TypedTree/TcGlobals.fs

@@ -151,6 +151,7 @@ type internal TcGlobals =
         pathMap: Internal.Utilities.PathMap *
         langVersion: Features.LanguageVersion *
         realsig: bool *
+        emitHotReloadClassStateMachines: bool *
         compilationMode: CompilationMode ->
             TcGlobals
 
@@ -901,6 +902,11 @@ type internal TcGlobals =
 
     member realsig: bool
 
+    /// Hot reload: emit resumable (task/taskSeq/user CE) state machines as reference types
+    /// (classes), so adding/removing a let!/do!/yield is an AddInstanceFieldToExistingType +
+    /// method update rather than a forbidden struct re-layout.
+    member emitHotReloadClassStateMachines: bool
+
     member ref_tuple1_tcr: TypedTree.EntityRef
 
     member ref_tuple2_tcr: TypedTree.EntityRef