Refactor invocation validation into separate methods for better readability

Co-authored-by: meziantou <[email protected]>

Author: Copilot

src/Meziantou.Analyzer/Rules/ArgumentExceptionShouldSpecifyArgumentNameAnalyzer.cs

@@ -148,37 +148,43 @@ private static void AnalyzeInvocation(OperationAnalysisContext context, INamedTy
         if (op.Arguments.Length == 0)
             return;
 
-        var availableParameterNames = GetParameterNames(op, context.CancellationToken);
-
         // If there's a second argument (paramName) and it's not null, check that instead
         if (op.Arguments.Length >= 2)
         {
             var secondArgument = op.Arguments[1];
             if (secondArgument.Parameter?.Type.IsString() == true && secondArgument.Value is not null)
             {
-                // Check if the second argument is a constant string value
-                if (secondArgument.Value.ConstantValue.HasValue && secondArgument.Value.ConstantValue.Value is string paramNameValue)
-                {
-                    if (availableParameterNames.Contains(paramNameValue, StringComparer.Ordinal))
-                    {
-                        if (secondArgument.Value is not INameOfOperation)
-                        {
-                            var properties = ImmutableDictionary<string, string?>.Empty.Add(ArgumentExceptionShouldSpecifyArgumentNameAnalyzerCommon.ArgumentNameKey, paramNameValue);
-                            context.ReportDiagnostic(NameofRule, properties, secondArgument.Value);
-                        }
+                ValidateParamNameArgument(context, op, secondArgument);
+                return;
+            }
+        }
 
-                        return;
-                    }
+        ValidateFirstArgument(context, op);
+    }
 
-                    context.ReportDiagnostic(Rule, secondArgument, $"'{paramNameValue}' is not a valid parameter name");
-                    return;
-                }
+    private static void ValidateParamNameArgument(OperationAnalysisContext context, IInvocationOperation op, IArgumentOperation paramNameArgument)
+    {
+        // Check if the argument is a constant string value
+        if (!paramNameArgument.Value.ConstantValue.HasValue || paramNameArgument.Value.ConstantValue.Value is not string paramNameValue)
+            return;
 
-                // Cannot determine the value of the second argument, so we can't validate it
-                return;
+        var availableParameterNames = GetParameterNames(op, context.CancellationToken);
+        if (availableParameterNames.Contains(paramNameValue, StringComparer.Ordinal))
+        {
+            if (paramNameArgument.Value is not INameOfOperation)
+            {
+                var properties = ImmutableDictionary<string, string?>.Empty.Add(ArgumentExceptionShouldSpecifyArgumentNameAnalyzerCommon.ArgumentNameKey, paramNameValue);
+                context.ReportDiagnostic(NameofRule, properties, paramNameArgument.Value);
             }
+
+            return;
         }
 
+        context.ReportDiagnostic(Rule, paramNameArgument, $"'{paramNameValue}' is not a valid parameter name");
+    }
+
+    private static void ValidateFirstArgument(OperationAnalysisContext context, IInvocationOperation op)
+    {
         var firstArgument = op.Arguments[0];
         if (firstArgument.Value is null)
             return;
@@ -199,6 +205,7 @@ private static void AnalyzeInvocation(OperationAnalysisContext context, INamedTy
             return;
 
         // Check if this argument name corresponds to a valid parameter in the current scope
+        var availableParameterNames = GetParameterNames(op, context.CancellationToken);
         if (!availableParameterNames.Contains(argumentName, StringComparer.Ordinal))
         {
             context.ReportDiagnostic(Rule, firstArgument, $"'{argumentName}' is not a valid parameter name");