Fix collection expression handling

Author: stephentoub

src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.NetCore.Analyzers/Tasks/DoNotUseNonCancelableTaskDelayWithWhenAny.cs

@@ -1,18 +1,16 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
 
 using System.Collections.Immutable;
-using System.Linq;
 using Analyzer.Utilities;
 using Analyzer.Utilities.Extensions;
 using Analyzer.Utilities.Lightup;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
+using static Microsoft.NetCore.Analyzers.MicrosoftNetCoreAnalyzersResources;
 
 namespace Microsoft.NetCore.Analyzers.Tasks
 {
-    using static MicrosoftNetCoreAnalyzersResources;
-
     /// <summary>
     /// CA2027: <inheritdoc cref="DoNotUseNonCancelableTaskDelayWithWhenAnyTitle"/>
     /// </summary>
@@ -53,55 +51,57 @@ public override void Initialize(AnalysisContext context)
                     var invocation = (IInvocationOperation)context.Operation;
 
                     // Check if this is a call to Task.WhenAny
-                    if (!IsTaskWhenAny(invocation.TargetMethod, taskType))
+                    var method = invocation.TargetMethod;
+                    if (!SymbolEqualityComparer.Default.Equals(method.ContainingType, taskType) ||
+                        !method.IsStatic ||
+                        method.Name != nameof(Task.WhenAny))
                     {
                         return;
                     }
 
                     // Count the total number of tasks passed to WhenAny
                     int taskCount = 0;
-                    System.Collections.Generic.List<IOperation>? taskDelayOperations = null;
+                    List<IOperation>? taskDelayOperations = null;
 
                     // Task.WhenAny has params parameters, so arguments are often implicitly wrapped in an array
                     // We need to check inside the array initializer or collection expression
-                    foreach (var argument in invocation.Arguments)
+                    for (int i = 0; i < invocation.Arguments.Length; i++)
                     {
-                        // Check if this is an array creation (implicit params expansion, explicit array, or collection expression)
-                        if (argument.Value is IArrayCreationOperation { Initializer: not null } arrayCreation)
+                        var argument = invocation.Arguments[i].Value.WalkDownConversion();
+
+                        // Check if this is an array creation
+                        if (argument is IArrayCreationOperation { Initializer: not null } arrayCreation)
                         {
                             // Check each element in the array
                             foreach (var element in arrayCreation.Initializer.ElementValues)
                             {
                                 taskCount++;
                                 if (IsNonCancelableTaskDelay(element, taskType, cancellationTokenType))
                                 {
-                                    taskDelayOperations ??= new System.Collections.Generic.List<IOperation>();
-                                    taskDelayOperations.Add(element);
+                                    (taskDelayOperations ??= []).Add(element);
                                 }
                             }
                         }
-                        else if (ICollectionExpressionOperationWrapper.IsInstance(argument.Value))
+                        else if (ICollectionExpressionOperationWrapper.IsInstance(argument))
                         {
                             // Check each element in the collection expression
-                            var collectionExpression = ICollectionExpressionOperationWrapper.FromOperation(argument.Value);
+                            var collectionExpression = ICollectionExpressionOperationWrapper.FromOperation(argument);
                             foreach (var element in collectionExpression.Elements)
                             {
                                 taskCount++;
                                 if (IsNonCancelableTaskDelay(element, taskType, cancellationTokenType))
                                 {
-                                    taskDelayOperations ??= new System.Collections.Generic.List<IOperation>();
-                                    taskDelayOperations.Add(element);
+                                    (taskDelayOperations ??= []).Add(element);
                                 }
                             }
                         }
                         else
                         {
                             // Direct argument (not params or array)
                             taskCount++;
-                            if (IsNonCancelableTaskDelay(argument.Value, taskType, cancellationTokenType))
+                            if (IsNonCancelableTaskDelay(argument, taskType, cancellationTokenType))
                             {
-                                taskDelayOperations ??= new System.Collections.Generic.List<IOperation>();
-                                taskDelayOperations.Add(argument.Value);
+                                (taskDelayOperations ??= []).Add(argument);
                             }
                         }
                     }
@@ -119,42 +119,30 @@ public override void Initialize(AnalysisContext context)
             });
         }
 
-        private static bool IsTaskWhenAny(IMethodSymbol method, INamedTypeSymbol taskType)
-        {
-            return SymbolEqualityComparer.Default.Equals(method.ContainingType, taskType) &&
-                   method.IsStatic &&
-                   method.Name == nameof(System.Threading.Tasks.Task.WhenAny);
-        }
-
         private static bool IsNonCancelableTaskDelay(IOperation operation, INamedTypeSymbol taskType, INamedTypeSymbol cancellationTokenType)
         {
-            // Unwrap conversions to get to the actual invocation
-            if (operation is IConversionOperation conversion)
-            {
-                operation = conversion.Operand;
-            }
+            operation = operation.WalkDownConversion();
 
             if (operation is not IInvocationOperation invocation)
             {
                 return false;
             }
 
-            var method = invocation.TargetMethod;
-
             // Check if this is Task.Delay
+            var method = invocation.TargetMethod;
             if (!SymbolEqualityComparer.Default.Equals(method.ContainingType, taskType) ||
                 !method.IsStatic ||
-                method.Name != nameof(System.Threading.Tasks.Task.Delay))
+                method.Name != nameof(Task.Delay))
             {
                 return false;
             }
 
-            // Check if any parameter is a CancellationToken
+            // Check if any parameter is a CancellationToken, in which case we consider it cancelable
             foreach (var parameter in method.Parameters)
             {
                 if (SymbolEqualityComparer.Default.Equals(parameter.Type, cancellationTokenType))
                 {
-                    return false; // Has a CancellationToken parameter, so it's cancelable
+                    return false;
                 }
             }