Enhance NUnit analyzer converters with additional patterns

[thomhurst]

Summary

• Add support for Has.Count.EqualTo(n) → Count().IsEqualTo(n) conversion
• Add support for Has.Exactly(n).Items → Count().IsEqualTo(n) conversion
• Improve Is.Not.Zero to use IsNotZero() instead of IsNotEqualTo(0)
• Add support for Assert.Multiple(() => { ... }) → using (Assert.Multiple()) { ... } conversion

Fixes #4191

Test plan

• Added test NUnit_HasCount_Converted - verifies Has.Count.EqualTo pattern
• Added test NUnit_HasExactlyItems_Converted - verifies Has.Exactly(n).Items pattern
• Added test NUnit_IsNotZero_Converted - verifies Is.Not.Zero pattern
• Added test NUnit_AssertMultiple_Lambda_Converted - verifies Assert.Multiple lambda conversion
• All 65 NUnit migration tests pass

🤖 Generated with Claude Code

[thomhurst]

Summary

Enhances the NUnit-to-TUnit analyzer with four new conversion patterns.

Critical Issues

None found - all changes look good.

Suggestions

1. Consider null checks in ConvertAssertMultipleLambda when Visit returns null
2. Review trivia handling in CreateUsingMultipleStatement for closing brace indentation

Verdict

APPROVE - No blocking issues. Great work on test coverage!

[Copilot]

Pull request overview

This pull request enhances the NUnit to TUnit migration analyzer with four new conversion patterns:

• Has.Count.EqualTo(n) → Count().IsEqualTo(n) for collection count assertions
• Has.Exactly(n).Items → Count().IsEqualTo(n) for exact item count checks
• Is.Not.Zero → IsNotZero() for improved zero-check assertions
• Assert.Multiple(() => { ... }) → using (Assert.Multiple()) { ... } for batched assertions

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 7 comments.

File	Description
TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs	Adds 4 comprehensive test cases validating each new conversion pattern with expected input/output code
TUnit.Analyzers.CodeFixers/NUnitMigrationCodeFixProvider.cs	Implements the conversion logic for all 4 patterns including VisitExpressionStatement override for Assert.Multiple, constraint conversion methods, and CreateCountAssertion helper

[Copilot]

This Visit call uses a null-forgiving operator but could potentially return null. Consider adding null checks before casting to avoid potential NullReferenceExceptions.

[Copilot]

This Visit call uses a null-forgiving operator but could potentially return null. Consider adding null checks before casting to avoid potential NullReferenceExceptions.

[Copilot]

The ConvertAssertMultipleSimpleLambda and ConvertAssertMultipleLambda methods contain identical implementation logic. Consider extracting the common code into a single helper method that both can call, passing the lambda body as a parameter. This would reduce code duplication and improve maintainability.

[Copilot]

This code block for handling Has.Exactly(n).Items is duplicated in the ConvertConstraintMemberToTUnit method (lines 729-741). Consider extracting this pattern matching logic into a shared helper method to reduce code duplication and improve maintainability.

[Copilot]

The Has.Count.EqualTo(n) pattern handling is implemented in ConvertConstraintToTUnitWithMessage (lines 480-495) but is missing in the ConvertConstraintToTUnit method (line 589+). While ConvertConstraintToTUnit is primarily used for handling chained constraints like .Within(), it should still handle Has.Count patterns consistently for completeness and to avoid potential bugs if the code is refactored in the future.

[Copilot]

The Visit method is being called with null-forgiving operators (!) on lines 266, 272, 289, and 294, but CSharpSyntaxRewriter.Visit can return null for certain node types. While in this specific case the Visit calls are likely safe (they're visiting statements/expressions that will be converted), it would be more defensive to add null checks before casting to avoid potential NullReferenceExceptions if the Visit method returns null in unexpected cases.

Suggested change

	var convertedStatements = block.Statements.Select(s => (StatementSyntax)Visit(s)!).ToArray();
	statements = SyntaxFactory.List(convertedStatements);
	}
	else if (lambda.Body is ExpressionSyntax expr)
	{
	// Single expression lambda - convert it
	var visitedExpr = (ExpressionSyntax)Visit(expr)!;
	var convertedStatements = block.Statements
	.Select(s => (StatementSyntax)(Visit(s) ?? s))
	.ToArray();
	statements = SyntaxFactory.List(convertedStatements);
	}
	else if (lambda.Body is ExpressionSyntax expr)
	{
	// Single expression lambda - convert it
	var visitedExpr = (ExpressionSyntax)(Visit(expr) ?? expr);

[Copilot]

Similar to line 266, this Visit call uses a null-forgiving operator but could potentially return null. Consider adding null checks before casting.