Add WhereAsArray with generic argument (#42682)

* Add WhereAsArray with generic argument.

* Feedback

src/Compilers/CSharp/Portable/Binder/Binder_Crefs.cs

@@ -278,8 +278,8 @@ private ImmutableArray<Symbol> BindConversionOperatorMemberCref(ConversionOperat
             TypeSymbol returnType = BindCrefParameterOrReturnType(syntax.Type, syntax, diagnostics);
 
             // Filter out methods with the wrong return type, since overload resolution won't catch these.
-            sortedSymbols = sortedSymbols.WhereAsArray(symbol =>
-                symbol.Kind != SymbolKind.Method || TypeSymbol.Equals(((MethodSymbol)symbol).ReturnType, returnType, TypeCompareKind.ConsiderEverything2));
+            sortedSymbols = sortedSymbols.WhereAsArray((symbol, returnType) =>
+                symbol.Kind != SymbolKind.Method || TypeSymbol.Equals(((MethodSymbol)symbol).ReturnType, returnType, TypeCompareKind.ConsiderEverything2), returnType);
 
             if (!sortedSymbols.Any())
             {

src/Compilers/CSharp/Portable/Binder/DecisionDagBuilder.cs

@@ -1126,7 +1126,7 @@ private static RemainingTestsForCase RemoveEvaluation(RemainingTestsForCase c, B
         {
             return new RemainingTestsForCase(
                 Index: c.Index, Syntax: c.Syntax,
-                RemainingTests: c.RemainingTests.WhereAsArray(d => !(d is BoundDagEvaluation e2) || e2 != e),
+                RemainingTests: c.RemainingTests.WhereAsArray((d, e) => !(d is BoundDagEvaluation e2) || e2 != e, e),
                 Bindings: c.Bindings, WhenClause: c.WhenClause, CaseLabel: c.CaseLabel);
         }
 

src/Compilers/CSharp/Portable/Binder/Imports.cs

@@ -459,7 +459,7 @@ private static ImmutableArray<AliasAndExternAliasDirective> ConcatExternAliases(
 
             var replacedExternAliases = PooledHashSet<string>.GetInstance();
             replacedExternAliases.AddAll(externs2.Select(e => e.Alias.Name));
-            return externs1.WhereAsArray(e => !replacedExternAliases.Contains(e.Alias.Name)).AddRange(externs2);
+            return externs1.WhereAsArray((e, replacedExternAliases) => !replacedExternAliases.Contains(e.Alias.Name), replacedExternAliases).AddRange(externs2);
         }
 
         private static ImmutableArray<AliasAndExternAliasDirective> BuildExternAliases(

src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs

@@ -3970,7 +3970,7 @@ private static ImmutableArray<MethodSymbol> FilterOverriddenOrHiddenMethods(Immu
                 }
             }
 
-            return methods.WhereAsArray(m => !hiddenSymbols.Contains(m));
+            return methods.WhereAsArray((m, hiddenSymbols) => !hiddenSymbols.Contains(m), hiddenSymbols);
         }
 
         // Get the symbols and possible method group associated with a method group bound node, as
@@ -4075,7 +4075,7 @@ private static ImmutableArray<MethodSymbol> FilterOverriddenOrHiddenMethods(Immu
                         // If the bad expression has symbol(s) from this method group, it better indicates any problems.
                         ImmutableArray<Symbol> myMethodGroup = methodGroup;
 
-                        symbols = ((BoundBadExpression)boundNodeForSyntacticParent).Symbols.WhereAsArray(sym => myMethodGroup.Contains(sym));
+                        symbols = ((BoundBadExpression)boundNodeForSyntacticParent).Symbols.WhereAsArray((sym, myMethodGroup) => myMethodGroup.Contains(sym), myMethodGroup);
                         if (symbols.Any())
                         {
                             resultKind = ((BoundBadExpression)boundNodeForSyntacticParent).ResultKind;
@@ -4176,7 +4176,7 @@ private static ImmutableArray<MethodSymbol> FilterOverriddenOrHiddenMethods(Immu
                         // If the bad expression has symbol(s) from this property group, it better indicates any problems.
                         ImmutableArray<Symbol> myPropertyGroup = propertyGroup;
 
-                        symbols = ((BoundBadExpression)boundNodeForSyntacticParent).Symbols.WhereAsArray(sym => myPropertyGroup.Contains(sym));
+                        symbols = ((BoundBadExpression)boundNodeForSyntacticParent).Symbols.WhereAsArray((sym, myPropertyGroup) => myPropertyGroup.Contains(sym), myPropertyGroup);
                         if (symbols.Any())
                         {
                             resultKind = ((BoundBadExpression)boundNodeForSyntacticParent).ResultKind;

src/Compilers/CSharp/Portable/Symbols/ErrorTypeSymbol.cs

@@ -158,7 +158,7 @@ public override ImmutableArray<Symbol> GetMembers()
         /// no members with this name, returns an empty ImmutableArray. Never returns Null.</returns>
         public override ImmutableArray<Symbol> GetMembers(string name)
         {
-            return GetMembers().WhereAsArray(m => m.Name == name);
+            return GetMembers().WhereAsArray((m, name) => m.Name == name, name);
         }
 
         internal sealed override IEnumerable<FieldSymbol> GetFieldsToEmit()

src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs

@@ -1474,7 +1474,7 @@ public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(string name)
 
         public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(string name, int arity)
         {
-            return GetTypeMembers(name).WhereAsArray(type => type.Arity == arity);
+            return GetTypeMembers(name).WhereAsArray((type, arity) => type.Arity == arity, arity);
         }
 
         public override ImmutableArray<Location> Locations

src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamespaceSymbol.cs

@@ -132,7 +132,7 @@ public sealed override ImmutableArray<NamedTypeSymbol> GetTypeMembers(string nam
 
         public sealed override ImmutableArray<NamedTypeSymbol> GetTypeMembers(string name, int arity)
         {
-            return GetTypeMembers(name).WhereAsArray(type => type.Arity == arity);
+            return GetTypeMembers(name).WhereAsArray((type, arity) => type.Arity == arity, arity);
         }
 
         public sealed override ImmutableArray<Location> Locations

src/Compilers/CSharp/Portable/Symbols/NamespaceOrTypeSymbol.cs

@@ -165,7 +165,7 @@ public virtual ImmutableArray<NamedTypeSymbol> GetTypeMembers(string name, int a
         {
             // default implementation does a post-filter. We can override this if its a performance burden, but 
             // experience is that it won't be.
-            return GetTypeMembers(name).WhereAsArray(t => t.Arity == arity);
+            return GetTypeMembers(name).WhereAsArray((t, arity) => t.Arity == arity, arity);
         }
 
         /// <summary>

src/Compilers/CSharp/Portable/Symbols/ReferenceManager.cs

@@ -270,7 +270,9 @@ public PEAssemblySymbol CreatePEAssemblyForAssemblyMetadata(AssemblyMetadata met
 
                 var assemblySymbol = new PEAssemblySymbol(assembly, DocumentationProvider.Default, isLinked: false, importOptions: importOptions);
 
-                var unifiedAssemblies = this.UnifiedAssemblies.WhereAsArray(unified => referencedAssembliesByIdentity.Contains(unified.OriginalReference, allowHigherVersion: false));
+                var unifiedAssemblies = this.UnifiedAssemblies.WhereAsArray(
+                    (unified, referencedAssembliesByIdentity) => referencedAssembliesByIdentity.Contains(unified.OriginalReference, allowHigherVersion: false), referencedAssembliesByIdentity);
+
                 InitializeAssemblyReuseData(assemblySymbol, peReferences, unifiedAssemblies);
 
                 if (assembly.ContainsNoPiaLocalTypes())

src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs

@@ -1112,7 +1112,7 @@ public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(string name)
 
         public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(string name, int arity)
         {
-            return GetTypeMembers(name).WhereAsArray(t => t.Arity == arity);
+            return GetTypeMembers(name).WhereAsArray((t, arity) => t.Arity == arity, arity);
         }
 
         private Dictionary<string, ImmutableArray<NamedTypeSymbol>> GetTypeMembersDictionary()

src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs

@@ -179,7 +179,7 @@ public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(string name)
 
         public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(string name, int arity)
         {
-            return GetTypeMembers(name).WhereAsArray(s => s.Arity == arity);
+            return GetTypeMembers(name).WhereAsArray((s, arity) => s.Arity == arity, arity);
         }
 
         internal override ModuleSymbol ContainingModule

src/Compilers/CSharp/Portable/Symbols/SubstitutedNamedTypeSymbol.cs

@@ -286,7 +286,7 @@ private ImmutableArray<Symbol> GetMembersWorker(string name)
         {
             if (IsTupleType)
             {
-                var result = GetMembers().WhereAsArray(m => m.Name == name);
+                var result = GetMembers().WhereAsArray((m, name) => m.Name == name, name);
                 cacheResult(result);
                 return result;
             }

src/Compilers/Core/CodeAnalysisTest/Collections/ImmutableArrayExtensionsTests.cs

@@ -453,6 +453,16 @@ public void WhereAsArray()
             Assert.True(a.WhereAsArray(i => i % 2 == 1).SequenceEqual(ImmutableArray.Create<int>(1, 3, 5)));
         }
 
+        [Fact]
+        public void WhereAsArray_WithArg()
+        {
+            var x = new C();
+            Assert.Same(x, ImmutableArray.Create<object>(x).WhereAsArray((o, arg) => o == arg, x)[0]);
+
+            var a = ImmutableArray.Create(0, 1, 2, 3, 4, 5);
+            AssertEx.Equal(new[] { 3, 4, 5 }, a.WhereAsArray((i, j) => i > j, 2));
+        }
+
         private class C
         {
         }

src/Compilers/Core/Portable/Collections/ImmutableArrayExtensions.cs

@@ -259,13 +259,23 @@ public static ImmutableArray<byte> ToImmutable(this MemoryStream stream)
         /// <summary>
         /// Creates a new immutable array based on filtered elements by the predicate. The array must not be null.
         /// </summary>
-        /// <typeparam name="T"></typeparam>
         /// <param name="array">The array to process</param>
         /// <param name="predicate">The delegate that defines the conditions of the element to search for.</param>
-        /// <returns></returns>
         public static ImmutableArray<T> WhereAsArray<T>(this ImmutableArray<T> array, Func<T, bool> predicate)
+            => WhereAsArrayImpl<T, object?>(array, predicate, predicateWithArg: null, arg: null);
+
+        /// <summary>
+        /// Creates a new immutable array based on filtered elements by the predicate. The array must not be null.
+        /// </summary>
+        /// <param name="array">The array to process</param>
+        /// <param name="predicate">The delegate that defines the conditions of the element to search for.</param>
+        public static ImmutableArray<T> WhereAsArray<T, TArg>(this ImmutableArray<T> array, Func<T, TArg, bool> predicate, TArg arg)
+            => WhereAsArrayImpl(array, predicateWithoutArg: null, predicate, arg);
+
+        private static ImmutableArray<T> WhereAsArrayImpl<T, TArg>(ImmutableArray<T> array, Func<T, bool>? predicateWithoutArg, Func<T, TArg, bool>? predicateWithArg, TArg arg)
         {
             Debug.Assert(!array.IsDefault);
+            Debug.Assert(predicateWithArg != null ^ predicateWithoutArg != null);
 
             ArrayBuilder<T>? builder = null;
             bool none = true;
@@ -275,7 +285,8 @@ public static ImmutableArray<T> WhereAsArray<T>(this ImmutableArray<T> array, Fu
             for (int i = 0; i < n; i++)
             {
                 var a = array[i];
-                if (predicate(a))
+
+                if ((predicateWithoutArg != null) ? predicateWithoutArg(a) : predicateWithArg!(a, arg))
                 {
                     none = false;
                     if (all)

src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.vb

@@ -803,7 +803,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
         End Function
 
         Public Overloads Overrides Function GetTypeMembers(name As String, arity As Integer) As ImmutableArray(Of NamedTypeSymbol)
-            Return GetTypeMembers(name).WhereAsArray(Function(type) type.Arity = arity)
+            Return GetTypeMembers(name).WhereAsArray(Function(type, arity_) type.Arity = arity_, arity)
         End Function
 
         Public Overrides ReadOnly Property Locations As ImmutableArray(Of Location)

src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/PENamespaceSymbol.vb

@@ -120,7 +120,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
         End Function
 
         Public Overloads Overrides Function GetTypeMembers(name As String, arity As Integer) As ImmutableArray(Of NamedTypeSymbol)
-            Return GetTypeMembers(name).WhereAsArray(Function(type) type.Arity = arity)
+            Return GetTypeMembers(name).WhereAsArray(Function(type, arity_) type.Arity = arity_, arity)
         End Function
 
         Public NotOverridable Overrides ReadOnly Property Locations As ImmutableArray(Of Location)

src/Compilers/VisualBasic/Portable/Symbols/NamespaceOrTypeSymbol.vb

@@ -112,7 +112,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
         Public Overridable Function GetTypeMembers(name As String, arity As Integer) As ImmutableArray(Of NamedTypeSymbol)
             ' default implementation does a post-filter. We can override this if its a performance burden, but 
             ' experience is that it won't be.
-            Return GetTypeMembers(name).WhereAsArray(Function(t) t.Arity = arity)
+            Return GetTypeMembers(name).WhereAsArray(Function(type, arity_) type.Arity = arity_, arity)
         End Function
 
         ' Only the compiler can create new instances.

src/Compilers/VisualBasic/Portable/Symbols/ReferenceManager.vb

@@ -227,7 +227,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
 
                 Dim assemblySymbol = New PEAssemblySymbol(assembly, DocumentationProvider.Default, isLinked:=False, importOptions:=importOptions)
 
-                Dim unifiedAssemblies = Me.UnifiedAssemblies.WhereAsArray(Function(unified) referencedAssembliesByIdentity.Contains(unified.OriginalReference, allowHigherVersion:=False))
+                Dim unifiedAssemblies = Me.UnifiedAssemblies.WhereAsArray(
+                    Function(unified, refAsmByIdentity) refAsmByIdentity.Contains(unified.OriginalReference, allowHigherVersion:=False), referencedAssembliesByIdentity)
+
                 InitializeAssemblyReuseData(assemblySymbol, peReferences, unifiedAssemblies)
 
                 If assembly.ContainsNoPiaLocalTypes() Then

src/Compilers/VisualBasic/Portable/Symbols/Source/SourceMemberContainerTypeSymbol.vb

@@ -1649,7 +1649,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
         End Function
 
         Public Overrides Function GetTypeMembers(name As String, arity As Integer) As ImmutableArray(Of NamedTypeSymbol)
-            Return GetTypeMembers(name).WhereAsArray(Function(t) t.Arity = arity)
+            Return GetTypeMembers(name).WhereAsArray(Function(t, arity_) t.Arity = arity_, arity)
         End Function
 
         Friend Overrides ReadOnly Property DefaultPropertyName As String

src/Compilers/VisualBasic/Portable/Symbols/Tuples/TupleTypeSymbol.vb

@@ -942,7 +942,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
         End Function
 
         Public Overrides Function GetMembers(name As String) As ImmutableArray(Of Symbol)
-            Return Me.GetMembers().WhereAsArray(Function(m As Symbol) IdentifierComparison.Equals(m.Name, name))
+            Return Me.GetMembers().WhereAsArray(Function(member, name_) IdentifierComparison.Equals(member.Name, name_), name)
         End Function
 
         Public Overrides Function GetTypeMembers() As ImmutableArray(Of NamedTypeSymbol)

src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Rewriters/CapturedVariableRewriter.cs

@@ -43,7 +43,7 @@ internal sealed class CapturedVariableRewriter : BoundTreeRewriterWithStackGuard
 
         public override BoundNode VisitBlock(BoundBlock node)
         {
-            var rewrittenLocals = node.Locals.WhereAsArray(local => local.IsCompilerGenerated || local.Name == null || this.GetVariable(local.Name) == null);
+            var rewrittenLocals = node.Locals.WhereAsArray((local, rewriter) => local.IsCompilerGenerated || local.Name == null || rewriter.GetVariable(local.Name) == null, this);
             var rewrittenLocalFunctions = node.LocalFunctions;
             var rewrittenStatements = VisitList(node.Statements);
             return node.Update(rewrittenLocals, rewrittenLocalFunctions, rewrittenStatements);

src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EENamedTypeSymbol.cs

@@ -172,7 +172,7 @@ public override ImmutableArray<Symbol> GetMembers(string name)
             // Should not be requesting generated members
             // by name other than constructors.
             Debug.Assert((name == WellKnownMemberNames.InstanceConstructorName) || (name == WellKnownMemberNames.StaticConstructorName));
-            return this.GetMembers().WhereAsArray(m => m.Name == name);
+            return this.GetMembers().WhereAsArray((m, name) => m.Name == name, name);
         }
 
         public override ImmutableArray<NamedTypeSymbol> GetTypeMembers()

src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/Symbols/EENamedTypeSymbol.vb

@@ -170,7 +170,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
         Public Overrides Function GetMembers(name As String) As ImmutableArray(Of Symbol)
             ' Should not be requesting generated members by name other than constructors.
             Debug.Assert(name = WellKnownMemberNames.InstanceConstructorName OrElse name = WellKnownMemberNames.StaticConstructorName)
-            Return GetMembers().WhereAsArray(Function(m) m.Name = name)
+            Return GetMembers().WhereAsArray(Function(member, name_) member.Name = name_, name)
         End Function
 
         Public Overrides Function GetTypeMembers() As ImmutableArray(Of NamedTypeSymbol)