fix(generator): place CallerArgumentExpression before params in [GenerateAssertion] emit

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

@@ -0,0 +1,328 @@
+[  
+// <auto-generated/>
+#pragma warning disable
+#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 ContainsAny
+/// </summary>
+public sealed class String_ContainsAny_String_StringArray_Assertion : Assertion<string>
+{
+    private static readonly Task<AssertionResult> _passedTask = Task.FromResult(AssertionResult.Passed);
+
+    private readonly string _label;
+    private readonly string[] _candidates;
+
+    public String_ContainsAny_String_StringArray_Assertion(AssertionContext<string> context, string label, string[] candidates)
+        : base(context)
+    {
+        _label = label;
+        _candidates = candidates;
+    }
+
+    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!.ContainsAny(_label, _candidates);
+        return result
+            ? _passedTask
+            : Task.FromResult(AssertionResult.Failed($"found {value}"));
+    }
+
+    protected override string GetExpectation()
+    {
+        return $"to satisfy ContainsAny({_label}, {_candidates})";
+    }
+}
+
+/// <summary>
+/// Generated assertion for IsBetweenExcluding
+/// </summary>
+public sealed class Int_IsBetweenExcluding_Int_Int_IntArray_Assertion : Assertion<int>
+{
+    private static readonly Task<AssertionResult> _passedTask = Task.FromResult(AssertionResult.Passed);
+
+    private readonly int _min;
+    private readonly int _max;
+    private readonly int[] _excluded;
+
+    public Int_IsBetweenExcluding_Int_Int_IntArray_Assertion(AssertionContext<int> context, int min, int max, int[] excluded)
+        : base(context)
+    {
+        _min = min;
+        _max = max;
+        _excluded = excluded;
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<int> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        if (exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().FullName}"));
+        }
+
+        var result = value!.IsBetweenExcluding(_min, _max, _excluded);
+        return result
+            ? _passedTask
+            : Task.FromResult(AssertionResult.Failed($"found {value}"));
+    }
+
+    protected override string GetExpectation()
+    {
+        return $"to satisfy IsBetweenExcluding({_min}, {_max}, {_excluded})";
+    }
+}
+
+/// <summary>
+/// Generated assertion for MeetsLength
+/// </summary>
+public sealed class String_MeetsLength_Int_StringArray_Assertion : Assertion<string>
+{
+    private static readonly Task<AssertionResult> _passedTask = Task.FromResult(AssertionResult.Passed);
+
+    private readonly int _minLength;
+    private readonly string[] _suffixes;
+
+    public String_MeetsLength_Int_StringArray_Assertion(AssertionContext<string> context, int minLength, string[] suffixes)
+        : base(context)
+    {
+        _minLength = minLength;
+        _suffixes = suffixes;
+    }
+
+    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!.MeetsLength(_minLength, _suffixes);
+        return result
+            ? _passedTask
+            : Task.FromResult(AssertionResult.Failed($"found {value}"));
+    }
+
+    protected override string GetExpectation()
+    {
+        return $"to satisfy MeetsLength({_minLength}, {_suffixes})";
+    }
+}
+
+/// <summary>
+/// Generated assertion for IsOneOfWithDefault
+/// </summary>
+[System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2091", Justification = "Generic type parameter is only used for property access, not instantiation")]
+public sealed class T_IsOneOfWithDefault_T_TArray_Assertion<T> : Assertion<T>
+{
+    private static readonly Task<AssertionResult> _passedTask = Task.FromResult(AssertionResult.Passed);
+
+    private readonly T _fallback;
+    private readonly T[] _alternatives;
+
+    public T_IsOneOfWithDefault_T_TArray_Assertion(AssertionContext<T> context, T fallback, T[] alternatives)
+        : base(context)
+    {
+        _fallback = fallback;
+        _alternatives = alternatives;
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<T> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        if (exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().FullName}"));
+        }
+
+        var result = value!.IsOneOfWithDefault<T>(_fallback, _alternatives);
+        return result
+            ? _passedTask
+            : Task.FromResult(AssertionResult.Failed($"found {value}"));
+    }
+
+    protected override string GetExpectation()
+    {
+        return $"to satisfy IsOneOfWithDefault({_fallback}, {_alternatives})";
+    }
+}
+
+/// <summary>
+/// Generated assertion for StartsWithAny
+/// </summary>
+public sealed class String_StartsWithAny_String_StringArray_Assertion : Assertion<string>
+{
+    private static readonly Task<AssertionResult> _passedTask = Task.FromResult(AssertionResult.Passed);
+
+    private readonly string _prefix;
+    private readonly string[] _suffixes;
+
+    public String_StartsWithAny_String_StringArray_Assertion(AssertionContext<string> context, string prefix, string[] suffixes)
+        : base(context)
+    {
+        _prefix = prefix;
+        _suffixes = suffixes;
+    }
+
+    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 = _suffixes.Length >= 0 && value!.StartsWith(_prefix);
+        return result
+            ? _passedTask
+            : Task.FromResult(AssertionResult.Failed($"found {value}"));
+    }
+
+    protected override string GetExpectation()
+    {
+        return $"to satisfy StartsWithAny({_prefix}, {_suffixes})";
+    }
+}
+
+/// <summary>
+/// Generated assertion for ContainsExactly
+/// </summary>
+public sealed class String_ContainsExactly_StringArray_Assertion : Assertion<string>
+{
+    private static readonly Task<AssertionResult> _passedTask = Task.FromResult(AssertionResult.Passed);
+
+    private readonly string[] _required;
+
+    public String_ContainsExactly_StringArray_Assertion(AssertionContext<string> context, string[] required)
+        : base(context)
+    {
+        _required = required;
+    }
+
+    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!.ContainsExactly(_required);
+        return result
+            ? _passedTask
+            : Task.FromResult(AssertionResult.Failed($"found {value}"));
+    }
+
+    protected override string GetExpectation()
+    {
+        return $"to satisfy ContainsExactly({_required})";
+    }
+}
+
+public static partial class ParamsParameterAssertionExtensions
+{
+    /// <summary>
+    /// Generated extension method for ContainsAny
+    /// </summary>
+    public static String_ContainsAny_String_StringArray_Assertion ContainsAny(this IAssertionSource<string> source, string label, [CallerArgumentExpression(nameof(label))] string? labelExpression = null, params string[] candidates)
+    {
+        source.Context.ExpressionBuilder.Append($".ContainsAny({labelExpression}, {candidates})");
+        return new String_ContainsAny_String_StringArray_Assertion(source.Context, label, candidates);
+    }
+
+    /// <summary>
+    /// Generated extension method for IsBetweenExcluding
+    /// </summary>
+    public static Int_IsBetweenExcluding_Int_Int_IntArray_Assertion IsBetweenExcluding(this IAssertionSource<int> source, int min, int max, [CallerArgumentExpression(nameof(min))] string? minExpression = null, [CallerArgumentExpression(nameof(max))] string? maxExpression = null, params int[] excluded)
+    {
+        source.Context.ExpressionBuilder.Append($".IsBetweenExcluding({minExpression}, {maxExpression}, {excluded})");
+        return new Int_IsBetweenExcluding_Int_Int_IntArray_Assertion(source.Context, min, max, excluded);
+    }
+
+    /// <summary>
+    /// Generated extension method for MeetsLength
+    /// </summary>
+    public static String_MeetsLength_Int_StringArray_Assertion MeetsLength(this IAssertionSource<string> source, int minLength = 1, [CallerArgumentExpression(nameof(minLength))] string? minLengthExpression = null, params string[] suffixes)
+    {
+        source.Context.ExpressionBuilder.Append($".MeetsLength({minLengthExpression}, {suffixes})");
+        return new String_MeetsLength_Int_StringArray_Assertion(source.Context, minLength, suffixes);
+    }
+
+    /// <summary>
+    /// Generated extension method for IsOneOfWithDefault
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2091", Justification = "Generic type parameter is only used for property access, not instantiation")]
+    public static T_IsOneOfWithDefault_T_TArray_Assertion<T> IsOneOfWithDefault<T>(this IAssertionSource<T> source, T fallback, [CallerArgumentExpression(nameof(fallback))] string? fallbackExpression = null, params T[] alternatives)
+    {
+        source.Context.ExpressionBuilder.Append($".IsOneOfWithDefault({fallbackExpression}, {alternatives})");
+        return new T_IsOneOfWithDefault_T_TArray_Assertion<T>(source.Context, fallback, alternatives);
+    }
+
+    /// <summary>
+    /// Generated extension method for StartsWithAny
+    /// </summary>
+    public static String_StartsWithAny_String_StringArray_Assertion StartsWithAny(this IAssertionSource<string> source, string prefix, [CallerArgumentExpression(nameof(prefix))] string? prefixExpression = null, params string[] suffixes)
+    {
+        source.Context.ExpressionBuilder.Append($".StartsWithAny({prefixExpression}, {suffixes})");
+        return new String_StartsWithAny_String_StringArray_Assertion(source.Context, prefix, suffixes);
+    }
+
+    /// <summary>
+    /// Generated extension method for ContainsExactly
+    /// </summary>
+    public static String_ContainsExactly_StringArray_Assertion ContainsExactly(this IAssertionSource<string> source, params string[] required)
+    {
+        source.Context.ExpressionBuilder.Append($".ContainsExactly({required})");
+        return new String_ContainsExactly_StringArray_Assertion(source.Context, required);
+    }
+
+}
+
+]