Clear hoisted locals when disposing iterator and async-iterator state machines

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

@@ -88,11 +88,22 @@ internal AsyncIteratorMethodToStateMachineRewriter(
 
             return (asyncDispatch != null) ? F.Block(asyncDispatch, iteratorDispatch) : iteratorDispatch;
         }
+
+        protected override BoundStatement GenerateHoistedLocalsCleanup(ImmutableArray<StateMachineFieldSymbol> hoistedLocals)
+        {
+            // We need to clean nested hoisted local variables too (not just top-level ones)
+            // as they are not cleaned when exiting a block if we exit using a `yield break`
+            // or if the caller interrupts the enumeration after we reached a `yield return`.
+            // So we clean both top-level and nested hoisted local variables
+            return GenerateAllHoistedLocalsCleanup();
+        }
 #nullable disable
+
         protected override BoundStatement GenerateSetResultCall()
         {
             // ... _exprReturnLabel: ...
             // ... this.state = FinishedState; ...
+            // ... hoisted locals cleanup ...
 
             // if (this.combinedTokens != null) { this.combinedTokens.Dispose(); this.combinedTokens = null; } // for enumerables only
             // _current = default;

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

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
@@ -258,7 +259,7 @@ protected BoundCatchBlock GenerateExceptionHandling(LocalSymbol exceptionLocal,
                 isSynthesizedAsyncCatchAll: true);
         }
 
-        protected BoundStatement GenerateHoistedLocalsCleanup(ImmutableArray<StateMachineFieldSymbol> hoistedLocals)
+        protected virtual BoundStatement GenerateHoistedLocalsCleanup(ImmutableArray<StateMachineFieldSymbol> hoistedLocals)
         {
             var builder = ArrayBuilder<BoundStatement>.GetInstance();
 

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

@@ -160,7 +160,11 @@ internal void GenerateMoveNextAndDispose(BoundStatement body, SynthesizedImpleme
             if (rootFrame.knownStates == null)
             {
                 // nothing to finalize
-                F.CloseMethod(F.Return());
+                var disposeBody = F.Block(
+                                    GenerateAllHoistedLocalsCleanup(),
+                                    F.Return());
+
+                F.CloseMethod(disposeBody);
             }
             else
             {
@@ -171,6 +175,7 @@ internal void GenerateMoveNextAndDispose(BoundStatement body, SynthesizedImpleme
                                     ImmutableArray.Create<LocalSymbol>(stateLocal),
                                     F.Assignment(F.Local(stateLocal), F.Field(F.This(), stateField)),
                                     EmitFinallyFrame(rootFrame, state),
+                                    GenerateAllHoistedLocalsCleanup(),
                                     F.Return());
 
                 F.CloseMethod(disposeBody);

src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/MethodToStateMachineRewriter.cs

@@ -61,7 +61,7 @@ internal abstract class MethodToStateMachineRewriter : MethodToClassRewriter
         /// Note that there is a dispatch occurring at every try-finally statement, so this
         /// variable takes on a new set of values inside each try block.
         /// </summary>
-        private Dictionary<LabelSymbol, List<StateMachineState>> _dispatches = new();
+        private Dictionary<LabelSymbol, List<StateMachineState>> _dispatches = new Dictionary<LabelSymbol, List<StateMachineState>>();
 
         /// <summary>
         /// A pool of fields used to hoist locals. They appear in this set when not in scope,
@@ -75,11 +75,6 @@ internal abstract class MethodToStateMachineRewriter : MethodToClassRewriter
         /// </summary>
         private int _nextHoistedFieldId = 1;
 
-        /// <summary>
-        /// Used to enumerate the instance fields of a struct.
-        /// </summary>
-        private readonly EmptyStructTypeCache _emptyStructTypeCache = EmptyStructTypeCache.CreateNeverEmpty();
-
         /// <summary>
         /// The set of local variables and parameters that were hoisted and need a proxy.
         /// </summary>
@@ -434,6 +429,50 @@ private void AddVariableCleanup(ArrayBuilder<BoundExpression> cleanup, FieldSymb
             }
         }
 
+#nullable enable
+        protected BoundBlock GenerateAllHoistedLocalsCleanup()
+        {
+            var variableCleanup = ArrayBuilder<BoundExpression>.GetInstance();
+            var alreadyCleaned = PooledHashSet<string>.GetInstance();
+            foreach (var symbol in HoistedVariables)
+            {
+                if (symbol is LocalSymbol
+                    && proxies.TryGetValue(symbol, out CapturedSymbolReplacement? replacement))
+                {
+                    Debug.Assert(replacement is CapturedToStateMachineFieldReplacement or CapturedToExpressionSymbolReplacement);
+
+                    if (replacement is CapturedToStateMachineFieldReplacement fieldReplacement)
+                    {
+                        addVariableCleanupOnce(variableCleanup, fieldReplacement.HoistedField, alreadyCleaned);
+                    }
+                    else if (replacement is CapturedToExpressionSymbolReplacement expressionReplacement)
+                    {
+                        foreach (var field in expressionReplacement.HoistedFields)
+                        {
+                            addVariableCleanupOnce(variableCleanup, field, alreadyCleaned);
+                        }
+                    }
+                }
+            }
+
+            var result = F.Block(variableCleanup.SelectAsArray((e, f) => (BoundStatement)f.ExpressionStatement(e), F));
+
+            variableCleanup.Free();
+            alreadyCleaned.Free();
+
+            return result;
+
+            void addVariableCleanupOnce(ArrayBuilder<BoundExpression> variableCleanup, FieldSymbol field, PooledHashSet<string> alreadyCleaned)
+            {
+                // Hoisted fields may be re-used, so we can skip those that were cleared already
+                if (alreadyCleaned.Add(field.Name))
+                {
+                    AddVariableCleanup(variableCleanup, field);
+                }
+            }
+        }
+#nullable disable
+
         private StateMachineFieldSymbol GetOrAllocateReusableHoistedField(TypeSymbol type, out bool reused, LocalSymbol local = null)
         {
             ArrayBuilder<StateMachineFieldSymbol> fields;