fix: point analyzer diagnostics to specific parameters instead of methods

TUnit.Analyzers.Tests/GlobalTestHooksAnalyzerTests.cs

@@ -89,11 +89,11 @@ await Verifier
                 """
                 using TUnit.Core;
                 using static TUnit.Core.HookType;
-                     
+
                 public class Tests
                 {
                     [BeforeEvery(Test)]
-                    public static void {|#0:SetUp|}(string unknown)
+                    public static void SetUp(string {|#0:unknown|})
                     {
                     }
                 }
@@ -269,11 +269,11 @@ await Verifier
                 """
                 using TUnit.Core;
                 using static TUnit.Core.HookType;
-                     
+
                 public class Tests
                 {
                     [AfterEvery(Test)]
-                    public static void {|#0:CleanUp|}(string unknown)
+                    public static void CleanUp(string {|#0:unknown|})
                     {
                     }
                 }
@@ -292,11 +292,11 @@ await Verifier
                 """
                 using TUnit.Core;
                 using static TUnit.Core.HookType;
-                     
+
                 public class Tests
                 {
                     [AfterEvery(Class)]
-                    public static void {|#0:CleanUp|}(int unknown1, string unknown2)
+                    public static void CleanUp(int {|#0:unknown1|}, string unknown2)
                     {
                     }
                 }
@@ -315,11 +315,11 @@ await Verifier
                 """
                 using TUnit.Core;
                 using static TUnit.Core.HookType;
-                     
+
                 public class Tests
                 {
                     [AfterEvery(Assembly)]
-                    public static void {|#0:CleanUp|}(object unknown)
+                    public static void CleanUp(object {|#0:unknown|})
                     {
                     }
                 }

TUnit.Analyzers.Tests/TestMethodParametersAnalyzerTests.cs

@@ -34,7 +34,7 @@ await Verifier
                 public class MyClass
                 {
                     [Test]
-                    public void {|#0:MyTest|}(int value)
+                    public void MyTest(int {|#0:value|})
                     {
                     }
                 }

TUnit.Analyzers/AssemblyTestHooksAnalyzer.cs

@@ -65,8 +65,9 @@ private void AnalyzeSymbol(SymbolAnalysisContext context)
 
         if (!IsAssemblyHookContextParameter(methodSymbol))
         {
+            var firstBadParam = FindFirstUnknownParameter(methodSymbol);
             context.ReportDiagnostic(Diagnostic.Create(Rules.UnknownParameters,
-                context.Symbol.Locations.FirstOrDefault(),
+                firstBadParam?.Locations.FirstOrDefault() ?? context.Symbol.Locations.FirstOrDefault(),
                 "empty or only contain `AssemblyHookContext` and `CancellationToken`")
             );
         }
@@ -105,4 +106,20 @@ private static bool IsAssemblyHookContextParameter(IMethodSymbol methodSymbol)
 
         return true;
     }
+
+    private static IParameterSymbol? FindFirstUnknownParameter(IMethodSymbol methodSymbol)
+    {
+        foreach (var parameter in methodSymbol.Parameters)
+        {
+            if (parameter.Type.GloballyQualified() !=
+                WellKnown.AttributeFullyQualifiedClasses.AssemblyHookContext.WithGlobalPrefix &&
+                parameter.Type.GloballyQualified() !=
+                WellKnown.AttributeFullyQualifiedClasses.CancellationToken.WithGlobalPrefix)
+            {
+                return parameter;
+            }
+        }
+
+        return null;
+    }
 }

TUnit.Analyzers/ClassHooksAnalyzer.cs

@@ -64,8 +64,9 @@ private void AnalyzeSymbol(SymbolAnalysisContext context)
 
         if (!IsClassHookContextParameter(methodSymbol))
         {
+            var firstBadParam = FindFirstUnknownParameter(methodSymbol);
             context.ReportDiagnostic(Diagnostic.Create(Rules.UnknownParameters,
-                context.Symbol.Locations.FirstOrDefault(),
+                firstBadParam?.Locations.FirstOrDefault() ?? context.Symbol.Locations.FirstOrDefault(),
                 "empty or only contain `ClassHookContext`")
             );
         }
@@ -97,4 +98,20 @@ private static bool IsClassHookContextParameter(IMethodSymbol methodSymbol)
 
         return true;
     }
+
+    private static IParameterSymbol? FindFirstUnknownParameter(IMethodSymbol methodSymbol)
+    {
+        foreach (var parameter in methodSymbol.Parameters)
+        {
+            if (parameter.Type.GloballyQualified() !=
+                WellKnown.AttributeFullyQualifiedClasses.ClassHookContext.WithGlobalPrefix &&
+                parameter.Type.GloballyQualified() !=
+                WellKnown.AttributeFullyQualifiedClasses.CancellationToken.WithGlobalPrefix)
+            {
+                return parameter;
+            }
+        }
+
+        return null;
+    }
 }

TUnit.Analyzers/GlobalTestHooksAnalyzer.cs

@@ -110,9 +110,10 @@ private void AnalyzeSymbol(SymbolAnalysisContext context)
                             HookLevel.Assembly => "AssemblyHookContext",
                             _ => "context"
                         };
+                        var firstBadParam = FindFirstUnknownParameter(methodSymbol, contextType!);
                         context.ReportDiagnostic(Diagnostic.Create(
-                            Rules.HookUnknownParameters, 
-                            methodSymbol.Locations.FirstOrDefault(),
+                            Rules.HookUnknownParameters,
+                            firstBadParam?.Locations.FirstOrDefault() ?? methodSymbol.Locations.FirstOrDefault(),
                             expectedContextTypeName));
                         break;
                 }
@@ -182,4 +183,19 @@ private static HookParameterStatus CheckHookParameters(IMethodSymbol methodSymbo
         // Anything else is unknown/invalid
         return HookParameterStatus.UnknownParameters;
     }
+
+    private static IParameterSymbol? FindFirstUnknownParameter(IMethodSymbol methodSymbol, string contextType)
+    {
+        foreach (var parameter in methodSymbol.Parameters)
+        {
+            var paramType = parameter.Type.GloballyQualifiedNonGeneric();
+            if (paramType != contextType &&
+                paramType != "global::System.Threading.CancellationToken")
+            {
+                return parameter;
+            }
+        }
+
+        return null;
+    }
 }

TUnit.Analyzers/InstanceTestHooksAnalyzer.cs

@@ -44,8 +44,9 @@ private void AnalyzeSymbol(SymbolAnalysisContext context)
 
         if (!IsContextParameter(methodSymbol))
         {
+            var firstBadParam = FindFirstUnknownParameter(methodSymbol);
             context.ReportDiagnostic(Diagnostic.Create(Rules.MethodMustBeParameterless,
-                context.Symbol.Locations.FirstOrDefault())
+                firstBadParam?.Locations.FirstOrDefault() ?? context.Symbol.Locations.FirstOrDefault())
             );
         }
 
@@ -83,4 +84,20 @@ private static bool IsContextParameter(IMethodSymbol methodSymbol)
 
         return true;
     }
+
+    private static IParameterSymbol? FindFirstUnknownParameter(IMethodSymbol methodSymbol)
+    {
+        foreach (var parameter in methodSymbol.Parameters)
+        {
+            if (parameter.Type.GloballyQualified() !=
+                WellKnown.AttributeFullyQualifiedClasses.TestContext.WithGlobalPrefix &&
+                parameter.Type.GloballyQualified() !=
+                WellKnown.AttributeFullyQualifiedClasses.CancellationToken.WithGlobalPrefix)
+            {
+                return parameter;
+            }
+        }
+
+        return null;
+    }
 }

TUnit.Analyzers/MatrixAnalyzer.cs

@@ -95,7 +95,7 @@ private void CheckMatrixErrors(SymbolAnalysisContext context, ImmutableArray<Att
                 if (!conversion.Exists)
                 {
                     context.ReportDiagnostic(Diagnostic.Create(Rules.WrongArgumentTypeTestData,
-                        context.Symbol.Locations.FirstOrDefault(),
+                        parameterSymbol.Locations.FirstOrDefault() ?? context.Symbol.Locations.FirstOrDefault(),
                         arrayItem.Type,
                         parameterSymbol.Type));
 

TUnit.Analyzers/TestMethodParametersAnalyzer.cs

@@ -37,7 +37,8 @@ private void AnalyzeSymbol(SymbolAnalysisContext context)
 
         if (!methodSymbol.HasDataDrivenAttributes())
         {
-            context.ReportDiagnostic(Diagnostic.Create(Rules.NoDataSourceProvided, methodSymbol.Locations.FirstOrDefault()));
+            context.ReportDiagnostic(Diagnostic.Create(Rules.NoDataSourceProvided,
+                parameters[0].Locations.FirstOrDefault() ?? methodSymbol.Locations.FirstOrDefault()));
         }
     }
 }

TUnit.Analyzers/TimeoutCancellationTokenAnalyzer.cs

@@ -58,7 +58,7 @@ private void AnalyzeSymbol(SymbolAnalysisContext context)
         {
             context.ReportDiagnostic(
                 Diagnostic.Create(Rules.MissingTimeoutCancellationTokenAttributes,
-                    context.Symbol.Locations.FirstOrDefault())
+                    lastParameter.Locations.FirstOrDefault() ?? context.Symbol.Locations.FirstOrDefault())
             );
         }
     }