Add ArrayAssertion<TItem> so GenerateAssertion works with concrete array types

TUnit.Assertions.SourceGenerator.Tests/MethodAssertionGeneratorTests.ArrayTargetType.DotNet10_0.verified.txt

@@ -0,0 +1,69 @@
+[  
+#nullable enable
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+using TUnit.Assertions.Core;
+using TUnit.Assertions.Tests.TestData;
+
+namespace TUnit.Assertions.Extensions;
+
+/// <summary>
+/// Generated assertion for ContainsMessage
+/// </summary>
+public sealed class StringArray_ContainsMessage_String_Bool_Assertion : Assertion<string[]>
+{
+    private static readonly Task<AssertionResult> _passedTask = Task.FromResult(AssertionResult.Passed);
+
+    private readonly string _needle;
+    private readonly bool _exact;
+
+    public StringArray_ContainsMessage_String_Bool_Assertion(AssertionContext<string[]> context, string needle, bool exact)
+        : base(context)
+    {
+        _needle = needle;
+        _exact = exact;
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<string[]> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        if (exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().FullName}"));
+        }
+
+        if (value is null)
+        {
+            return Task.FromResult(AssertionResult.Failed("Actual value is null"));
+        }
+
+        var result = value!.ContainsMessage(_needle, _exact);
+        return result
+            ? _passedTask
+            : Task.FromResult(AssertionResult.Failed($"found {value}"));
+    }
+
+    protected override string GetExpectation()
+    {
+        return $"to contain message '{_needle}'";
+    }
+}
+
+public static partial class ArrayTargetAssertionExtensions
+{
+    /// <summary>
+    /// Generated extension method for ContainsMessage
+    /// </summary>
+    public static StringArray_ContainsMessage_String_Bool_Assertion ContainsMessage(this IAssertionSource<string[]> source, string needle, bool exact, [CallerArgumentExpression(nameof(needle))] string? needleExpression = null, [CallerArgumentExpression(nameof(exact))] string? exactExpression = null)
+    {
+        source.Context.ExpressionBuilder.Append($".ContainsMessage({needleExpression}, {exactExpression})");
+        return new StringArray_ContainsMessage_String_Bool_Assertion(source.Context, needle, exact);
+    }
+
+}
+
+]

TUnit.Assertions.SourceGenerator.Tests/MethodAssertionGeneratorTests.ArrayTargetType.DotNet8_0.verified.txt

@@ -0,0 +1,69 @@
+[  
+#nullable enable
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+using TUnit.Assertions.Core;
+using TUnit.Assertions.Tests.TestData;
+
+namespace TUnit.Assertions.Extensions;
+
+/// <summary>
+/// Generated assertion for ContainsMessage
+/// </summary>
+public sealed class StringArray_ContainsMessage_String_Bool_Assertion : Assertion<string[]>
+{
+    private static readonly Task<AssertionResult> _passedTask = Task.FromResult(AssertionResult.Passed);
+
+    private readonly string _needle;
+    private readonly bool _exact;
+
+    public StringArray_ContainsMessage_String_Bool_Assertion(AssertionContext<string[]> context, string needle, bool exact)
+        : base(context)
+    {
+        _needle = needle;
+        _exact = exact;
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<string[]> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        if (exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().FullName}"));
+        }
+
+        if (value is null)
+        {
+            return Task.FromResult(AssertionResult.Failed("Actual value is null"));
+        }
+
+        var result = value!.ContainsMessage(_needle, _exact);
+        return result
+            ? _passedTask
+            : Task.FromResult(AssertionResult.Failed($"found {value}"));
+    }
+
+    protected override string GetExpectation()
+    {
+        return $"to contain message '{_needle}'";
+    }
+}
+
+public static partial class ArrayTargetAssertionExtensions
+{
+    /// <summary>
+    /// Generated extension method for ContainsMessage
+    /// </summary>
+    public static StringArray_ContainsMessage_String_Bool_Assertion ContainsMessage(this IAssertionSource<string[]> source, string needle, bool exact, [CallerArgumentExpression(nameof(needle))] string? needleExpression = null, [CallerArgumentExpression(nameof(exact))] string? exactExpression = null)
+    {
+        source.Context.ExpressionBuilder.Append($".ContainsMessage({needleExpression}, {exactExpression})");
+        return new StringArray_ContainsMessage_String_Bool_Assertion(source.Context, needle, exact);
+    }
+
+}
+
+]

TUnit.Assertions.SourceGenerator.Tests/MethodAssertionGeneratorTests.ArrayTargetType.DotNet9_0.verified.txt

@@ -0,0 +1,69 @@
+[  
+#nullable enable
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+using TUnit.Assertions.Core;
+using TUnit.Assertions.Tests.TestData;
+
+namespace TUnit.Assertions.Extensions;
+
+/// <summary>
+/// Generated assertion for ContainsMessage
+/// </summary>
+public sealed class StringArray_ContainsMessage_String_Bool_Assertion : Assertion<string[]>
+{
+    private static readonly Task<AssertionResult> _passedTask = Task.FromResult(AssertionResult.Passed);
+
+    private readonly string _needle;
+    private readonly bool _exact;
+
+    public StringArray_ContainsMessage_String_Bool_Assertion(AssertionContext<string[]> context, string needle, bool exact)
+        : base(context)
+    {
+        _needle = needle;
+        _exact = exact;
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<string[]> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        if (exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().FullName}"));
+        }
+
+        if (value is null)
+        {
+            return Task.FromResult(AssertionResult.Failed("Actual value is null"));
+        }
+
+        var result = value!.ContainsMessage(_needle, _exact);
+        return result
+            ? _passedTask
+            : Task.FromResult(AssertionResult.Failed($"found {value}"));
+    }
+
+    protected override string GetExpectation()
+    {
+        return $"to contain message '{_needle}'";
+    }
+}
+
+public static partial class ArrayTargetAssertionExtensions
+{
+    /// <summary>
+    /// Generated extension method for ContainsMessage
+    /// </summary>
+    public static StringArray_ContainsMessage_String_Bool_Assertion ContainsMessage(this IAssertionSource<string[]> source, string needle, bool exact, [CallerArgumentExpression(nameof(needle))] string? needleExpression = null, [CallerArgumentExpression(nameof(exact))] string? exactExpression = null)
+    {
+        source.Context.ExpressionBuilder.Append($".ContainsMessage({needleExpression}, {exactExpression})");
+        return new StringArray_ContainsMessage_String_Bool_Assertion(source.Context, needle, exact);
+    }
+
+}
+
+]

TUnit.Assertions.SourceGenerator.Tests/MethodAssertionGeneratorTests.ArrayTargetType.Net4_7.verified.txt

@@ -0,0 +1,69 @@
+[  
+#nullable enable
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+using TUnit.Assertions.Core;
+using TUnit.Assertions.Tests.TestData;
+
+namespace TUnit.Assertions.Extensions;
+
+/// <summary>
+/// Generated assertion for ContainsMessage
+/// </summary>
+public sealed class StringArray_ContainsMessage_String_Bool_Assertion : Assertion<string[]>
+{
+    private static readonly Task<AssertionResult> _passedTask = Task.FromResult(AssertionResult.Passed);
+
+    private readonly string _needle;
+    private readonly bool _exact;
+
+    public StringArray_ContainsMessage_String_Bool_Assertion(AssertionContext<string[]> context, string needle, bool exact)
+        : base(context)
+    {
+        _needle = needle;
+        _exact = exact;
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<string[]> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        if (exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().FullName}"));
+        }
+
+        if (value is null)
+        {
+            return Task.FromResult(AssertionResult.Failed("Actual value is null"));
+        }
+
+        var result = value!.ContainsMessage(_needle, _exact);
+        return result
+            ? _passedTask
+            : Task.FromResult(AssertionResult.Failed($"found {value}"));
+    }
+
+    protected override string GetExpectation()
+    {
+        return $"to contain message '{_needle}'";
+    }
+}
+
+public static partial class ArrayTargetAssertionExtensions
+{
+    /// <summary>
+    /// Generated extension method for ContainsMessage
+    /// </summary>
+    public static StringArray_ContainsMessage_String_Bool_Assertion ContainsMessage(this IAssertionSource<string[]> source, string needle, bool exact, [CallerArgumentExpression(nameof(needle))] string? needleExpression = null, [CallerArgumentExpression(nameof(exact))] string? exactExpression = null)
+    {
+        source.Context.ExpressionBuilder.Append($".ContainsMessage({needleExpression}, {exactExpression})");
+        return new StringArray_ContainsMessage_String_Bool_Assertion(source.Context, needle, exact);
+    }
+
+}
+
+]

TUnit.Assertions.SourceGenerator.Tests/MethodAssertionGeneratorTests.cs

@@ -234,4 +234,21 @@ public Task RefStructParameter() => RunTest(
             await Assert.That(mainFile).Contains("value!.Contains(_message)");
         });
 #endif
+
+    [Test]
+    public Task ArrayTargetType() => RunTest(
+        Path.Combine(Sourcy.Git.RootDirectory.FullName,
+            "TUnit.Assertions.SourceGenerator.Tests",
+            "TestData",
+            "ArrayTargetAssertion.cs"),
+        async generatedFiles =>
+        {
+            await Assert.That(generatedFiles).HasCount(1);
+
+            var mainFile = generatedFiles.FirstOrDefault(f => f.Contains("ContainsMessage"));
+            await Assert.That(mainFile).IsNotNull();
+            // Verify extension method targets IAssertionSource<string[]>
+            await Assert.That(mainFile!).Contains("IAssertionSource<string[]>");
+            await Assert.That(mainFile!).Contains("StringArray_ContainsMessage_String_Bool_Assertion");
+        });
 }

TUnit.Assertions.SourceGenerator.Tests/TestData/ArrayTargetAssertion.cs

@@ -0,0 +1,16 @@
+using TUnit.Assertions.Attributes;
+
+namespace TUnit.Assertions.Tests.TestData;
+
+/// <summary>
+/// Test case: GenerateAssertion targeting a concrete array type (string[])
+/// Should generate Assertion class and extension method using IAssertionSource&lt;string[]&gt;
+/// </summary>
+public static partial class ArrayTargetAssertionExtensions
+{
+    [GenerateAssertion(ExpectationMessage = "to contain message '{needle}'")]
+    public static bool ContainsMessage(this string[] strings, string needle, bool exact = true)
+    {
+        return strings.Any(x => exact ? x == needle : x.Contains(needle));
+    }
+}

TUnit.Assertions.SourceGenerator/Generators/MethodAssertionGenerator.cs

@@ -20,7 +20,7 @@
     public static string BuildAssertion = "MethodAssertionData";
 
     private static readonly DiagnosticDescriptor MethodMustBeStaticRule = new DiagnosticDescriptor(
         id: "TUNITGEN001",
         title: "Method must be static",
         messageFormat: "Method '{0}' decorated with [GenerateAssertion] must be static",
         category: "TUnit.Assertions.SourceGenerator",
@@ -29,7 +29,7 @@
         description: "Methods decorated with [GenerateAssertion] must be static to be used in generated assertions.");
 
     private static readonly DiagnosticDescriptor MethodMustHaveParametersRule = new DiagnosticDescriptor(
         id: "TUNITGEN002",
         title: "Method must have at least one parameter",
         messageFormat: "Method '{0}' decorated with [GenerateAssertion] must have at least one parameter (the value to assert)",
         category: "TUnit.Assertions.SourceGenerator",
@@ -38,18 +38,18 @@
         description: "Methods decorated with [GenerateAssertion] must have at least one parameter representing the value being asserted.");
 
     private static readonly DiagnosticDescriptor UnsupportedReturnTypeRule = new DiagnosticDescriptor(
         id: "TUNITGEN003",
         title: "Unsupported return type",
         messageFormat: "Method '{0}' decorated with [GenerateAssertion] has unsupported return type '{1}'. Supported types are: bool, AssertionResult, Task<bool>, Task<AssertionResult>",
         category: "TUnit.Assertions.SourceGenerator",
         defaultSeverity: DiagnosticSeverity.Error,
         isEnabledByDefault: true,
         description: "Methods decorated with [GenerateAssertion] must return bool, AssertionResult, Task<bool>, or Task<AssertionResult>.");
 
     private static readonly DiagnosticDescriptor RefStructRequiresInliningRule = new DiagnosticDescriptor(
         id: "TUNITGEN004",
         title: "Ref struct parameter requires method body inlining",
         messageFormat: "Method '{0}' has ref struct parameter '{1}' of type '{2}'. Use InlineMethodBody = true and ensure the method has a single-expression or single-return-statement body",
         category: "TUnit.Assertions.SourceGenerator",
         defaultSeverity: DiagnosticSeverity.Error,
         isEnabledByDefault: true,
@@ -825,7 +825,7 @@
         // Add null-forgiving operator for reference types if not already present
         // This is safe because we've already checked for null above
         var isNullable = data.TargetType.IsNullable;
         if (isNullable && !string.IsNullOrEmpty(inlinedBody) && !inlinedBody.StartsWith("value!"))
         {
             // Replace null-conditional operators with null-forgiving + regular operators
             // value?.Member becomes value!.Member (safe because we already null-checked)
@@ -1026,6 +1026,12 @@
 
     private static string GetSimpleTypeName(ITypeSymbol type)
     {
+        // Handle array types: string[] becomes StringArray
+        if (type is IArrayTypeSymbol arrayType)
+        {
+            return $"{GetSimpleTypeName(arrayType.ElementType)}Array";
+        }
+
         // Handle special types first
         var simpleName = type.SpecialType switch
         {

TUnit.Assertions.Tests/GenerateAssertionArrayTests.cs

@@ -0,0 +1,43 @@
+using TUnit.Assertions.Attributes;
+
+namespace TUnit.Assertions.Tests;
+
+/// <summary>
+/// Tests that [GenerateAssertion] works correctly when targeting concrete array types.
+/// The source generator creates an extension method on IAssertionSource&lt;string[]&gt;
+/// and ArrayAssertion&lt;string&gt; (returned by Assert.That(string[])) implements that interface.
+/// </summary>
+public class GenerateAssertionArrayTests
+{
+    [Test]
+    public async Task ContainsMessage_ExactMatch_Passes()
+    {
+        string[] items = ["food", "bard"];
+        await Assert.That(items).ContainsMessage("food", true);
+    }
+
+    [Test]
+    public async Task ContainsMessage_PartialMatch_Passes()
+    {
+        string[] items = ["food", "bard"];
+        await Assert.That(items).ContainsMessage("foo", false);
+    }
+
+    [Test]
+    public async Task ContainsMessage_NoMatch_Fails()
+    {
+        string[] items = ["food", "bard"];
+        var action = async () => await Assert.That(items).ContainsMessage("xyz", true);
+
+        await Assert.That(action).Throws<AssertionException>();
+    }
+}
+
+public static partial class GenerateAssertionArrayTestExtensions
+{
+    [GenerateAssertion(ExpectationMessage = "to contain message '{needle}'")]
+    public static bool ContainsMessage(this string[] strings, string needle, bool exact = true)
+    {
+        return strings.Any(x => exact ? x == needle : x.Contains(needle));
+    }
+}

TUnit.Assertions/Extensions/Assert.cs

@@ -190,15 +190,16 @@ public static ListAssertion<TItem> That<TItem>(
 
     /// <summary>
     /// Creates an assertion for an array value.
-    /// Arrays are routed to CollectionAssertion to preserve array-specific generated assertions.
+    /// Returns ArrayAssertion which implements IAssertionSource&lt;TItem[]&gt;,
+    /// enabling generated assertions that target concrete array types (e.g., string[]).
     /// Example: await Assert.That(array).IsSingleElement();
     /// </summary>
     [OverloadResolutionPriority(5)]
-    public static CollectionAssertion<TItem> That<TItem>(
+    public static ArrayAssertion<TItem> That<TItem>(
         TItem[]? value,
         [CallerArgumentExpression(nameof(value))] string? expression = null)
     {
-        return new CollectionAssertion<TItem>(value!, expression);
+        return new ArrayAssertion<TItem>(value, expression);
     }
 
     /// <summary>