Fix Local-Symbol Containing-Symbol in New-Extension-Method-Rewriter for Capture Analysis

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 virtual bool AllowReuseOfLocalsWithIncorrectContainingSymbol => true;
+
         public override BoundNode DefaultVisit(BoundNode node)
         {
             Debug.Fail($"Override the visitor for {node.Kind}");
@@ -55,7 +57,7 @@ protected virtual bool TryRewriteLocal(LocalSymbol local, [NotNullWhen(true)] ou
             }
 
             var newType = VisitType(local.Type);
-            if (TypeSymbol.Equals(newType, local.Type, TypeCompareKind.ConsiderEverything2))
+            if (AllowReuseOfLocalsWithIncorrectContainingSymbol && TypeSymbol.Equals(newType, local.Type, TypeCompareKind.ConsiderEverything2))
             {
                 newLocal = local;
             }

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 AllowReuseOfLocalsWithIncorrectContainingSymbol => false;
+
         public ExtensionMethodBodyRewriter(MethodSymbol sourceMethod, SourceExtensionImplementationMethodSymbol implementationMethod)
         {
             Debug.Assert(sourceMethod is not null);

src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests.cs

@@ -947,6 +947,49 @@ public static class Extensions
         Assert.Equal("Extensions.<>E__1<T>", symbol2.ToTestDisplayString());
     }
 
+    [Fact]
+    [WorkItem("https://github.com/dotnet/roslyn/issues/78135")]
+    public void ExtensionWithCapturing()
+    {
+        var src = """
+using System;
+using System.Text;
+
+var sb = new StringBuilder("Info: ");
+Extensions.Inspect(sb);
+
+public static class Extensions
+{
+    extension(StringBuilder)
+    {
+        public static StringBuilder Inspect(StringBuilder sb)
+        {
+            var s = () =>
+            {
+                foreach (char c in sb.ToString())
+                {
+                    Console.Write(c);
+                }
+            };
+            s();
+            return sb;
+        }
+    }
+}
+""";
+
+        var comp = CreateCompilation(src);
+        comp.VerifyEmitDiagnostics();
+
+        var tree = comp.SyntaxTrees[0];
+        var model = comp.GetSemanticModel(tree);
+        var extension1 = tree.GetRoot().DescendantNodes().OfType<ExtensionDeclarationSyntax>().First();
+        var symbol1 = model.GetDeclaredSymbol(extension1);
+        var sourceExtension1 = symbol1.GetSymbol<SourceNamedTypeSymbol>();
+        Assert.Equal("<>E__0", symbol1.MetadataName);
+        Assert.Equal("Extensions.<>E__0", symbol1.ToTestDisplayString());
+    }
+
     [Fact]
     public void ExtensionIndex_TwoExtensions_SameSignatures_02()
     {