- Revert Determinism CI job back to Debug: Release exposes pre-existing
  TypeDefsBuilder races unrelated to this fix, causing flaky failures.
  Release coverage belongs in a follow-up when all races are fixed.
- Add regression test exercising DetupleArgs + TLR with tuple-arg
  functions and nested lambdas across 8 files (#19732).

Co-authored-by: Copilot <[email protected]>

Reverting CI to Debug was a hack. The Release determinism job is meant
to fail when non-determinism slips into the compiler; that is exactly
its job. Pre-existing races (TypeDefsBuilder counter, ConcurrentStack
drain, NiceNameGenerator) must be fixed at source, not papered over.

Co-authored-by: Copilot <[email protected]>

Two additional Release-only determinism races:

1. AssemblyBuilder.GrabExtraBindingsToGenerate (IlxGen.fs):
   Anonymous-record augmentation bindings are pushed onto a ConcurrentStack
   from many parallel file-gen threads, so the drain order is racy. Sort
   the drained bindings by source position using valSourceOrderKey before
   feeding them into CodeGenMethod. The baseline shifts are exactly the
   reorder of anon-record .Equals/.CompareTo/.GetHashCode overloads.

2. ParseInputFilesInParallel (ParseAndCheckInputs.fs):
   FileIndex values are allocated lazily under a lock keyed by parse-time
   first-touch. With parallel parsing this assigns indices in a thread-
   interleaved order. Indices leak into IL via debug info, NiceNameGenerator
   keys ((basicName, FileIndex)), and any downstream sort using FileIndex.
   Pre-register indices in source-file order before kicking off the parallel
   parse so file 0 always gets the first index.

Baseline updates:
  EmittedIL/Misc/AnonRecd.fs.il.netcore.bsl
  EmittedIL/Nullness/AnonRecords.fs.il.netcore.bsl
Both are pure reorderings of overloaded compiler-generated members.

Co-authored-by: Copilot <[email protected]>

Differential testing (compile same project twice, once with
--parallelcompilation+ and once with --parallelcompilation- + --test:ParallelOff)
revealed that the order of methods within a class diverged between the two
modes for TLR-lifted helpers (e.g. nested 'composed@N' methods).

Root cause: in sequential mode (delayCodeGen = false), method bodies were
generated inline during the sequential file walk, so inner AddMethodDef
calls (for TLR helpers discovered during body codegen) interleaved with
outer ones in source order. In parallel mode (delayCodeGen = true), method
bodies were deferred and forced later, so inner AddMethodDef calls happened
AFTER the outer method def was already registered.

Two complementary fixes:

1. TypeDefBuilder: tag every AddMethodDef / AddFieldDef / AddEventDef
   with (batchIndex, intraIndex) and sort at Close time. Sequential phase
   uses batch 0 with a shared counter; each parallel file batch gets its
   own batchIndex via ParallelCodeGenContext. Adds are now lock-protected
   because multiple parallel batches can target the same TypeDef
   (StartupCode$, AnonymousType$, augmentation types).

2. Always set delayCodeGen = true in GenerateCode, regardless of
   parallelIlxGen. Parallel vs sequential only affects whether the
   deferred file batches are forced via ArrayParallel.iteri or
   Array.iteri. This normalizes AddMethodDef timing across modes.

Component test: 'Parallel and sequential compilation must produce identical
assemblies' (DeterministicTests.fs). 12 files exercising TLR + anon records.
Verified to fail without (2) and pass with it.

All 1172 EmittedIL component tests still pass with no baseline changes.

Co-authored-by: Copilot <[email protected]>

…est hardening

Addresses cross-model consensus from 21-agent adversarial review:

- valSourceOrderKey: document Val.Stamp tiebreaker hazard and pair every
  callsite with assertValSourceOrderKeyUnique (debug-only) so any future
  collision on the build-stable prefix (FileIndex, line, col, LogicalName)
  fires an assertion instead of silently reintroducing #19732.
- IlxGen TypeDefBuilder: extract tagInitial helper, deduplicate triplicated
  List.mapi tagging, rename NextIntra -> NextIntraBatchIndex, replace the
  two hand-rolled while loops in Append/PrependInstructionsToSpecificMethodDef
  with Seq.tryFindIndex, lock-protect gproperties for parity with
  gmethods/gfields/gevents, and lock the gmethods scans in those Append/
  Prepend members instead of relying on an implicit post-join invariant.
- azure-pipelines-PR.yml Determinism_Release: drop the duplicate
  experimental_features matrix leg (both legs set _experimental_flag: '',
  giving identical coverage at double the CI cost).
- DeterministicTests: switch to createTemporaryDirectory(), wrap test body
  in try/finally so artifacts survive on failure, drop sprintf+15-positional
  args in favour of $"""...""" interpolation matching the rest of the file,
  and eliminate the verbatim File1 duplicate by routing the primary source
  through the same fileSource helper.
- Release note: replace the overclaimed 'Release MVID reproducible' with a
  precise description of what the differential test and CI job actually prove.

Co-authored-by: Copilot <[email protected]>

… trim prose

Addresses round-1 cross-model review consensus:

- D8 (PR compactness): drop the lock on gproperties and the locks around
  the gmethods scans in Append/PrependInstructionsToSpecificMethodDef. Those
  members are called only from the main thread after the parallel codegen
  join in CodegenAssembly, so the locks were speculative defensive code
  (their own comment admitted as much). Add a one-line invariant note in
  place of the locks.
- D5 vs D8 tension: drop assertValSourceOrderKeyUnique entirely. Running
  the EmittedIL suite with the assertion promoted from Debug.Assert to
  failwith showed that synthetic Vals at the same source location DO
  legitimately collide on the build-stable prefix (e.g. e1/e2 generic
  compare-augmentation parameters at file 0, line 1, col 0). The collision
  is real but harmless in practice because those Vals are created together
  by a single pass and therefore receive monotonic Stamp values within one
  process. Rely on the differential
  'Parallel and sequential compilation must produce identical assemblies'
  component test as the regression guard instead of an always-failing
  precondition that would block normal compilation.
- D8: trim TypeDefsBuilder.Close (9-line comment -> 3), trim delayCodeGen=true
  rationale (5 lines -> 3), trim the release-note bullet, drop the .fsi/.fs
  duplication on valSourceOrderKey.

All 1172 EmittedIL component tests, 21 DeterministicTests, and the local
/tmp/det-diff seq-vs-par differential all pass.

Co-authored-by: Copilot <[email protected]>

Build 1443688 surfaced three deterministic-IL-related failures that the
previous netcore-only baseline updates did not cover:

* WindowsCompressedMetadata_Desktop Batch1 - EmittedIL.RealInternalSignature.Misc.AnonRecd_fs
* WindowsCompressedMetadata_Desktop Batch2 - EmittedIL.NullnessMetadata 'Nullable attr for anon records'
* Build_And_Test_AOT_Windows (classic + compressed) - StaticLinkedFSharpCore trim size

The IlxGen emit-order stabilization changes anon-record method order
identically on .NET Framework and .NET, so mirror the netcore.bsl
reordering into the matching net472.bsl files (CompareTo(obj) before
CompareTo(typed); Equals(obj)/Equals(typed)/Equals(obj,comp)/Equals(typed,comp)
before GetHashCode()/GetHashCode(comp)). Bump the trimmed
StaticLinkedFSharpCore_Trimming_Test.dll expected size from 9168384 to
9177088 bytes to track the new deterministic emit.

Co-authored-by: Copilot <[email protected]>

The default 'same' mode (build twice with identical flags) only catches
non-determinism that happens to fire between two runs of the same code
path. The new 'seq-vs-par' mode builds the compiler once with
--parallelcompilation- --test:ParallelOff and once with --parallelcompilation+,
then MD5-compares all outputs. Any divergence between the two scheduling
modes is a deterministic 1-shot failure, converting the probabilistic test
of #19732 / PR #19810 into a regression gate without retries.

Threads an AdditionalFscCmdFlags MSBuild property through Run-Build that
flows into the existing OtherFlags wiring; the flag pair is empty in
'same' mode so behaviour is byte-identical to today.

Verified locally on macOS that the in-process equivalent of these flag
pairs produces (a) divergent MVIDs on pre-fix bdb847a and (b) identical
MVIDs on the current head, so the CI signal will fail before the fix lands
and pass after.

Co-authored-by: Copilot <[email protected]>

The race-detector leg keeps catching schedule-divergent non-determinism on
the same code path. The new seq-vs-par leg deterministically catches any
divergence between --parallelcompilation+ and --parallelcompilation- on the
full compiler self-build in one shot — converting the probabilistic
regression test of #19732 into a hard gate.

Co-authored-by: Copilot <[email protected]>

These are local-only investigation harness files from a subagent's working
directory; they should not be in the repo. Adds .scratch/ to .gitignore.

Co-authored-by: Copilot <[email protected]>

The local 12-file harness shows seq == par with the full PR applied, but
the empirical experiment at full compiler scale (build 1443778, log 268)
revealed that FSharp.Compiler.Service.dll and FSharp.Core.dll still differ
between sequential and parallel compilation at the whole-self-build scale.

There are evidently additional non-determinism sources that only surface at
the ~700-file compiler-self-build size which this PR has not yet identified
and fixed. Rather than block PR merge on a stronger invariant that isn't
fully achieved, mark the new leg as informational (continueOnError: true)
so it provides data without gating. The original race-detector leg
(build-twice-identical) PASSES and is the actual #19732 contract.

Co-authored-by: Copilot <[email protected]>

…eOnError)"

This reverts commit 87cdc4c.

After the safe inline strip-top-lambda fix (a3d8690), the
PrimeStableNamesForCodegen walk visits additional binding bodies
correctly, producing a small further shift in closure suffix
counters and method ordering for 60 RealInternalSignature tests.

These were missed in the original 327-file regen because that
batch was generated against the pre-Phase-1.8 compiler.

Co-authored-by: Copilot <[email protected]>

5 test files updated to match the new IL emission produced by the
deterministic parallel-codegen fixes:

 * tests/FSharp.Compiler.ComponentTests/Interop/StaticsInInterfaces.fs
   - "F# can call interface with static abstract method": within-type
     method order changes (.ctor then 'Tests.Test.IAdditionOperator...
     .op_Addition' then get_Value, sorted by Name+insertion-idx).

 * tests/FSharp.Compiler.ComponentTests/Conformance/Types/UnionTypes/
   UnionStructTypes.fs
   - "Struct DU compilation - have a look at IL for massive cases":
     verifyIL fragment list reordered to match the new actual-emit
     order (.ctor, NewCase3, get_Case11, get_IsCase3). Sub-agent dispatch
     for this test was inaccurate (reported test passing without changes)
     — fixed by hand. Also added missing 'instance bool' specifier on
     get_IsCase3 to match actual.

 * tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/
   StaticLet/StaticLetInUnionsAndRecords.fs
   - 4 tests updated (per sub-agent fix-staticlet-il): method/field
     reordering inside MyTypes.X classes, new unconditional empty .cctor
     stubs added to module classes, new .ctor inserted between .cctor
     and GetMyName in StaticLetInGenericRecordsILtest.

 * tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/
   MethodResolution/OptionalAndOutParameters.fs.RealInternalSignature*.bsl
   - 2 .bsl baselines regenerated (alphabetical method/field reordering
     inside $OutOptionalTests module + new module .cctor stub).

After these changes, full FSharp.Compiler.ComponentTests run shows only
3 failures, all confirmed pre-existing on origin/main on macOS arm64:
   - Language.InterpolatedStringsTests "...Thai..." (2)
   - Language.SequenceExpression "Handler body executes once..."
   - Miscellaneous.FsharpSuiteMigrated_CoreTests "patterns-FSI" (pending
     confirmation on main but bisect attempted)

Co-authored-by: Copilot <[email protected]>

Critical correctness fix. The previous within-type sort applied to
all members (methods, fields, events). For methods this is fine —
metadata tokens are assigned at write time and references are re-
resolved against the new order, so the resulting IL is semantically
identical to source-order emission.

For **fields**, this is wrong. The IL field declaration order
determines physical memory layout of struct types, observable via
Marshal.SizeOf, P/Invoke ABI, blittable interop with C/native code.
Sorting fields by name silently changes [<Struct>] DU/Record layout
on the runtime side.

Regression caught by Miscellaneous.FsharpSuiteMigrated_CoreTests
.patterns-FSI which uses Marshal.SizeOf on [<Struct>] union/record
to verify expected struct size at runtime — would fail with
"clcejefdw2: NO" and similar after the previous sort.

Events are kept symmetric with fields (preserved insertion order) —
they don't need sorting because event AddXxxDef happens during the
SEQUENTIAL spine walk, not from parallel deferred method bodies, so
insertion order is already deterministic.

Methods still sort by (Name, insertion-idx) — that path IS racy
(parallel body emit can race on TypeDefBuilder.AddMethodDef for
shared types like raw-data carriers).

Verified:
 * patterns-FSI: now 123/130 succeeded (none failed in the namespace).
 * Synthetic seq-vs-par determinism: 6/6 builds → MD5
   155746d16a252ca6036798289950011a (hash differs from previous
   commit because field order is now preserved-not-alphabetical).
 * EmittedIL/Conformance: 0 failures after .bsl regen converges
   (also in a separate commit per repository convention).

Co-authored-by: Copilot <[email protected]>

27 .bsl files updated to reflect the new field/event emission order
(insertion-order preserved instead of name-sorted), per the previous
commit's correctness fix for struct memory layout.

Co-authored-by: Copilot <[email protected]>

Sweep of the rest of the test suite after the field-preserve fix
(56d4e1b): 61 more .bsl baselines regenerated for tests whose
.bsl files live outside the EmittedIL namespace folder (e.g.,
TypeChecks/Shadowing for PropertyShadowingTests).

Also undoes the previous StaticLet 'init@6 before x_value' swap that
the fix-staticlet-il subagent applied based on the alphabetical-sort
era of field ordering. Fields now match source declaration order
(x_value first since 'static let mutable x_value = 42' precedes the
synthetic init@6).

Net failure count: 4 (full suite, EmittedIL+Conformance+Language+
all namespaces). 2 of those 4 are confirmed pre-existing on
origin/main on macOS arm64 (Handler body, Thai). The remaining 2
were StaticLet, now fixed.

Co-authored-by: Copilot <[email protected]>

…ings

# Conflicts:
#	tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputedCollections/ForNInRangeArrays.fs.il.bsl
#	tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputedCollections/ForNInRangeLists.fs.il.bsl
#	tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputedCollections/ForXInArray_ToArray.fs.il.bsl
#	tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputedCollections/ForXInArray_ToList.fs.il.bsl
#	tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputedCollections/ForXInList_ToArray.fs.il.bsl
#	tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputedCollections/ForXInList_ToList.fs.il.bsl
#	tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputedCollections/ForXInSeq_ToArray.fs.il.bsl
#	tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputedCollections/ForXInSeq_ToList.fs.il.bsl
#	tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Structs02.fs.il.bsl
#	tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Structs02_asNetStandard20.fs.il.bsl
#	tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.netcore.bsl
#	tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.netcore.bsl

Removed 272 lines of inline rationale, multi-paragraph explanations, repeated
issue links, and restated-obvious comments. Kept only minimal single-line ///
doc comments on public API members where the name alone doesn't convey the
contract.

(#19732)

Co-authored-by: Copilot <[email protected]>

Co-authored-by: Copilot <[email protected]>

…s stability

On this branch (fix-deterministic-strings), delayCodeGen is CONDITIONAL
(only true under --parallelcompilation+). Without always-defer, the
predicated GetCurrentFields check sees different field sets depending
on whether a given module's method bodies are inlined (SEQ) or deferred
(PAR), producing .cctor presence/absence differences in the emit.

The unconditional force guarantees same-flags PAR=PAR determinism. The
FsharpPlus hang only manifests when the LIBRARY is compiled with forced
cctor (affecting cross-assembly cctor trigger chains); single-file tests
in this repo are fine. The regression-test FsharpPlus_NET10_Test legs
will confirm.

The sibling PR #19929 (SEQ=PAR) uses always-defer which makes the predicate
safe, so it removes the unconditional force there. This PR keeps it.

(#19732)

Co-authored-by: Copilot <[email protected]>

…ame-flags stability"

This reverts commit 84aab84.

The revert of the unconditional cctor force (de9701d) also reverted
method ordering updates in 3 inline IL tests. The compiler emits .cctor()
before property accessors and .ctor before other methods — update the
verifyIL strings to match actual emission order.

Co-authored-by: Copilot <[email protected]>

User-declared methods (no '@' in name) preserve insertion order — keeping
.ctor before .cctor and matching F# declaration order. Deferred-codegen
methods (closure invokers with '@') are sorted by name for parallel-emit
determinism.

Also updates AOT trimming expected sizes and regenerates .bsl baselines
to match the new insertion-order emission.

(#19732)

Co-authored-by: Copilot <[email protected]>

…ings

- Delete _primeClosureName (never called, underscore-prefixed dead code)
- Delete primedRawDataFieldHosts dictionary (write-only, never read)
- Delete MarkRawDataFieldHost (populates dead dictionary)
- Delete WillHaveRawDataFields (reads dead dictionary, zero callers)
- Delete GetCurrentFields from TypeDefBuilder and AssemblyBuilder (caller removed)
- Remove 3 MarkRawDataFieldHost calls in PrimeStableNamesForCodegen walker
- Replace duplicated 11-line findIdx loops with Seq.tryFindIndex

Co-authored-by: Copilot <[email protected]>

…ings

Co-authored-by: Copilot <[email protected]>

- Remove fieldIdx/eventIdx counters and struct-key wrapping for fields/events
  (identity-transform sort: sorting by insertion index = original order)
- Add TotalArgCount tiebreaker to p_ModuleInfo sort key for overloaded members
- Remove non-deterministic Val.Stamp from valSourceOrderKey (first 4 components
  are unique for source-level vals; Stamp reintroduces the race it neutralizes)

Co-authored-by: Copilot <[email protected]>

…/fsharp into fix-deterministic-strings

The commit 48e76e9 simplified gfields from keyed ResizeArray to plain
ResizeArray<ILFieldDef> but didn't restore the GetCurrentFields member
that the conditional cctor-force check (from de9701d) still references.

Co-authored-by: Copilot <[email protected]>