Fix Local-Symbol Containing-Symbol in New-Extension-Method-Rewriter for Capture Analysis (#78160)

* fixes #78135

* fixes #78135

* comment adjusted

* test fixed

* comment added

* reuse if container does not change

* AllowReuseOfLocalsWithIncorrectContainingSymbol => EnforceAccurateContainerForLocals

* use CompileAndVerify, acutally use extensions

* test added

* use VerifyTypeIL

* test added for #78042

* avoid Foo

* simplify if statement

* simplify test - use simple local function without async

* EnforceAccurateContainerForLocals should be abstract

Author: bernd5

src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncMethodToStateMachineRewriter.cs

@@ -63,6 +63,11 @@ internal class AsyncMethodToStateMachineRewriter : MethodToStateMachineRewriter
 
         private readonly Dictionary<BoundValuePlaceholderBase, BoundExpression> _placeholderMap;
 
+        /// <summary>
+        /// Containing Symbols are not checked after this step - for performance reasons we can allow inaccurate locals
+        /// </summary>
+        protected override bool EnforceAccurateContainerForLocals => false;
+
         internal AsyncMethodToStateMachineRewriter(
             MethodSymbol method,
             int methodOrdinal,

src/Compilers/CSharp/Portable/Lowering/BoundTreeToDifferentEnclosingContextRewriter.cs

@@ -19,7 +19,7 @@ namespace Microsoft.CodeAnalysis.CSharp
     internal abstract class BoundTreeToDifferentEnclosingContextRewriter : BoundTreeRewriterWithStackGuardWithoutRecursionOnTheLeftOfBinaryOperator
     {
         // A mapping from every local variable to its replacement local variable.  Local variables are replaced when
-        // their types change due to being inside of a generic method.  Otherwise we reuse the original local (even
+        // their types change due to being inside of a generic method.  Otherwise we may reuse the original local (even
         // though its containing method is not correct because the code is moved into another method)
         private readonly Dictionary<LocalSymbol, LocalSymbol> localMap = new Dictionary<LocalSymbol, LocalSymbol>();
 
@@ -30,6 +30,8 @@ internal abstract class BoundTreeToDifferentEnclosingContextRewriter : BoundTree
 
         protected abstract MethodSymbol CurrentMethod { get; }
 
+        protected abstract bool EnforceAccurateContainerForLocals { get; }
+
         public override BoundNode DefaultVisit(BoundNode node)
         {
             Debug.Fail($"Override the visitor for {node.Kind}");
@@ -55,7 +57,8 @@ protected virtual bool TryRewriteLocal(LocalSymbol local, [NotNullWhen(true)] ou
             }
 
             var newType = VisitType(local.Type);
-            if (TypeSymbol.Equals(newType, local.Type, TypeCompareKind.ConsiderEverything2))
+            if (TypeSymbol.Equals(newType, local.Type, TypeCompareKind.ConsiderEverything2) &&
+                (!EnforceAccurateContainerForLocals || local.ContainingSymbol == CurrentMethod))
             {
                 newLocal = local;
             }

src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ClosureConversion.cs

@@ -151,6 +151,11 @@ internal sealed partial class ClosureConversion : MethodToClassRewriter
         /// </summary>
         private readonly ImmutableHashSet<Symbol> _allCapturedVariables;
 
+        /// <summary>
+        /// Containing Symbols are not checked after this step - for performance reasons we can allow inaccurate locals
+        /// </summary>
+        protected override bool EnforceAccurateContainerForLocals => false;
+
 #nullable enable
 
         private ClosureConversion(

src/Compilers/CSharp/Portable/Lowering/ExtensionMethodBodyRewriter.cs

@@ -27,6 +27,11 @@ internal sealed class ExtensionMethodBodyRewriter : BoundTreeToDifferentEnclosin
 
         private RewrittenMethodSymbol _rewrittenContainingMethod;
 
+        /// <summary>
+        /// To allow regular capture analysis we do not want to reuse locals with an incorrect containing symbol
+        /// </summary>
+        protected override bool EnforceAccurateContainerForLocals => true;
+
         public ExtensionMethodBodyRewriter(MethodSymbol sourceMethod, SourceExtensionImplementationMethodSymbol implementationMethod)
         {
             Debug.Assert(sourceMethod is not null);

src/Compilers/CSharp/Portable/Lowering/IteratorRewriter/IteratorMethodToStateMachineRewriter.cs

@@ -74,6 +74,11 @@ internal IteratorMethodToStateMachineRewriter(
             _nextFinalizeState = slotAllocatorOpt?.GetFirstUnusedStateMachineState(increasing: false) ?? StateMachineState.FirstIteratorFinalizeState;
         }
 
+        /// <summary>
+        /// Containing Symbols are not checked after this step - for performance reasons we can allow inaccurate locals
+        /// </summary>
+        protected override bool EnforceAccurateContainerForLocals => false;
+
 #nullable disable
         protected sealed override HotReloadExceptionCode EncMissingStateErrorCode
             => HotReloadExceptionCode.CannotResumeSuspendedIteratorMethod;