Defer display class allocation for async local functions to call site

[benaadams]

Fixes #18946

When an async local function captures variables via closure, the display class is heap-allocated at method entry unconditionally - even when the local function is never called. This means the fast path (where the async work completes synchronously) pays for an allocation it doesn't need.

This PR defers display class allocation to the call site for eligible async local functions. Captured variables remain as locals on the fast path; the closure frame is only allocated when the local function is actually invoked.

Analysis phase (ClosureConversion.Analysis.cs):

• IsDeferrableEnvironment identifies eligible environments using conservative guards: class closure (not struct), single closure in scope, Release build, async local function, not delegate-converted, no this capture, no captured local function calls, and all call sites are top-level return await
• LocalFunctionCallSiteAnalyzer walks the lowered body to verify call-site constraints

Code generation (ClosureConversion.cs):

• DeferredCapturedToFrameSymbolReplacement provides dual-mode proxy replacement: returns the original local/parameter in the containing method, returns the field access in the lowered local function body
• CreateDeferredFrameInitializationSequence wraps the local function call in a BoundSequence that allocates the display class and copies captured variable values into its fields
• IntroduceFrame skips frame constructor and InitVariableProxy for deferred environments

Proxy context (MethodToClassRewriter.cs):

• ProxyReplacementContext struct replaces the anonymous tuple passed to TryReplaceWithProxy, enabling the deferred replacement to distinguish calling contexts via structured type checking

Tests

• 2 positive tests: basic deferred allocation, generic method deferred allocation - verify newobj DisplayClass appears after get_IsCompleted in IL
• 7 negative tests: delegate conversion, non-return call site, multiple closures sharing environment, call in loop, this capture, debug mode, generic with constraints - verify allocation is not deferred
• Existing closure conversion test suite passes without regressions

[Copilot]

Pull request overview

This PR updates C# closure conversion to defer heap allocation of the display-class (closure frame) for eligible async local functions until the local function is actually invoked, avoiding an unconditional method-entry allocation on the synchronous fast-path.

Changes:

• Adds analysis to conservatively detect “deferrable” top-level closure environments and validate call sites (must be top-level return ... positions).
• Updates closure conversion rewriting to (1) avoid proxying captured locals/parameters on the top-level fast path, and (2) inject frame allocation + captured-value copying at the local-function call site.
• Adds IL-based codegen tests validating deferred vs non-deferred allocation behavior across several scenarios.

Reviewed changes

Copilot reviewed 5 out of 5 changed files in this pull request and generated 1 comment.

Show a summary per file

File	Description
src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLocalFunctionTests.cs	Adds positive/negative IL tests asserting where the display-class newobj appears relative to get_IsCompleted().
src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs	Introduces ProxyReplacementContext so proxy replacements can distinguish rewriting context.
src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ClosureConversion.cs	Implements deferred frame initialization and dual-mode proxy replacement for deferrable captures; wraps eligible call sites in a sequence that allocates/copies.
src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ClosureConversion.Analysis.cs	Adds deferrable-environment detection and a walker to validate call-site constraints.
src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ClosureConversion.Analysis.Tree.cs	Extends ClosureEnvironment to track IsDeferrable.