fix: shared mutable state in test infrastructure causes race conditions

[thomhurst]

Summary

• Replace HashSet<MethodInfo> with ConcurrentDictionary<MethodInfo, byte> in GenericTestRegistry.AotCompatibleMethods to prevent concurrent Add/Contains race conditions
• Add lock around HashSet<Type[]> mutations inside GenericTestRegistry._registeredCombinations and return snapshots from GetRegisteredCombinations to prevent concurrent modification during enumeration
• Replace Dictionary<Type, Func<...>> with ConcurrentDictionary in DataSourceHelpers.TypeCreators to prevent concurrent read/write race conditions from generated module initializers
• Use ConcurrentDictionary.GetOrAdd in TUnitInitializer.ParseParameters to eliminate TOCTOU (time-of-check-time-of-use) race on parameter list creation

Test plan

• dotnet build TUnit.Core/TUnit.Core.csproj passes (all 4 TFMs: netstandard2.0, net8.0, net9.0, net10.0)
• dotnet build TUnit.Engine/TUnit.Engine.csproj passes (all 4 TFMs)
• Existing CI tests pass with no regressions
• Verify no snapshot test changes required (no public API surface changes)

Fixes#4875

[claude]

Code Review

The thread-safety fixes in this PR are correct and well-targeted. The logic for each change is sound:

• AotCompatibleMethods → ConcurrentDictionary<MethodInfo, byte>: Clean, idiomatic C# pattern for a concurrent set. TryAdd/ContainsKey are the right replacements.
• TypeCreators → ConcurrentDictionary: Straightforward and correct.
• GetOrAdd in TUnitInitializer.ParseParameters: Eliminates the TOCTOU window in the original check-then-set pattern.

Architectural Observation: _combinationsLock granularity

The one design choice worth revisiting is the single global _combinationsLock in GenericTestRegistry:

privatestaticreadonlyobject_combinationsLock=new();// In RegisterGenericMethod:varcombinations=_registeredCombinations.GetOrAdd(declaringType,static _ =>newHashSet<Type[]>(...));lock(_combinationsLock)// global lock — blocks ALL declaring types{combinations.Add(typeArguments);}// In GetRegisteredCombinations:lock(_combinationsLock)// same global lock{returncombinations.ToArray();}

The issue is that _registeredCombinations already provides per-key isolation (each declaringType has its own HashSet<Type[]>), but the single global lock serializes all registrations and reads across all declaring types, even when they operate on completely independent HashSet instances.

A more granular alternative is to lock on the HashSet instance itself, which is already per-type:

varcombinations=_registeredCombinations.GetOrAdd(declaringType,static _ =>newHashSet<Type[]>(newTypeArrayComparer()));lock(combinations)// per-type lock — no cross-type contention{combinations.Add(typeArguments);}// In GetRegisteredCombinations:lock(combinations){returncombinations.ToArray();}

This is correct because:

1. The same HashSet<Type[]> instance is always returned for a given declaringType (since GetOrAdd never replaces an existing entry and nothing removes entries during registration)
2. Locking on the instance itself is the same pattern as locking on a per-key lock, just without the extra field
3. Two threads registering for TypeA and TypeB no longer block each other

This removes the need for _combinationsLock entirely. The existing ConcurrentDictionary already provides the per-key granularity; the lock just needs to follow that granularity.

Note: this applies to the _registeredCombinations path only. AotCompatibleMethods was correctly changed to ConcurrentDictionary<MethodInfo, byte> which handles its own thread-safety natively, so no lock is needed there at all.

---

Overall this is a solid, targeted fix for the race conditions described in #4875. No bugs were found in the introduced changes.