Add the F# hot reload session and FCS service surface

docs/hot-reload-rude-edits.md

@@ -0,0 +1,27 @@
+# F# hot reload rude-edit diagnostics
+
+F# hot reload reports an `FSHRDL` diagnostic when an edit cannot be applied safely to the running process. The application is rebuilt and restarted instead of applying a delta that could leave it in an invalid state.
+
+The diagnostic message identifies the affected declaration and the reason for the restart. These codes are owned by the F# compiler and are separate from Roslyn's `ENC` diagnostic namespace.
+
+| Code | Meaning | What to do |
+| --- | --- | --- |
+| `FSHRDL001` | A member signature changed. | Undo the signature change to apply in place, or allow the rebuild and restart. |
+| `FSHRDL002` | An `inline` annotation changed. | Allow the rebuild and restart. |
+| `FSHRDL003` | A type representation or layout changed. | Allow the rebuild and restart. |
+| `FSHRDL004` | A declaration was added in a shape the runtime cannot add. | Allow the rebuild and restart. |
+| `FSHRDL005` | A declaration was removed. | Allow the rebuild and restart. |
+| `FSHRDL006` | A virtual, abstract, or override member was added. | Allow the rebuild and restart. |
+| `FSHRDL007` | A constructor was added. | Allow the rebuild and restart. |
+| `FSHRDL008` | A user-defined operator was added. | Allow the rebuild and restart. |
+| `FSHRDL009` | An explicit interface implementation was added. | Allow the rebuild and restart. |
+| `FSHRDL010` | A member was added to an interface. | Allow the rebuild and restart. |
+| `FSHRDL011` | A field was added in a shape the runtime cannot add. | Allow the rebuild and restart. |
+| `FSHRDL012` | A lambda's lowered shape changed incompatibly. | Allow the rebuild and restart. |
+| `FSHRDL013` | A state machine's resumable or hoisted layout changed incompatibly. | Keep the existing resume-point and captured-value layout, or allow the rebuild and restart. |
+| `FSHRDL014` | A query expression's lowered shape changed incompatibly. | Allow the rebuild and restart. |
+| `FSHRDL015` | A synthesized compiler declaration changed incompatibly. | Allow the rebuild and restart. |
+| `FSHRDL016` | The runtime did not advertise a capability required by the edit. | Update the runtime if a newer version supports the capability, or allow the rebuild and restart. |
+| `FSHRDL099` | The edit is unsupported for another fail-closed reason. | Follow the detailed message and allow the rebuild and restart. |
+
+These diagnostics are intentionally fail closed. If the compiler cannot prove that an edit is safe, it requests a restart and leaves the running application unchanged.

docs/release-notes/.FSharp.Compiler.Service/11.0.100.md

@@ -131,7 +131,9 @@
 
 ### Added
 
+* Add an internal typed-tree diff utility for future F# hot reload edit classification. It is not called by normal compilation. ([PR #20025](https://github.com/dotnet/fsharp/pull/20025))
 * Added internal synthesized-name replay infrastructure for compiler-generated names, preserving normal compilation output while enabling future hot reload name stability work.
+* Added internal F# hot reload delta emitter and symbol matcher infrastructure with direct emitter test coverage. ([PR #20027](https://github.com/dotnet/fsharp/pull/20027))
 * Added `FSharpMemberOrFunctionOrValue.IsPropertyAccessor` convenience property that returns true for compiler-generated property accessors (`get_X` / `set_X`). ([Issue #18157](https://github.com/dotnet/fsharp/issues/18157), [PR #19883](https://github.com/dotnet/fsharp/pull/19883))
 * Added warning FS3884 when a function or delegate value is used as an interpolated string argument. ([PR #19289](https://github.com/dotnet/fsharp/pull/19289))
 * Symbols: add ObsoleteDiagnosticInfo ([PR #19359](https://github.com/dotnet/fsharp/pull/19359))
@@ -144,7 +146,10 @@
 * Checker: recover on checking language version ([PR ##19970](https://github.com/dotnet/fsharp/pull/19970))
 * Implied argument names for function-to-delegate coercions now fall back to the delegate's `Invoke` parameter names when the function has no recoverable names (e.g. a partial application like `System.Func<int, int>((+) 1)`), instead of synthetic `delegateArg0`, `delegateArg1`, … names. ([PR #20001](https://github.com/dotnet/fsharp/pull/20001))
 * Add internal `ResetCompilerGeneratedNameState` to `CompilerGlobalState` name generators so warm-checker re-compilation can produce fresh-process-identical generated names. ([PR #20017](https://github.com/dotnet/fsharp/pull/20017))
+* Add internal ECMA-335 Edit-and-Continue metadata delta writer to AbstractIL. ([PR #20019](https://github.com/dotnet/fsharp/pull/20019))
 * Add Roslyn-format EnC CustomDebugInformation codec and portable PDB method CDI emission support to AbstractIL. ([PR #20018](https://github.com/dotnet/fsharp/pull/20018))
+* Add an experimental `FSharpChecker` hot reload session API with per-project baselines, capability-gated delta emission, and `Commit`/`Discard` transaction semantics. Off by default behind `--test:HotReloadDeltas`. ([Issue #11636](https://github.com/dotnet/fsharp/issues/11636), [PR #20030](https://github.com/dotnet/fsharp/pull/20030))
+* Add internal hot reload baseline reading for recorded EnC state and synthesized-name snapshot PDB data. ([PR #20026](https://github.com/dotnet/fsharp/pull/20026))
 
 ### Improved
 

src/Compiler/AbstractIL/DeltaIndexSizing.fs

@@ -0,0 +1,186 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+/// Computes coded index sizing for delta metadata emission.
+///
+/// This module determines whether various metadata indices require 2 or 4 bytes
+/// based on row counts in the metadata tables. This is per ECMA-335 II.24.2.6.
+///
+/// Uses TableNames from BinaryConstants.fs for ECMA-335 metadata table indices,
+/// following the same pattern as the baseline IL writer (ilwrite.fs).
+module internal FSharp.Compiler.AbstractIL.DeltaIndexSizing
+
+open FSharp.Compiler.AbstractIL.BinaryConstants
+open FSharp.Compiler.AbstractIL.ILDeltaHandles
+open FSharp.Compiler.AbstractIL.DeltaMetadataEncoding
+
+type MetadataHeapSizes = FSharp.Compiler.AbstractIL.ILBinaryWriter.MetadataHeapSizes
+
+/// Holds computed "bigness" flags for all coded index types.
+/// When true, the index requires 4 bytes; when false, 2 bytes suffice.
+type CodedIndexSizes =
+    {
+        StringsBig: bool
+        GuidsBig: bool
+        BlobsBig: bool
+        SimpleIndexBig: bool[]
+        TypeDefOrRefBig: bool
+        TypeOrMethodDefBig: bool
+        HasConstantBig: bool
+        HasCustomAttributeBig: bool
+        HasFieldMarshalBig: bool
+        HasDeclSecurityBig: bool
+        MemberRefParentBig: bool
+        HasSemanticsBig: bool
+        MethodDefOrRefBig: bool
+        MemberForwardedBig: bool
+        ImplementationBig: bool
+        CustomAttributeTypeBig: bool
+        ResolutionScopeBig: bool
+    }
+
+let private tableSize (tableRowCounts: int[]) (table: int) = tableRowCounts.[table]
+
+let private totalRowCount (tableRowCounts: int[]) (externalRowCounts: int[]) (table: int) =
+    let index = table
+
+    let external =
+        if externalRowCounts.Length = tableRowCounts.Length then
+            externalRowCounts.[index]
+        else
+            0
+
+    tableRowCounts.[index] + external
+
+let private referenceExceedsLimit (tableRowCounts: int[]) (externalRowCounts: int[]) (maxValueExclusive: int) (tables: int[]) =
+    tables
+    |> Array.exists (fun table -> totalRowCount tableRowCounts externalRowCounts table >= maxValueExclusive)
+
+/// Determines if a coded index requires 4 bytes (big) or 2 bytes (small).
+/// For EnC deltas (uncompressed), all indices are 4 bytes.
+/// For compressed metadata, size depends on whether any referenced table
+/// has enough rows to overflow the available bits after the tag.
+let private codedBigness (tagBits: int) (tableRowCounts: int[]) (externalRowCounts: int[]) (isCompressed: bool) (tables: int[]) =
+    if not isCompressed then
+        // EnC deltas always use 4-byte indices
+        true
+    else
+        let limit = pown 2 (16 - tagBits)
+        referenceExceedsLimit tableRowCounts externalRowCounts limit tables
+
+let private isSimpleIndexBig (tableRowCounts: int[]) (externalRowCounts: int[]) (isCompressed: bool) (tableIndex: int) =
+    if not isCompressed then
+        true
+    else
+        let local =
+            if tableIndex < tableRowCounts.Length then
+                tableRowCounts.[tableIndex]
+            else
+                0
+
+        let external =
+            if tableIndex < externalRowCounts.Length then
+                externalRowCounts.[tableIndex]
+            else
+                0
+
+        local + external >= 0x10000
+
+/// Compute coded index sizes for all index types.
+/// This determines the byte width of each reference type in the metadata tables.
+let compute (tableRowCounts: int[]) (externalRowCounts: int[]) (heapSizes: MetadataHeapSizes) (isEncDelta: bool) : CodedIndexSizes =
+
+    let isCompressed = not isEncDelta
+
+    // Heap indices: 4 bytes if uncompressed or heap >= 64KB
+    let stringsBig = (not isCompressed) || heapSizes.StringHeapSize >= 0x10000
+    let blobsBig = (not isCompressed) || heapSizes.BlobHeapSize >= 0x10000
+    let guidsBig = (not isCompressed) || heapSizes.GuidHeapSize >= 0x10000
+
+    // Simple table indices
+    let simpleIndexBig =
+        Array.init DeltaTokens.TableCount (fun i -> isSimpleIndexBig tableRowCounts externalRowCounts isCompressed i)
+
+    // Helper to compute coded index bigness for a set of tables
+    let coded tag tables =
+        codedBigness tag tableRowCounts externalRowCounts isCompressed tables
+
+    // -------------------------------------------------------------------------
+    // Coded Index Definitions (per ECMA-335 II.24.2.6)
+    // -------------------------------------------------------------------------
+    // Each coded index combines a tag (to identify which table) with a row index.
+    // The tag uses the low N bits; the row index uses the remaining bits.
+    // If any table in the coded index exceeds (2^(16-N) - 1) rows, we need 4 bytes.
+
+    // TypeDefOrRef: TypeDef(0), TypeRef(1), TypeSpec(2) - 2-bit tag
+    let typeDefOrRefBig =
+        coded CodedIndices.TypeDefOrRef.TagBits CodedIndices.TypeDefOrRef.Tables
+
+    // TypeOrMethodDef: TypeDef(0), MethodDef(1) - 1-bit tag
+    let typeOrMethodDefBig =
+        coded CodedIndices.TypeOrMethodDef.TagBits CodedIndices.TypeOrMethodDef.Tables
+
+    // HasConstant: Field(0), Param(1), Property(2) - 2-bit tag
+    let hasConstantBig =
+        coded CodedIndices.HasConstant.TagBits CodedIndices.HasConstant.Tables
+
+    // HasCustomAttribute: 22 possible parent types - 5-bit tag
+    // This is the largest coded index, covering most metadata entities
+    let hasCustomAttributeBig =
+        coded CodedIndices.HasCustomAttribute.TagBits CodedIndices.HasCustomAttribute.Tables
+
+    // HasFieldMarshal: Field(0), Param(1) - 1-bit tag
+    let hasFieldMarshalBig =
+        coded CodedIndices.HasFieldMarshal.TagBits CodedIndices.HasFieldMarshal.Tables
+
+    // HasDeclSecurity: TypeDef(0), MethodDef(1), Assembly(2) - 2-bit tag
+    let hasDeclSecurityBig =
+        coded CodedIndices.HasDeclSecurity.TagBits CodedIndices.HasDeclSecurity.Tables
+
+    // MemberRefParent: TypeDef(0), TypeRef(1), ModuleRef(2), MethodDef(3), TypeSpec(4) - 3-bit tag
+    let memberRefParentBig =
+        coded CodedIndices.MemberRefParent.TagBits CodedIndices.MemberRefParent.Tables
+
+    // HasSemantics: Event(0), Property(1) - 1-bit tag
+    let hasSemanticsBig =
+        coded CodedIndices.HasSemantics.TagBits CodedIndices.HasSemantics.Tables
+
+    // MethodDefOrRef: MethodDef(0), MemberRef(1) - 1-bit tag
+    let methodDefOrRefBig =
+        coded CodedIndices.MethodDefOrRef.TagBits CodedIndices.MethodDefOrRef.Tables
+
+    // MemberForwarded: Field(0), MethodDef(1) - 1-bit tag
+    let memberForwardedBig =
+        coded CodedIndices.MemberForwarded.TagBits CodedIndices.MemberForwarded.Tables
+
+    // Implementation: File(0), AssemblyRef(1), ExportedType(2) - 2-bit tag
+    let implementationBig =
+        coded CodedIndices.Implementation.TagBits CodedIndices.Implementation.Tables
+
+    // CustomAttributeType: MethodDef(2), MemberRef(3) - 3-bit tag
+    // Note: tags 0, 1, 4 are reserved/unused
+    let customAttributeTypeBig =
+        coded CodedIndices.CustomAttributeType.TagBits CodedIndices.CustomAttributeType.Tables
+
+    // ResolutionScope: Module(0), ModuleRef(1), AssemblyRef(2), TypeRef(3) - 2-bit tag
+    let resolutionScopeBig =
+        coded CodedIndices.ResolutionScope.TagBits CodedIndices.ResolutionScope.Tables
+
+    {
+        StringsBig = stringsBig
+        GuidsBig = guidsBig
+        BlobsBig = blobsBig
+        SimpleIndexBig = simpleIndexBig
+        TypeDefOrRefBig = typeDefOrRefBig
+        TypeOrMethodDefBig = typeOrMethodDefBig
+        HasConstantBig = hasConstantBig
+        HasCustomAttributeBig = hasCustomAttributeBig
+        HasFieldMarshalBig = hasFieldMarshalBig
+        HasDeclSecurityBig = hasDeclSecurityBig
+        MemberRefParentBig = memberRefParentBig
+        HasSemanticsBig = hasSemanticsBig
+        MethodDefOrRefBig = methodDefOrRefBig
+        MemberForwardedBig = memberForwardedBig
+        ImplementationBig = implementationBig
+        CustomAttributeTypeBig = customAttributeTypeBig
+        ResolutionScopeBig = resolutionScopeBig
+    }