RemoveAll

src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs

@@ -94,21 +94,22 @@ private static void FilterValidStackLocals(Dictionary<LocalSymbol, LocalDefUseIn
             // remove fake dummies and variable that cannot be scheduled
             var dummies = ArrayBuilder<LocalDefUseInfo>.GetInstance();
 
-            foreach (var local in info.Keys.ToArray())
+            info.RemoveAll(static (local, locInfo, dummies) =>
             {
-                var locInfo = info[local];
-
                 if (local.SynthesizedKind == SynthesizedLocalKind.OptimizerTemp)
                 {
                     dummies.Add(locInfo);
-                    info.Remove(local);
+                    return true;
                 }
-                else if (locInfo.CannotSchedule)
+
+                if (locInfo.CannotSchedule)
                 {
                     locInfo.Free();
-                    info.Remove(local);
+                    return true;
                 }
-            }
+
+                return false;
+            }, dummies);
 
             if (info.Count != 0)
             {

src/Compilers/CSharp/Portable/Utilities/FirstAmongEqualsSet.cs

@@ -80,18 +80,7 @@ public void IntersectWith(IEnumerable<T> items)
             // is a hash set; in practice it will not typically be.)
             _hashSet.UnionWith(items);
 
-            // Remove from the dictionary all items that are not
-            // in the input item set.
-
-            // Make a copy of the keys so that we are not changing the 
-            // dictionary as we enumerate it.
-            foreach (var key in _dictionary.Keys.ToList())
-            {
-                if (!_hashSet.Contains(key))
-                {
-                    _dictionary.Remove(key);
-                }
-            }
+            _dictionary.RemoveAll(static (key, value, hashSet) => !hashSet.Contains(key), _hashSet);
 
             // Now update the dictionary so that it contains the more
             // canonical of the items that are in both sets.

src/Compilers/VisualBasic/Portable/CodeGen/Optimizer/StackScheduler.vb

@@ -36,16 +36,18 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGen
             '  remove fake dummies and variable that cannot be scheduled
             Dim dummies As New List(Of LocalDefUseInfo)
 
-            For Each local In info.Keys.ToArray()
-                Dim locInfo = info(local)
-
-                If TypeOf local Is DummyLocal Then
-                    dummies.Add(locInfo)
-                    info.Remove(local)
-                ElseIf locInfo.CannotSchedule Then
-                    info.Remove(local)
-                End If
-            Next
+            info.RemoveAll(
+                Function(local, locInfo, dummiesList)
+                    If TypeOf local Is DummyLocal Then
+                        dummiesList.Add(locInfo)
+                        Return True
+                    ElseIf locInfo.CannotSchedule Then
+                        Return True
+                    End If
+
+                    Return False
+                End Function,
+                dummies)
 
             If info.Count = 0 Then
                 ' nothing to filter

src/Dependencies/Collections/Extensions/IDictionaryExtensions.cs

@@ -0,0 +1,64 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// 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 Microsoft.CodeAnalysis.PooledObjects;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis;
+
+internal static class IDictionaryExtensions
+{
+    /// <summary>
+    /// Removes entries from a dictionary based on a specified condition. The condition is defined by a function that
+    /// evaluates each key-value pair.
+    /// </summary>
+    public static void RemoveAll<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, Func<TKey, TValue, bool> predicate)
+        where TKey : notnull
+        => RemoveAll(dictionary, static (key, value, predicate) => predicate(key, value), predicate);
+
+    /// <summary>
+    /// Removes entries from a dictionary based on a specified condition. The condition is defined by a function that
+    /// evaluates each key-value pair.
+    /// </summary>
+    public static void RemoveAll<TKey, TValue, TArg>(this IDictionary<TKey, TValue> dictionary, Func<TKey, TValue, TArg, bool> predicate, TArg arg)
+        where TKey : notnull
+    {
+        if (dictionary.Count == 0)
+        {
+            return;
+        }
+#if NET
+        // .NET implementation of Dictionary<,> supports removing while enumerating:
+        if (dictionary is Dictionary<TKey, TValue> dict)
+        {
+            foreach (var (key, value) in dict)
+            {
+                if (predicate(key, value, arg))
+                {
+                    dict.Remove(key);
+                }
+            }
+
+            return;
+        }
+#endif
+        var keysToRemove = ArrayBuilder<TKey>.GetInstance();
+        foreach (var (key, value) in dictionary)
+        {
+            if (predicate(key, value, arg))
+            {
+                keysToRemove.Add(key);
+            }
+        }
+
+        foreach (var key in keysToRemove)
+        {
+            dictionary.Remove(key);
+        }
+
+        keysToRemove.Free();
+    }
+}

src/Dependencies/Collections/Microsoft.CodeAnalysis.Collections.projitems

@@ -71,6 +71,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\ImmutableArrayExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\ICollectionExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\IListExtensions.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Extensions\IDictionaryExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\MemoryExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Specialized\SpecializedCollections.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Specialized\SpecializedCollections.Empty.Collection.cs" />

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Options/EditorConfigValueSerializer.cs

@@ -181,13 +181,7 @@ public static void Serialize(IDictionary<string, string> builder, IOption2 optio
         if (value is NamingStylePreferences preferences)
         {
             // remove existing naming style values:
-            foreach (var name in builder.Keys)
-            {
-                if (name.StartsWith("dotnet_naming_rule.") || name.StartsWith("dotnet_naming_symbols.") || name.StartsWith("dotnet_naming_style."))
-                {
-                    builder.Remove(name);
-                }
-            }
+            builder.RemoveAll(static (name, _) => name.StartsWith("dotnet_naming_rule.") || name.StartsWith("dotnet_naming_symbols.") || name.StartsWith("dotnet_naming_style."));
 
             NamingStylePreferencesEditorConfigSerializer.WriteNamingStylePreferencesToEditorConfig(
                 preferences.SymbolSpecifications,

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/IDictionaryExtensions.cs

@@ -224,42 +224,4 @@ public static void MultiRemove<TKey, TValue>(this IDictionary<TKey, ImmutableArr
             }
         }
     }
-
-    /// <summary>
-    /// Removes entries from a dictionary based on a specified condition. The condition is defined by a function that
-    /// evaluates each key-value pair.
-    /// </summary>
-    public static void RemoveAll<TKey, TValue, TArg>(this Dictionary<TKey, TValue> dictionary, Func<TKey, TValue, TArg, bool> predicate, TArg arg)
-        where TKey : notnull
-    {
-#if NET
-        // .NET supports removing while enumerating:
-        foreach (var entry in dictionary)
-        {
-            if (predicate(entry.Key, entry.Value, arg))
-            {
-                dictionary.Remove(entry.Key);
-            }
-        }
-#else
-        if (dictionary.Count == 0)
-        {
-            return;
-        }
-
-        using var _ = ArrayBuilder<TKey>.GetInstance(out var keysToRemove);
-        foreach (var entry in dictionary)
-        {
-            if (predicate(entry.Key, entry.Value, arg))
-            {
-                keysToRemove.Add(entry.Key);
-            }
-        }
-
-        foreach (var key in keysToRemove)
-        {
-            dictionary.Remove(key);
-        }
-#endif
-    }
 }

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Extensions/Symbols/INamedTypeSymbolExtensions.cs

@@ -597,13 +597,12 @@ static void RemoveNonOverriddableMembers(
                 if (member.IsImplicitlyDeclared)
                     continue;
 
-                var matches = result.Where(kvp =>
-                    comparer.Equals(member.Name, kvp.Key.Name) &&
-                    SignatureComparer.Instance.HaveSameSignature(member, kvp.Key, caseSensitive));
-
-                // realize the matches since we're mutating the collection we're querying.
-                foreach (var match in matches.ToImmutableArray())
-                    result.Remove(match.Key);
+                result.RemoveAll(static (symbol, value, arg) =>
+                    {
+                        return arg.comparer.Equals(arg.member.Name, symbol.Name) &&
+                               SignatureComparer.Instance.HaveSameSignature(arg.member, symbol, arg.caseSensitive);
+                    },
+                    (comparer, member, caseSensitive));
             }
         }
     }