NET-1254 Fix S3878 FN: When params are passed as array throught an attribute

Author: mary-georgiou-sonarsource

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

@@ -17,26 +17,34 @@
 namespace SonarAnalyzer.CSharp.Rules;
 
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
-public sealed class ArrayPassedAsParams : ArrayPassedAsParamsBase<SyntaxKind, ArgumentSyntax>
+public sealed class ArrayPassedAsParams : ArrayPassedAsParamsBase<SyntaxKind, CSharpSyntaxNode>
 {
     protected override ILanguageFacade<SyntaxKind> Language => CSharpFacade.Instance;
 
     protected override SyntaxKind[] ExpressionKinds { get; } =
         [
             SyntaxKind.ObjectCreationExpression,
             SyntaxKind.InvocationExpression,
-            SyntaxKindEx.ImplicitObjectCreationExpression
+            SyntaxKindEx.ImplicitObjectCreationExpression,
+            SyntaxKind.Attribute
         ];
 
-    protected override ArgumentSyntax LastArgumentIfArrayCreation(SyntaxNode expression) =>
-        ArgumentList(expression) is { Arguments: { Count: > 0 } arguments }
-        && arguments.Last() is var lastArgument
-        && IsArrayCreation(lastArgument.Expression)
+    protected override CSharpSyntaxNode LastArgumentIfArrayCreation(SyntaxNode expression)
+    {
+        CSharpSyntaxNode lastArgument = expression switch
+        {
+            AttributeSyntax { ArgumentList.Arguments: { Count: > 0 } args } => args.Last(),
+            _ when ArgumentList(expression) is { Arguments: { Count: > 0 } args } => args.Last(),
+            _ => null
+        };
+
+        return IsArrayCreation(lastArgument)
             ? lastArgument
             : null;
+    }
 
-    protected override ITypeSymbol ArrayElementType(ArgumentSyntax argument, SemanticModel model) =>
-        argument.Expression switch
+    protected override ITypeSymbol ArrayElementType(CSharpSyntaxNode argument, SemanticModel model) =>
+        ArgumentExpression(argument) switch
         {
             ArrayCreationExpressionSyntax arrayCreation => model.GetTypeInfo(arrayCreation.Type.ElementType).Type,
             ImplicitArrayCreationExpressionSyntax implicitArrayCreation => (model.GetTypeInfo(implicitArrayCreation).Type as IArrayTypeSymbol)?.ElementType,
@@ -53,16 +61,27 @@ _ when ImplicitObjectCreationExpressionSyntaxWrapper.IsInstance(expression) =>
             _ => null
         };
 
-    private static bool IsArrayCreation(ExpressionSyntax expression) =>
-        expression switch
+    private static bool IsArrayCreation(CSharpSyntaxNode argument)
+    {
+        var expression = ArgumentExpression(argument);
+        return expression switch
         {
             ArrayCreationExpressionSyntax { Initializer: not null } => true,
             ImplicitArrayCreationExpressionSyntax => true,
             _ when CollectionExpressionSyntaxWrapper.IsInstance(expression) => !ContainsSpread((CollectionExpressionSyntaxWrapper)expression),
             _ => false
         };
+    }
 
     // [x, y, ..z] is not possible to be passed as params
     private static bool ContainsSpread(CollectionExpressionSyntaxWrapper expression) =>
         expression.Elements.Any(x => x.SyntaxNode.IsKind(SyntaxKindEx.SpreadElement));
+
+    private static ExpressionSyntax ArgumentExpression(CSharpSyntaxNode node) =>
+        node switch
+        {
+            ArgumentSyntax arg => arg.Expression,
+            AttributeArgumentSyntax arg => arg.Expression,
+            _ => null
+        };
 }

analyzers/tests/SonarAnalyzer.Test/TestCases/ArrayPassedAsParams.Latest.cs

@@ -76,3 +76,22 @@ public struct MyImmutableArray<T> : IEnumerable<T>
     IEnumerator<T> IEnumerable<T>.GetEnumerator() => default!;
     IEnumerator IEnumerable.GetEnumerator() => default!;
 }
+
+// Reproducer for https://github.com/SonarSource/sonar-dotnet/issues/6977
+public class Repro6977_CollectionExpression
+{
+    class ParamsAttribute : Attribute
+    {
+        public ParamsAttribute(params string[] values) { }
+        public ParamsAttribute(int a, string b, params string[] values) { }
+    }
+
+    internal enum Foo
+    {
+        [Params(["1", "2" ])] // Noncompliant
+        Red,
+
+        [Params("1", "2")]
+        Yellow
+    }
+}

analyzers/tests/SonarAnalyzer.Test/TestCases/ArrayPassedAsParams.cs

@@ -29,8 +29,8 @@ public void Base(string[] myArray)
         Method3(new string[] { "s1", "s2" }, new string[] { "s1", "s2" }); // Noncompliant
 //                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
         Method3(null, null);        // Compliant
-        Method4(new [] { "s1" });   // Compliant
-        Method4(new [] { "s1", "s2" }); // Compliant
+        Method4(new[] { "s1" });   // Compliant
+        Method4(new[] { "s1", "s2" }); // Compliant
 
         Method3(args: new string[] { "s1", "s2" }, a: new string[12]); // Compliant (if you specifically require the arguments to be passed in this order there is no way of making this compliant, thus we shouldn't raise)
         Method3(args: new string[12], a: new string[] { "s1", "s2" }); // Compliant
@@ -92,7 +92,7 @@ public void CallMethod(dynamic d)
         Method(new object[] { new int[] { 1, 2 } });                            // FN, elements in args: [System.Int32[]]
         Method(new int[] { 1, 2, 3, });                                         // Compliant, Elements in args: [System.Int32[]]
         Method(new String[] { "1", "2" }, new String[] { "1", "2" });           // Compliant, elements in args: [System.String[], System.String[]]
-        Method(new String[] { "1", "2"}, new int[] { 1, 2});                    // Compliant, elements in args: [System.String[], System.Int32[]]
+        Method(new String[] { "1", "2" }, new int[] { 1, 2 });                    // Compliant, elements in args: [System.String[], System.Int32[]]
         MethodMixed(1, new String[] { "1", "2" });                              // Noncompliant
         MethodArray(new String[] { "1", "2" }, new String[] { "1", "2" });      // Compliant, elements in args: [System.String[], System.String[]]
         MethodArray(new int[] { 1, 2 }, new int[] { 1, 2 });                    // Compliant, elements in args: [System.Int32[], System.Int32[]]
@@ -127,14 +127,25 @@ public class Repro6977
     class ParamsAttribute : Attribute
     {
         public ParamsAttribute(params string[] values) { }
+        public ParamsAttribute(int a, string b, params string[] values) { }
+        public ParamsAttribute() { }
     }
 
     internal enum Foo
     {
-        [Params(new[] { "1", "2" })] // FN
-        Bar,
+        [Params(new[] { "1", "2" })] // Noncompliant
+        Red,
 
         [Params("1", "2")]
-        FooBar
+        Yellow,
+
+        [Params(a: 1, b: "hello", values : new[] { "1", "2" })] // Noncompliant
+        Blue,
+
+        [Params(a: 1, values: new[] { "1", "2" }, b: "hello")]  // FN
+        Green,
+
+        [Params]
+        Violet
     }
 }