Code review changes

src/nunit.analyzers.tests/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFixTests.cs

@@ -260,7 +260,7 @@ public void VerifyAreEqualFixWhenWithMessageAndArgsArray()
         public void Test(object actual, object expected)
         {
             object[] args = { expected, actual };
-            ClassicAssert.AreEqual(expected, actual, ""Expected: {0} Got: {1}"", args);
+            ↓ClassicAssert.AreEqual(expected, actual, ""Expected: {0} Got: {1}"", args);
         }");
             var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings(@"
         [TestCase(3.0, 3)]
@@ -279,7 +279,7 @@ public void VerifyAreEqualFixWhenWithMessageVariable()
         [TestCase(3.0, 3)]
         public void Test(object actual, object expected)
         {
-            ClassicAssert.AreEqual(expected, actual, GetLocalizedFormatSpecification(), expected, actual);
+            ↓ClassicAssert.AreEqual(expected, actual, GetLocalizedFormatSpecification(), expected, actual);
         }
         private static string GetLocalizedFormatSpecification() => ""Expected: {0} Got: {1}"";
         ");

src/nunit.analyzers/ClassicModelAssertUsage/ClassicModelAssertUsageCodeFix.cs

@@ -74,7 +74,7 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
             bool argsIsArray = !string.IsNullOrEmpty(diagnostic.Properties[AnalyzerPropertyKeys.ArgsIsArray]);
 
             argumentNamesToArguments.TryGetValue(NUnitFrameworkConstants.NameOfMessageParameter, out ArgumentSyntax? messageArgument);
-            if (CodeFixHelper.GetInterpolatedMessageArgumentOrDefault(false, argsIsArray, messageArgument, args) is ArgumentSyntax interpolatedMessageArgument)
+            if (CodeFixHelper.GetInterpolatedMessageArgumentOrDefault(messageArgument, args, unconditional: false, argsIsArray) is ArgumentSyntax interpolatedMessageArgument)
                 newArguments.Add(interpolatedMessageArgument);
 
             var newArgumentsList = invocationNode.ArgumentList.WithArguments(newArguments);

src/nunit.analyzers/Helpers/CodeFixHelper.cs

@@ -38,13 +38,13 @@ internal static class CodeFixHelper
         /// <summary>
         /// This is assumed to be arguments for an 'Assert.That(actual, constraint, "...: {0} - {1}", param0, param1)`
         /// which needs converting into 'Assert.That(actual, constraint, $"...: {param0} - {param1}").
-        /// Unless we cannot, in which case we create 'string.Format(specification, args)'.
+        /// Unless we cannot, in which case we create '() => string.Format(specification, args)'.
         /// </summary>
-        /// <param name="unconditional">If the message is not conditional on the test outcome.</param>
-        /// <param name="argsIsArray">The params args is passed as an array iso individual parameters.</param>
         /// <param name="messageArgument">The argument that corresponds to the composite format string.</param>
         /// <param name="args">The list of arguments that correspond to format items.</param>
-        public static ArgumentSyntax? GetInterpolatedMessageArgumentOrDefault(bool unconditional, bool argsIsArray, ArgumentSyntax? messageArgument, List<ArgumentSyntax> args)
+        /// <param name="unconditional">If the message is not conditional on the test outcome.</param>
+        /// <param name="argsIsArray">The params args is passed as an array instead of individual parameters.</param>
+        public static ArgumentSyntax? GetInterpolatedMessageArgumentOrDefault(ArgumentSyntax? messageArgument, List<ArgumentSyntax> args, bool unconditional, bool argsIsArray)
         {
             if (messageArgument is null)
                 return null;
@@ -86,15 +86,7 @@ internal static class CodeFixHelper
                     .WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(
                         args.Select(x => x.WithNameColon(null)).Prepend(messageArgument))));
 
-                if (unconditional)
-                {
-                    return SyntaxFactory.Argument(stringFormat);
-                }
-                else
-                {
-                    var stringFormatLambda = SyntaxFactory.ParenthesizedLambdaExpression(stringFormat);
-                    return SyntaxFactory.Argument(stringFormatLambda);
-                }
+                return SyntaxFactory.Argument(unconditional ? stringFormat : SyntaxFactory.ParenthesizedLambdaExpression(stringFormat));
             }
 
             var formatSpecification = literalExpression.Token.ValueText;
@@ -114,17 +106,17 @@ internal static class CodeFixHelper
         /// </summary>
         /// <param name="arguments">The arguments passed to the 'Assert' method. </param>
         /// <param name="minimumNumberOfArguments">The argument needed for the actual method, any more are assumed messages.</param>
-        public static void UpdateStringFormatToFormattableString(bool argsIsArray, List<ArgumentSyntax> arguments, int minimumNumberOfArguments)
+        public static void UpdateStringFormatToFormattableString(List<ArgumentSyntax> arguments, int minimumNumberOfArguments, bool argsIsArray)
         {
             // If only 1 extra argument is passed, it must be a non-formattable message.
             if (arguments.Count <= minimumNumberOfArguments + 1)
                 return;
 
             ArgumentSyntax? message = GetInterpolatedMessageArgumentOrDefault(
-                minimumNumberOfArguments == 0,
-                argsIsArray,
                 arguments[minimumNumberOfArguments],
-                arguments.Skip(minimumNumberOfArguments + 1).ToList());
+                arguments.Skip(minimumNumberOfArguments + 1).ToList(),
+                unconditional: minimumNumberOfArguments == 0,
+                argsIsArray);
 
             var nextArgument = minimumNumberOfArguments;
             if (message is not null)

src/nunit.analyzers/Helpers/DiagnosticsHelper.cs

@@ -9,7 +9,7 @@ internal static class DiagnosticsHelper
     {
         public static bool LastArgumentIsNonParamsArray(ImmutableArray<IArgumentOperation> arguments)
         {
-            // Find out of the 'params' argument is an existing array and not one created from a params creation.
+            // Find out if the 'params' argument is an existing array and not one created from a params creation.
             return arguments[arguments.Length - 1].ArgumentKind != ArgumentKind.ParamArray;
         }
 

src/nunit.analyzers/UpdateStringFormatToInterpolatableString/UpdateStringFormatToInterpolatableStringAnalyzer.cs

@@ -123,7 +123,7 @@ private static void AnalyzeNUnit4AssertInvocation(OperationAnalysisContext conte
                 // The argument after the message is explicitly specified
                 // Most likely the user thought it was using a format specification with a parameter.
                 // Or it copied code from some NUnit 3.x source into an NUNit 4 project.
-                ReportDiagnostic(context, assertOperation, methodName, formatParameterIndex, false);
+                ReportDiagnostic(context, assertOperation, methodName, formatParameterIndex, argsIsArray: false);
             }
         }
 

src/nunit.analyzers/UpdateStringFormatToInterpolatableString/UpdateStringFormatToInterpolatableStringCodeFix.cs

@@ -53,7 +53,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
             var minimumNumberOfArguments = int.Parse(diagnostic.Properties[AnalyzerPropertyKeys.MinimumNumberOfArguments]!, CultureInfo.InvariantCulture);
             bool argsIsArray = !string.IsNullOrEmpty(diagnostic.Properties[AnalyzerPropertyKeys.ArgsIsArray]);
 
-            CodeFixHelper.UpdateStringFormatToFormattableString(argsIsArray, arguments, minimumNumberOfArguments);
+            CodeFixHelper.UpdateStringFormatToFormattableString(arguments, minimumNumberOfArguments, argsIsArray);
 
             var newArgumentsList = invocationNode.ArgumentList.WithArguments(arguments);
             var newInvocationNode = invocationNode.WithArgumentList(newArgumentsList);