Cache overload resolution results for repeated method calls (preview language feature)

[Copilot]

Performance

Measured on 5000 Assert.Equal(x, y) calls where x and y are let-bound integers:

Typecheck Phase Duration

Compiler	Typecheck (s)	vs .NET 10	vs .NET 9
.NET 9 SDK	40.8	+528%	baseline
.NET 10 SDK	6.5	baseline	-84%
This PR	2.9	-55%	-93%

Speedup: 2.2x faster than .NET 10 SDK, 14x faster than .NET 9 SDK

GC Pressure Reduction

Compiler	GC0 collections	GC1	GC2
.NET 10 SDK	115	28	3
This PR	21	3	1

GC0 collections reduced by 82%

Cache Statistics

Cache	Hit Ratio	Hits	Misses
overloadResolutionCache	99.98%	4999	1
typeSubsumptionCache	81%	601	141

Why

Overload resolution is expensive. When the same overloaded method is called repeatedly with the same argument types (common in test files with Assert.Equal), the compiler redundantly recomputes the same resolution.

Strategy

Cache the resolution result using a composite key:

• Method group hash - identity of the available overloads
• Caller argument types - structural fingerprint of each argument type
• Object argument types - critical for extension methods
• Expected return type - for disambiguation (e.g., methods with out args)
• Type argument count - for generic calls

When the same key is seen again, return the cached winner index.

Handling Type Stability

TypeHashing generates a TypeStructure for each type, which can be:

Structure	Meaning	Caching Behavior
Stable	Fully resolved, won't change	✅ Cache
Unstable (solved typars)	Contains type variables that have solutions	✅ Cache (see below)
Unstable (unsolved typars)	Contains unsolved flexible typars	❌ Skip
PossiblyInfinite	Type exceeds 256 tokens	❌ Skip

Why Solved Typars Are Safe to Cache

When TypeHashing encounters a solved typar (e.g., 'a solved to int), it:

1. Emits the solution type tokens (int), not the typar itself
2. Marks the structure as Unstable (because Trace.Undo could theoretically revert it)

However, in overload resolution context, this is safe because:

• Cache keys are computed before FilterEachThenUndo runs
• Caller argument types are already resolved at this point
• Any solved typars in those types won't be reverted by the speculative resolution undo

We reject Unstable structures only when they contain TypeToken.Unsolved - these are flexible typars that could resolve to different types in different contexts.

Before/After Key Strategy

To maximize cache hits:

1. Compute cache key before resolution (may have solved typars marked Unstable)
2. Perform resolution (may solve more types)
3. Compute cache key after resolution (types now fully solved)
4. Store result under both keys if they differ

This allows future calls with already-solved types to hit the cache directly.

Safety Constraints

Caching is disabled for:

• Named arguments (complex matching logic)
• SRTP/trait constraints (resolution is context-dependent)
• op_Explicit/op_Implicit conversions
• Single-candidate scenarios (no benefit)

Language Feature Gating

The caching optimization is gated behind a new MethodOverloadsCache language feature:

• Enabled: Only with --langversion:preview
• Disabled by default: Safe fallback to standard resolution

When the language feature is not supported:

• Cache key computation is skipped entirely
• No cache lookup or storage occurs
• Falls back to standard overload resolution

This provides a safe rollout path for testing the optimization before enabling it by default in a future F# release.

Code Organization

Cache logic is isolated in a dedicated module OverloadResolutionCache.fs:

• OverloadResolutionCacheKey - cache key type with method hash and type structures
• tryComputeOverloadCacheKey - key computation with stability checks
• storeCacheResult - stores under before/after keys for maximum cache hits (respects language feature)
• hasUnsolvedTokens - detects flexible typars that must not be cached

TypeHashing.fs is unchanged from main branch (only MaxTokenCount = 256 constant extracted).

Testing

67 E2E tests verify correct overload selection (not just compilation):

• 44 basic tests: primitives, multi-args, ParamArray, type hierarchy, extension methods, optional args, rigid typars, tuples, named arguments, constraints, type-directed conversions, out params
• 23 adversarial tests: cache poisoning attempts with alternating types, generic instantiations, subtype overloads, nested generics, byref overloads, stress test with 100 alternating calls

Each test returns a string identifying which overload was picked, verified at runtime.

All tests use withLangVersionPreview to enable the MethodOverloadsCache feature.

---

💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more Copilot coding agent tips in the docs.

[github-actions]

❗ Release notes required

---

✅ Found changes and release notes in following paths:

Warning

No PR link found in some release notes, please consider adding it.

Change path	Release notes path	Description
src/Compiler	docs/release-notes/.FSharp.Compiler.Service/10.0.300.md	No current pull request URL (#19072) found, please consider adding it
LanguageFeatures.fsi	docs/release-notes/.Language/preview.md

[Copilot]

@copilot : Add release notes to the 10.0.300 .md file pointing to this PR and giving a one-line about what it is.

Added release notes entry to docs/release-notes/.FSharp.Compiler.Service/10.0.300.md (commit c909230):

Overload resolution results are now cached, providing significant performance improvements for code with repeated method calls. (Issue #18807)