Analyzer for providing too many arguments in [ArgumentsAttribute(...)] (

#1734)
thomhurst · Feb 1, 2025 · 42c9d8e · 42c9d8e
1 parent b10ca8e
commit 42c9d8e
Show file tree

Hide file tree

Showing 5 changed files with 90 additions and 16 deletions.
diff --git a/TUnit.Analyzers.Tests/DataDrivenTestArgumentsAnalyzerTests.cs b/TUnit.Analyzers.Tests/DataDrivenTestArgumentsAnalyzerTests.cs
@@ -215,4 +215,27 @@ public void Int_To_Short(short value)
                 """
             );
     }
+
+    [Test]
+    public async Task Error_When_Too_Many_Arguments()
+    {
+        await Verifier
+            .VerifyAnalyzerAsync(
+                """
+                using System.Threading.Tasks;
+                using TUnit.Core;
+
+                public class MyClass
+                {
+                    [Test]
+                    [{|#0:Arguments(null, "")|}]
+                    public void Create_Unit_Test(string? something)
+                    {
+                    }
+                }
+                """,
+                Verifier.Diagnostic(Rules.TooManyArguments)
+                    .WithLocation(0)
+            );
+    }
 }
diff --git a/TUnit.Analyzers/Resources.Designer.cs b/TUnit.Analyzers/Resources.Designer.cs
diff --git a/TUnit.Analyzers/Resources.resx b/TUnit.Analyzers/Resources.resx
@@ -459,4 +459,13 @@
     <data name="TUnit0049Title" xml:space="preserve">
         <value>[MatrixDataSourceAttribute] is required</value>
     </data>
+    <data name="TUnit0050Description" xml:space="preserve">
+        <value>Too many arguments provided.</value>
+    </data>
+    <data name="TUnit0050MessageFormat" xml:space="preserve">
+        <value>Too many arguments provided.</value>
+    </data>
+    <data name="TUnit0050Title" xml:space="preserve">
+        <value>Too many arguments provided</value>
+    </data>
 </root>
diff --git a/TUnit.Analyzers/Rules.cs b/TUnit.Analyzers/Rules.cs
@@ -117,6 +117,9 @@ public static class Rules
     public static DiagnosticDescriptor MatrixDataSourceAttributeRequired =
         CreateDescriptor("TUnit0049", UsageCategory, DiagnosticSeverity.Error);
 
+    public static readonly DiagnosticDescriptor TooManyArguments =
+        CreateDescriptor("TUnit0050", UsageCategory, DiagnosticSeverity.Error);
+
     private static DiagnosticDescriptor CreateDescriptor(string diagnosticId, string category, DiagnosticSeverity severity)
     {
         return new DiagnosticDescriptor(

diff --git a/TUnit.Analyzers/TestDataAnalyzer.cs b/TUnit.Analyzers/TestDataAnalyzer.cs
@@ -24,7 +24,8 @@ public class TestDataAnalyzer : ConcurrentDiagnosticAnalyzer
             Rules.PropertyRequiredNotSet,
             Rules.MustHavePropertySetter,
             Rules.ReturnFunc,
-            Rules.MatrixDataSourceAttributeRequired);
+            Rules.MatrixDataSourceAttributeRequired,
+            Rules.TooManyArguments);
 
     protected override void InitializeInternal(AnalysisContext context)
     { 
@@ -126,7 +127,7 @@ private void Analyze(SymbolAnalysisContext context,
             if (SymbolEqualityComparer.Default.Equals(attribute.AttributeClass,
                     context.Compilation.GetTypeByMetadataName(WellKnown.AttributeFullyQualifiedClasses.Arguments.WithoutGlobalPrefix)))
             {
-                CheckArguments(context, attribute, parameters);
+                CheckArguments(context, attribute, parameters, propertySymbol);
             }
 
             if (SymbolEqualityComparer.Default.Equals(attribute.AttributeClass,
@@ -175,7 +176,7 @@ private ImmutableArray<ITypeSymbol> GetTypes(ImmutableArray<IParameterSymbol> pa
     }
 
     private void CheckArguments(SymbolAnalysisContext context, AttributeData argumentsAttribute,
-        ImmutableArray<IParameterSymbol> parameters)
+        ImmutableArray<IParameterSymbol> parameters, IPropertySymbol? propertySymbol)
     {
         if (argumentsAttribute.ConstructorArguments.IsDefaultOrEmpty)
         {
@@ -192,25 +193,36 @@ private void CheckArguments(SymbolAnalysisContext context, AttributeData argumen
 
         var cancellationTokenType = context.Compilation.GetTypeByMetadataName(typeof(CancellationToken).FullName!);
 
-        for (var i = 0; i < parameters.Length; i++)
+        for (var i = 0; i < Math.Max(parameters.Length, arguments.Length); i++)
         {
-            var parameter = parameters[i];
+            var parameter = parameters.ElementAtOrDefault(i);
+
+            if (parameter is null && propertySymbol is null)
+            {
+                context.ReportDiagnostic(
+                    Diagnostic.Create(Rules.TooManyArguments, argumentsAttribute.GetLocation())
+                );
+                break;
+            }
+
             var argumentExists = i + 1 <= arguments.Length;
-            var methodParameterType = parameter.Type;
+
+            var typeSymbol = parameter?.Type ?? propertySymbol!.Type;
+
             var argument = arguments.ElementAtOrDefault(i);
 
-            if (parameter.Type.IsCollectionType(context.Compilation, out var innerType)
+            if (typeSymbol.IsCollectionType(context.Compilation, out var innerType)
                 && arguments.Skip(i).Select(x => x.Type).All(x => SymbolEqualityComparer.Default.Equals(x, innerType)))
             {
                 break;
             }
 
-            if (SymbolEqualityComparer.Default.Equals(methodParameterType, cancellationTokenType))
+            if (SymbolEqualityComparer.Default.Equals(typeSymbol, cancellationTokenType))
             {
                 continue;
             }
 
-            if (!argumentExists && parameter.IsOptional)
+            if (!argumentExists && parameter?.IsOptional is true)
             {
                 continue;
             }
@@ -221,32 +233,32 @@ private void CheckArguments(SymbolAnalysisContext context, AttributeData argumen
                     Diagnostic.Create(Rules.WrongArgumentTypeTestData,
                         argumentsAttribute.GetLocation(),
                         "null",
-                        methodParameterType.ToDisplayString())
+                        typeSymbol.ToDisplayString())
                 );
                 return;
             }
 
-            if (argument.IsNull && methodParameterType.NullableAnnotation == NullableAnnotation.NotAnnotated)
+            if (argument.IsNull && typeSymbol.NullableAnnotation == NullableAnnotation.NotAnnotated)
             {
                 context.ReportDiagnostic(
                     Diagnostic.Create(Rules.MethodParameterBadNullability,
-                        parameters[i].Locations.FirstOrDefault(),
-                        parameters[i].Name)
+                        parameter?.Locations.FirstOrDefault() ?? propertySymbol!.Locations.FirstOrDefault(),
+                        parameter?.Name ?? propertySymbol!.Name)
                 );
             }
 
-            if (IsEnumAndInteger(methodParameterType, argument.Type))
+            if (IsEnumAndInteger(typeSymbol, argument.Type))
             {
                 continue;
             }
 
-            if (!argument.IsNull && !CanConvert(context, argument, methodParameterType))
+            if (!argument.IsNull && !CanConvert(context, argument, typeSymbol))
             {
                 context.ReportDiagnostic(
                     Diagnostic.Create(Rules.WrongArgumentTypeTestData,
                         argumentsAttribute.GetLocation(),
                         argument.Type?.ToDisplayString(),
-                        methodParameterType.ToDisplayString())
+                        typeSymbol.ToDisplayString())
                 );
                 return;
             }