Fix params argument if type isn't exact much but is implicitly convertible (#2114)

* Fix params argument if type isn't exact much but is implicitly convertible

* Don't consider string a collection

* Fix

Author: thomhurst

TUnit.Analyzers.Tests/ArgumentsAnalyzerTests.cs

@@ -0,0 +1,28 @@
+using NUnit.Framework;
+using Verifier = TUnit.Analyzers.Tests.Verifiers.CSharpAnalyzerVerifier<TUnit.Analyzers.TestDataAnalyzer>;
+
+namespace TUnit.Analyzers.Tests;
+
+public class ArgumentsAnalyzerTests
+{
+    [Test]
+    public async Task Test_No_Error()
+    {
+        await Verifier
+            .VerifyAnalyzerAsync(
+                """
+                using TUnit.Core;
+
+                public class MyClass
+                {
+                    [Test]
+                    [Arguments(0, 1L)] // this is ok
+                    [Arguments(0, 1)] // Error TUnit0001 : Attribute argument types 'int' don't match method parameter types 'long[]'
+                    public void Test(int a, params long[] arr)
+                    {
+                    }
+                }
+                """
+            );
+    }
+}

TUnit.Analyzers/Extensions/TypeExtensions.cs

@@ -124,6 +124,13 @@ public static bool IsAsyncDisposable(this ITypeSymbol type)
 
     public static bool IsCollectionType(this ITypeSymbol typeSymbol, Compilation compilation, [NotNullWhen(true)] out ITypeSymbol? innerType)
     {
+        if (typeSymbol.SpecialType == SpecialType.System_String)
+        {
+            // Technically a collection but not what we're looking for
+            innerType = null;
+            return false;
+        }
+        
         if (typeSymbol is IArrayTypeSymbol arrayTypeSymbol)
         {
             innerType = arrayTypeSymbol.ElementType;

TUnit.Analyzers/TestDataAnalyzer.cs

@@ -213,7 +213,7 @@ private void CheckArguments(SymbolAnalysisContext context, AttributeData argumen
             var argument = arguments.ElementAtOrDefault(i);
 
             if (typeSymbol.IsCollectionType(context.Compilation, out var innerType)
-                && arguments.Skip(i).Select(x => x.Type).All(x => SymbolEqualityComparer.Default.Equals(x, innerType)))
+                && arguments.Skip(i).Select(x => x.Type).All(x => CanConvert(context, x, innerType)))
             {
                 break;
             }
@@ -596,17 +596,22 @@ private static bool CanConvert(SymbolAnalysisContext context, TypedConstant argu
             return true;
         }
 
-        if (argument.Type is not null
+        return CanConvert(context, argument.Type, methodParameterType);
+    }
+    
+    private static bool CanConvert(SymbolAnalysisContext context, ITypeSymbol? argumentType, ITypeSymbol? methodParameterType)
+    {
+        if (argumentType is not null
             && methodParameterType is not null
-            && context.Compilation.ClassifyConversion(argument.Type, methodParameterType)
+            && context.Compilation.ClassifyConversion(argumentType, methodParameterType)
                 is { IsImplicit: true }
                 or { IsExplicit: true }
                 or { IsNumeric: true })
         {
             return true;
         }
 
-        return context.Compilation.HasImplicitConversionOrGenericParameter(argument.Type, methodParameterType);
+        return context.Compilation.HasImplicitConversionOrGenericParameter(argumentType, methodParameterType);
     }
 
     private bool IsEnumAndInteger(ITypeSymbol? type1, ITypeSymbol? type2)

TUnit.Core.SourceGenerator.Tests/Bugs/2112/Tests2112.cs

@@ -0,0 +1,17 @@
+using TUnit.Core.SourceGenerator.CodeGenerators;
+
+namespace TUnit.Core.SourceGenerator.Tests.Bugs._2112;
+
+internal class Tests2112 : TestsBase<TestsGenerator>
+{
+    [Test]
+    public Task Test() => RunTest(Path.Combine(Git.RootDirectory.FullName,
+            "TUnit.TestProject",
+            "Bugs",
+            "2112",
+            "Tests.cs"),
+        async generatedFiles =>
+        {
+            await Assert.That(generatedFiles.Length).IsEqualTo(2);
+        });
+}