Fix completion off of nullable lambda parameter

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

@@ -225,6 +225,26 @@ public static ImmutableArray<TResult> SelectAsArray<TItem, TResult>(this Immutab
             return builder.ToImmutableAndFree();
         }
 
+        /// <summary>
+        /// Maps and flattens a subset of immutable array to another immutable array.
+        /// </summary>
+        /// <typeparam name="TItem">Type of the source array items</typeparam>
+        /// <typeparam name="TResult">Type of the transformed array items</typeparam>
+        /// <param name="array">The array to transform</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <returns>If the array's length is 0, this will return an empty immutable array.</returns>
+        public static ImmutableArray<TResult> SelectManyAsArray<TItem, TResult>(this ImmutableArray<TItem> array, Func<TItem, IEnumerable<TResult>> selector)
+        {
+            if (array.Length == 0)
+                return ImmutableArray<TResult>.Empty;
+
+            var builder = ArrayBuilder<TResult>.GetInstance();
+            foreach (var item in array)
+                builder.AddRange(selector(item));
+
+            return builder.ToImmutableAndFree();
+        }
+
         /// <summary>
         /// Maps and flattens a subset of immutable array to another immutable array.
         /// </summary>

src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb

@@ -11151,5 +11151,31 @@ class Program
                 Await state.AssertSelectedCompletionItem(displayText:="Program", isHardSelected:=True)
             End Using
         End Function
+
+        <WpfTheory, CombinatorialData, WorkItem(42910, "https://github.com/dotnet/roslyn/issues/42910")>
+        Public Async Function CompletionOffOfNullableLambdaParameter(showCompletionInArgumentLists As Boolean) As Task
+            Using state = TestStateFactory.CreateCSharpTestState(
+                <Document><![CDATA[
+using System;
+
+struct TestStruct
+{
+    public int TestField;
+}
+
+class Program
+{
+    void Main() => TestMethod1(x => { return x?.$$ });
+
+    void TestMethod1(Predicate<TestStruct?> predicate) => default;
+}
+]]>
+                </Document>,
+                showCompletionInArgumentLists:=showCompletionInArgumentLists, languageVersion:=LanguageVersion.Preview)
+
+                state.SendInvokeCompletionList()
+                Await state.AssertCompletionItemsContain(displayText:="TestField", displayTextSuffix:="")
+            End Using
+        End Function
     End Class
 End Namespace

src/Workspaces/CSharp/Portable/Recommendations/CSharpRecommendationServiceRunner.cs

@@ -14,7 +14,6 @@
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.PooledObjects;
-using Microsoft.CodeAnalysis.Precedence;
 using Microsoft.CodeAnalysis.Recommendations;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;

src/Workspaces/Core/Portable/Recommendations/AbstractRecommendationServiceRunner.cs

@@ -46,13 +46,17 @@ public AbstractRecommendationServiceRunner(
         // where there are more than one overloads of ThenInclude accepting different types of parameters.
         private ImmutableArray<ISymbol> GetMemberSymbolsForParameter(IParameterSymbol parameter, int position, bool useBaseReferenceAccessibility, bool unwrapNullable, bool isForDereference)
         {
-            var symbols = TryGetMemberSymbolsForLambdaParameter(parameter, position, isForDereference);
+            var symbols = TryGetMemberSymbolsForLambdaParameter(parameter, position, unwrapNullable, isForDereference);
             return symbols.IsDefault
                 ? GetMemberSymbols(parameter.Type, position, excludeInstance: false, useBaseReferenceAccessibility, unwrapNullable, isForDereference)
                 : symbols;
         }
 
-        private ImmutableArray<ISymbol> TryGetMemberSymbolsForLambdaParameter(IParameterSymbol parameter, int position, bool isForDereference)
+        private ImmutableArray<ISymbol> TryGetMemberSymbolsForLambdaParameter(
+            IParameterSymbol parameter,
+            int position,
+            bool unwrapNullable,
+            bool isForDereference)
         {
             // Use normal lookup path for this/base parameters.
             if (parameter.IsThis)
@@ -110,8 +114,8 @@ private ImmutableArray<ISymbol> TryGetMemberSymbolsForLambdaParameter(IParameter
             // parameter the compiler inferred as it may have made a completely suitable inference for it.
             return parameterTypeSymbols
                 .Concat(parameter.Type)
-                .SelectMany(parameterTypeSymbol => GetMemberSymbols(parameterTypeSymbol, position, excludeInstance: false, useBaseReferenceAccessibility: false, unwrapNullable: false, isForDereference))
-                .ToImmutableArray();
+                .SelectManyAsArray(parameterTypeSymbol =>
+                    GetMemberSymbols(parameterTypeSymbol, position, excludeInstance: false, useBaseReferenceAccessibility: false, unwrapNullable, isForDereference));
         }
 
         private ImmutableArray<ITypeSymbol> SubstituteTypeParameters(ImmutableArray<ITypeSymbol> parameterTypeSymbols, SyntaxNode invocationExpression)