Fix S3415 FP/FN: Support named arguments

analyzers/src/SonarAnalyzer.CSharp/Facade/CSharpFacade.cs

@@ -18,6 +18,7 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
+using Microsoft.CodeAnalysis;
 using SonarAnalyzer.Helpers.Facade;
 
 namespace SonarAnalyzer.Helpers;
@@ -51,13 +52,19 @@ internal sealed class CSharpFacade : ILanguageFacade<SyntaxKind>
         node.FindConstantValue(model);
 
     public IMethodParameterLookup MethodParameterLookup(SyntaxNode invocation, IMethodSymbol methodSymbol) =>
+        invocation != null ? new CSharpMethodParameterLookup(GetArgumentList(invocation), methodSymbol) : null;
+
+    public IMethodParameterLookup MethodParameterLookup(SyntaxNode invocation, SemanticModel semanticModel) =>
+        invocation != null ? new CSharpMethodParameterLookup(GetArgumentList(invocation), semanticModel) : null;
+
+    private static ArgumentListSyntax GetArgumentList(SyntaxNode invocation) =>
         invocation switch
         {
-            null => null,
-            ObjectCreationExpressionSyntax x => new CSharpMethodParameterLookup(x.ArgumentList, methodSymbol),
-            InvocationExpressionSyntax x => new CSharpMethodParameterLookup(x, methodSymbol),
+            ArgumentListSyntax x => x,
+            ObjectCreationExpressionSyntax x => x.ArgumentList,
+            InvocationExpressionSyntax x => x.ArgumentList,
             _ when ImplicitObjectCreationExpressionSyntaxWrapper.IsInstance(invocation) =>
-                new CSharpMethodParameterLookup(((ImplicitObjectCreationExpressionSyntaxWrapper)invocation).ArgumentList, methodSymbol),
+                ((ImplicitObjectCreationExpressionSyntaxWrapper)invocation).ArgumentList,
             _ => throw new ArgumentException($"{invocation.GetType()} does not contain an ArgumentList.", nameof(invocation)),
         };
 

analyzers/src/SonarAnalyzer.CSharp/Helpers/CSharpMethodParameterLookup.cs

@@ -18,26 +18,25 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
-namespace SonarAnalyzer.Helpers
+namespace SonarAnalyzer.Helpers;
+
+internal class CSharpMethodParameterLookup : MethodParameterLookupBase<ArgumentSyntax>
 {
-    internal class CSharpMethodParameterLookup : MethodParameterLookupBase<ArgumentSyntax>
-    {
-        public CSharpMethodParameterLookup(InvocationExpressionSyntax invocation, SemanticModel semanticModel)
-            : this(invocation.ArgumentList, semanticModel) { }
+    public CSharpMethodParameterLookup(InvocationExpressionSyntax invocation, SemanticModel semanticModel)
+        : this(invocation.ArgumentList, semanticModel) { }
 
-        public CSharpMethodParameterLookup(InvocationExpressionSyntax invocation, IMethodSymbol methodSymbol)
-            : this(invocation.ArgumentList, methodSymbol) { }
+    public CSharpMethodParameterLookup(InvocationExpressionSyntax invocation, IMethodSymbol methodSymbol)
+        : this(invocation.ArgumentList, methodSymbol) { }
 
-        public CSharpMethodParameterLookup(ArgumentListSyntax argumentList, SemanticModel semanticModel)
-            : base(argumentList?.Arguments, argumentList == null ? null : semanticModel.GetSymbolInfo(argumentList.Parent).Symbol as IMethodSymbol) { }
+    public CSharpMethodParameterLookup(ArgumentListSyntax argumentList, SemanticModel semanticModel)
+        : base(argumentList.Arguments, semanticModel.GetSymbolInfo(argumentList.Parent)) { }
 
-        public CSharpMethodParameterLookup(ArgumentListSyntax argumentList, IMethodSymbol methodSymbol)
-            : base(argumentList?.Arguments, methodSymbol) { }
+    public CSharpMethodParameterLookup(ArgumentListSyntax argumentList, IMethodSymbol methodSymbol)
+        : base(argumentList.Arguments, methodSymbol) { }
 
-        protected override SyntaxNode Expression(ArgumentSyntax argument) =>
-            argument.Expression;
+    protected override SyntaxNode Expression(ArgumentSyntax argument) =>
+        argument.Expression;
 
-        protected override SyntaxToken? GetNameColonArgumentIdentifier(ArgumentSyntax argument) =>
-            argument.NameColon?.Name.Identifier;
-    }
+    protected override SyntaxToken? GetNameColonArgumentIdentifier(ArgumentSyntax argument) =>
+        argument.NameColon?.Name.Identifier;
 }

analyzers/src/SonarAnalyzer.CSharp/Helpers/CSharpSyntaxHelper.cs

@@ -338,12 +338,10 @@ public static bool IsComment(this SyntaxTrivia trivia)
         ///
         /// There can be zero, one or more results based on parameter type (Optional or ParamArray/params).
         /// </summary>
-        public static ImmutableArray<SyntaxNode> ArgumentValuesForParameter(SemanticModel semanticModel, ArgumentListSyntax argumentList, string parameterName)
-        {
-            var methodParameterLookup = new CSharpMethodParameterLookup(argumentList, semanticModel);
-            return methodParameterLookup.TryGetSyntax(parameterName, out var expressions)
-                ? expressions
-                : ImmutableArray<SyntaxNode>.Empty;
-        }
+        public static ImmutableArray<SyntaxNode> ArgumentValuesForParameter(SemanticModel semanticModel, ArgumentListSyntax argumentList, string parameterName) =>
+            argumentList != null
+                && new CSharpMethodParameterLookup(argumentList, semanticModel).TryGetSyntax(parameterName, out var expressions)
+                    ? expressions
+                    : ImmutableArray<SyntaxNode>.Empty;
     }
 }

analyzers/src/SonarAnalyzer.CSharp/Rules/AssertionArgsShouldBePassedInCorrectOrder.cs

@@ -18,63 +18,85 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
-namespace SonarAnalyzer.Rules.CSharp
+namespace SonarAnalyzer.Rules.CSharp;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class AssertionArgsShouldBePassedInCorrectOrder : SonarDiagnosticAnalyzer
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public sealed class AssertionArgsShouldBePassedInCorrectOrder : SonarDiagnosticAnalyzer
-    {
-        internal const string DiagnosticId = "S3415";
-        private const string MessageFormat = "Make sure these 2 arguments are in the correct order: expected value, actual value.";
+    internal const string DiagnosticId = "S3415";
+    private const string MessageFormat = "Make sure these 2 arguments are in the correct order: expected value, actual value.";
 
-        private static readonly DiagnosticDescriptor Rule = DescriptorFactory.Create(DiagnosticId, MessageFormat);
-        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(Rule);
+    private static readonly DiagnosticDescriptor Rule = DescriptorFactory.Create(DiagnosticId, MessageFormat);
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(Rule);
 
-        private static readonly IDictionary<string, ImmutableArray<KnownType>> MethodsWithType = new Dictionary<string, ImmutableArray<KnownType>>
+    protected override void Initialize(SonarAnalysisContext context) =>
+        context.RegisterNodeAction(c =>
         {
-            ["AreEqual"]    = ImmutableArray.Create(KnownType.Microsoft_VisualStudio_TestTools_UnitTesting_Assert, KnownType.NUnit_Framework_Assert),
-            ["AreNotEqual"] = ImmutableArray.Create(KnownType.Microsoft_VisualStudio_TestTools_UnitTesting_Assert, KnownType.NUnit_Framework_Assert),
-            ["AreSame"]     = ImmutableArray.Create(KnownType.Microsoft_VisualStudio_TestTools_UnitTesting_Assert, KnownType.NUnit_Framework_Assert),
-            ["AreNotSame"]  = ImmutableArray.Create(KnownType.Microsoft_VisualStudio_TestTools_UnitTesting_Assert, KnownType.NUnit_Framework_Assert),
-            ["Equal"]       = ImmutableArray.Create(KnownType.Xunit_Assert),
-            ["Same"]        = ImmutableArray.Create(KnownType.Xunit_Assert),
-            ["NotSame"]     = ImmutableArray.Create(KnownType.Xunit_Assert)
-        };
-
-        protected override void Initialize(SonarAnalysisContext context) =>
-            context.RegisterNodeAction(c =>
+            if (c.Node is InvocationExpressionSyntax { ArgumentList: { Arguments.Count: >= 2 } argumentList } invocation
+                && GetParameters(invocation.GetName()) is { } knownAssertParameters
+                && c.SemanticModel.GetSymbolInfo(invocation).AllSymbols()
+                    .SelectMany(symbol =>
+                        symbol is IMethodSymbol { IsStatic: true, ContainingSymbol: INamedTypeSymbol container } methodSymbol
+                            ? knownAssertParameters.Select(knownParameters => FindWrongArguments(c.SemanticModel, container, methodSymbol, argumentList, knownParameters))
+                            : Enumerable.Empty<WrongArguments?>())
+                    .FirstOrDefault(x => x is not null) is (Expected: var expected, Actual: var actual))
             {
-                var methodCall = (InvocationExpressionSyntax)c.Node;
-                if (!methodCall.Expression.IsKind(SyntaxKind.SimpleMemberAccessExpression)
-                    || methodCall.ArgumentList.Arguments.Count < 2)
-                {
-                    return;
-                }
+                c.ReportIssue(Diagnostic.Create(Rule, CreateLocation(expected, actual)));
+            }
+        },
+        SyntaxKind.InvocationExpression);
 
-                var firstArgument = methodCall.ArgumentList.Arguments[0];
-                var secondArgument = methodCall.ArgumentList.Arguments[1];
-                if (firstArgument.Expression is LiteralExpressionSyntax
-                    || secondArgument.Expression is not LiteralExpressionSyntax)
+    private static KnownAssertParameters[] GetParameters(string name) =>
+        name switch
+        {
+            "AreEqual" => new KnownAssertParameters[]
                 {
-                    return;
-                }
-
-                var methodCallExpression = (MemberAccessExpressionSyntax)methodCall.Expression;
-
-                var methodKnownTypes = MethodsWithType.GetValueOrDefault(methodCallExpression.Name.Identifier.ValueText);
-                if (methodKnownTypes == null)
+                    new(KnownType.Microsoft_VisualStudio_TestTools_UnitTesting_Assert, "expected", "actual"),
+                    new(KnownType.NUnit_Framework_Assert, "expected", "actual")
+                },
+            "AreNotEqual" => new KnownAssertParameters[]
                 {
-                    return;
-                }
-
-                var symbolInfo = c.SemanticModel.GetSymbolInfo(methodCallExpression.Expression).Symbol;
-                var isAnyTrackedAssertType = (symbolInfo as INamedTypeSymbol).IsAny(methodKnownTypes);
-                if (!isAnyTrackedAssertType)
+                    new(KnownType.Microsoft_VisualStudio_TestTools_UnitTesting_Assert, "notExpected", "actual"),
+                    new(KnownType.NUnit_Framework_Assert, "expected", "actual")
+                },
+            "AreSame" => new KnownAssertParameters[]
+                {
+                    new(KnownType.Microsoft_VisualStudio_TestTools_UnitTesting_Assert, "expected", "actual"),
+                    new(KnownType.NUnit_Framework_Assert, "expected", "actual")
+                },
+            "AreNotSame" => new KnownAssertParameters[]
+                {
+                    new(KnownType.Microsoft_VisualStudio_TestTools_UnitTesting_Assert, "notExpected", "actual"),
+                    new(KnownType.NUnit_Framework_Assert, "expected", "actual")
+                },
+            "Equal" or "NotEqual" or "Same" or "NotSame" => new KnownAssertParameters[]
                 {
-                    return;
-                }
+                    new(KnownType.Xunit_Assert, "expected", "actual")
+                },
+            _ => null
+        };
+
+    private static WrongArguments? FindWrongArguments(SemanticModel semanticModel,
+                                                      INamedTypeSymbol container,
+                                                      IMethodSymbol symbol,
+                                                      ArgumentListSyntax argumentList,
+                                                      KnownAssertParameters knownParameters) =>
+        container.Is(knownParameters.AssertClass)
+        && CSharpFacade.Instance.MethodParameterLookup(argumentList, symbol) is var parameterLookup
+        && parameterLookup.TryGetSyntax(knownParameters.ExpectedParamterName, out var expectedArguments)
+        && expectedArguments.FirstOrDefault() is { } expected
+        && semanticModel.GetConstantValue(expected).HasValue is false
+        && parameterLookup.TryGetSyntax(knownParameters.ActualParameterName, out var actualArguments)
+        && actualArguments.FirstOrDefault() is { } actual
+        && semanticModel.GetConstantValue(actual).HasValue is true
+            ? new(expected, actual)
+            : null;
+
+    private static Location CreateLocation(SyntaxNode argument1, SyntaxNode argument2) =>
+        argument1.Span.CompareTo(argument2.Span) < 0
+            ? argument1.Parent.CreateLocation(argument2.Parent)
+            : argument2.Parent.CreateLocation(argument1.Parent);
 
-                c.ReportIssue(Diagnostic.Create(Rule, firstArgument.CreateLocation(secondArgument)));
-            },
-            SyntaxKind.InvocationExpression);
-    }
+    private readonly record struct KnownAssertParameters(KnownType AssertClass, string ExpectedParamterName, string ActualParameterName);
+    private readonly record struct WrongArguments(SyntaxNode Expected, SyntaxNode Actual);
 }

analyzers/src/SonarAnalyzer.CSharp/Trackers/CSharpObjectCreationTracker.cs

@@ -29,13 +29,11 @@ public class CSharpObjectCreationTracker : ObjectCreationTracker<SyntaxKind>
                        && argumentList.Arguments.Count > index
                        && argumentList.Arguments[index].Expression.HasConstantValue(context.SemanticModel);
 
-        internal override object ConstArgumentForParameter(ObjectCreationContext context, string parameterName)
-        {
-            var argumentList = ObjectCreationFactory.Create(context.Node).ArgumentList;
-            var values = CSharpSyntaxHelper.ArgumentValuesForParameter(context.SemanticModel, argumentList, parameterName);
-            return values.Length == 1 && values[0] is ExpressionSyntax valueSyntax
+        internal override object ConstArgumentForParameter(ObjectCreationContext context, string parameterName) =>
+            ObjectCreationFactory.TryCreate(context.Node, out var objectCreation)
+            && CSharpSyntaxHelper.ArgumentValuesForParameter(context.SemanticModel, objectCreation.ArgumentList, parameterName) is { Length: 1 } values
+            && values[0] is ExpressionSyntax valueSyntax
                 ? valueSyntax.FindConstantValue(context.SemanticModel)
                 : null;
-        }
     }
 }

analyzers/src/SonarAnalyzer.CSharp/Wrappers/ObjectCreationFactory.cs

@@ -49,6 +49,12 @@ node switch
                  ? Create(node)
                  : null;
 
+        public static bool TryCreate(SyntaxNode node, out IObjectCreation objectCreation)
+        {
+            objectCreation = TryCreate(node);
+            return objectCreation is not null;
+        }
+
         private class ObjectCreation : IObjectCreation
         {
             private readonly ObjectCreationExpressionSyntax objectCreation;

analyzers/src/SonarAnalyzer.Common/Facade/ILanguageFacade.cs

@@ -33,6 +33,7 @@ public interface ILanguageFacade
     DiagnosticDescriptor CreateDescriptor(string id, string messageFormat, bool? isEnabledByDefault = null, bool fadeOutCode = false);
     object FindConstantValue(SemanticModel model, SyntaxNode node);
     IMethodParameterLookup MethodParameterLookup(SyntaxNode invocation, IMethodSymbol methodSymbol);
+    IMethodParameterLookup MethodParameterLookup(SyntaxNode invocation, SemanticModel semanticModel);
     string GetName(SyntaxNode expression);
 }