refactor: reorganize migration process and enhance framework type det…

…ection

TUnit.Analyzers.CodeFixers/Base/BaseMigrationCodeFixProvider.cs

@@ -48,29 +48,29 @@ protected async Task<Document> ConvertCodeAsync(Document document, SyntaxNode? r
 
         try
         {
-            // Remove framework usings and add TUnit usings
-            compilationUnit = MigrationHelpers.RemoveFrameworkUsings(compilationUnit, FrameworkName);
-            compilationUnit = MigrationHelpers.AddTUnitUsings(compilationUnit);
-
-            // Convert attributes
-            var attributeRewriter = CreateAttributeRewriter();
-            compilationUnit = (CompilationUnitSyntax)attributeRewriter.Visit(compilationUnit);
-
-            // Convert assertions
+            // Convert assertions FIRST (while semantic model still matches the syntax tree)
             var assertionRewriter = CreateAssertionRewriter(semanticModel);
             compilationUnit = (CompilationUnitSyntax)assertionRewriter.Visit(compilationUnit);
-            
-            // Framework-specific conversions
+
+            // Framework-specific conversions (also use semantic model while it still matches)
             compilationUnit = ApplyFrameworkSpecificConversions(compilationUnit, semanticModel);
-            
+
             // Remove unnecessary base classes and interfaces
             var baseTypeRewriter = CreateBaseTypeRewriter(semanticModel);
             compilationUnit = (CompilationUnitSyntax)baseTypeRewriter.Visit(compilationUnit);
-            
+
             // Update lifecycle methods
             var lifecycleRewriter = CreateLifecycleRewriter();
             compilationUnit = (CompilationUnitSyntax)lifecycleRewriter.Visit(compilationUnit);
-
+
+            // Convert attributes
+            var attributeRewriter = CreateAttributeRewriter();
+            compilationUnit = (CompilationUnitSyntax)attributeRewriter.Visit(compilationUnit);
+
+            // Remove framework usings and add TUnit usings (do this LAST)
+            compilationUnit = MigrationHelpers.RemoveFrameworkUsings(compilationUnit, FrameworkName);
+            compilationUnit = MigrationHelpers.AddTUnitUsings(compilationUnit);
+
             return document.WithSyntaxRoot(compilationUnit);
         }
         catch

TUnit.Analyzers.CodeFixers/NUnitMigrationCodeFixProvider.cs

@@ -138,9 +138,9 @@ protected override bool IsFrameworkAssertionNamespace(string namespaceName)
             return ConvertAssertThat(invocation);
         }
 
-        // Handle classic assertions like Assert.AreEqual, Assert.IsTrue, etc.
+        // Handle classic assertions like Assert.AreEqual, ClassicAssert.AreEqual, etc.
         if (invocation.Expression is MemberAccessExpressionSyntax classicMemberAccess &&
-            classicMemberAccess.Expression is IdentifierNameSyntax { Identifier.Text: "Assert" })
+            classicMemberAccess.Expression is IdentifierNameSyntax { Identifier.Text: "Assert" or "ClassicAssert" })
         {
             return ConvertClassicAssertion(invocation, classicMemberAccess.Name.Identifier.Text);
         }

TUnit.Analyzers.Tests/MSTestMigrationAnalyzerTests.cs

@@ -301,15 +301,11 @@ public void MyMethod()
 
     private static void ConfigureMSTestTest(Verifier.Test test)
     {
-        var globalUsings = ("GlobalUsings.cs", SourceText.From("global using Microsoft.VisualStudio.TestTools.UnitTesting;"));
-        test.TestState.Sources.Add(globalUsings);
         test.TestState.AdditionalReferences.Add(typeof(TestMethodAttribute).Assembly);
     }
-    
+
     private static void ConfigureMSTestTest(CodeFixer.Test test)
     {
-        var globalUsings = ("GlobalUsings.cs", SourceText.From("global using Microsoft.VisualStudio.TestTools.UnitTesting;"));
-        test.TestState.Sources.Add(globalUsings);
         test.TestState.AdditionalReferences.Add(typeof(TestMethodAttribute).Assembly);
         test.FixedState.AdditionalReferences.Add(typeof(TestMethodAttribute).Assembly);
     }

TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs

@@ -138,11 +138,12 @@ public async Task NUnit_Classic_Assertions_Converted()
         await CodeFixer.VerifyCodeFixAsync(
             """
                 using NUnit.Framework;
+                using NUnit.Framework.Legacy;
 
                 {|#0:public class MyClass|}
                 {
                     [Test]
-                    public void MyMethod() 
+                    public void MyMethod()
                     {
                         ClassicAssert.AreEqual(5, 5);
                         ClassicAssert.IsTrue(true);
@@ -160,7 +161,7 @@ public void MyMethod()
                 public class MyClass
                 {
                     [Test]
-                    public void MyMethod() 
+                    public void MyMethod()
                     {
                         await Assert.That(5).IsEqualTo(5);
                         await Assert.That(true).IsTrue();
@@ -260,16 +261,12 @@ public void MyMethod() { }
 
     private static void ConfigureNUnitTest(Verifier.Test test)
     {
-        var globalUsings = ("GlobalUsings.cs", SourceText.From("global using NUnit.Framework;"));
-        test.TestState.Sources.Add(globalUsings);
-        test.TestState.AdditionalReferences.Add(typeof(TestAttribute).Assembly);
+        test.TestState.AdditionalReferences.Add(typeof(NUnit.Framework.TestAttribute).Assembly);
     }
-    
+
     private static void ConfigureNUnitTest(CodeFixer.Test test)
     {
-        var globalUsings = ("GlobalUsings.cs", SourceText.From("global using NUnit.Framework;"));
-        test.TestState.Sources.Add(globalUsings);
-        test.TestState.AdditionalReferences.Add(typeof(TestAttribute).Assembly);
-        test.FixedState.AdditionalReferences.Add(typeof(TestAttribute).Assembly);
+        test.TestState.AdditionalReferences.Add(typeof(NUnit.Framework.TestAttribute).Assembly);
+        test.FixedState.AdditionalReferences.Add(typeof(NUnit.Framework.TestAttribute).Assembly);
     }
 }

TUnit.Analyzers/Migrators/Base/BaseMigrationAnalyzer.cs

@@ -1,8 +1,11 @@
+using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
 
 namespace TUnit.Analyzers.Migrators.Base;
 
@@ -39,19 +42,39 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
                 return;
             }
 
+            // Priority 1: Framework interfaces on the class
             if (HasFrameworkInterfaces(symbol))
             {
                 Flag(context, classDeclarationSyntax.GetLocation());
                 return;
             }
 
+            // Priority 2: Framework attributes on the class
             var classAttributeLocation = AnalyzeAttributes(context, symbol, classDeclarationSyntax);
             if (classAttributeLocation != null)
             {
                 Flag(context, classAttributeLocation);
                 return;
             }
 
+            // Priority 3: Framework types in the class (e.g., Assert calls)
+            // Flag on the class declaration so the entire class can be migrated
+            if (HasFrameworkTypes(context, symbol, classDeclarationSyntax))
+            {
+                // Flag the class declaration line: from start of modifiers to end of class name
+                var classHeaderSpan = TextSpan.FromBounds(
+                    classDeclarationSyntax.SpanStart,
+                    classDeclarationSyntax.Identifier.Span.End);
+                var classHeaderLocation = Location.Create(
+                    classDeclarationSyntax.SyntaxTree,
+                    classHeaderSpan);
+                Flag(context, classHeaderLocation);
+                return;
+            }
+
+            // Priority 4: Framework attributes on methods
+            // Collect all methods with framework attributes
+            var methodsWithFrameworkAttributes = new List<(IMethodSymbol symbol, Location location)>();
             foreach (var methodSymbol in symbol.GetMembers().OfType<IMethodSymbol>())
             {
                 var syntaxReferences = methodSymbol.DeclaringSyntaxReferences;
@@ -64,21 +87,34 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
                 var methodAttributeLocation = AnalyzeAttributes(context, methodSymbol, methodSyntax);
                 if (methodAttributeLocation != null)
                 {
-                    Flag(context, methodAttributeLocation);
-                    return;
+                    methodsWithFrameworkAttributes.Add((methodSymbol, methodAttributeLocation));
                 }
             }
 
-            var usingLocation = CheckUsingDirectives(classDeclarationSyntax);
-            if (usingLocation != null)
+            // If multiple methods have framework attributes, flag the class declaration
+            // If only one method has framework attributes, flag that specific attribute
+            if (methodsWithFrameworkAttributes.Count > 1)
             {
-                Flag(context, usingLocation);
+                var classHeaderSpan = TextSpan.FromBounds(
+                    classDeclarationSyntax.SpanStart,
+                    classDeclarationSyntax.Identifier.Span.End);
+                var classHeaderLocation = Location.Create(
+                    classDeclarationSyntax.SyntaxTree,
+                    classHeaderSpan);
+                Flag(context, classHeaderLocation);
+                return;
+            }
+            else if (methodsWithFrameworkAttributes.Count == 1)
+            {
+                Flag(context, methodsWithFrameworkAttributes[0].location);
                 return;
             }
 
-            if (HasFrameworkTypes(symbol))
+            // Priority 5 (lowest): Using directives - only flag if nothing else was found
+            var usingLocation = CheckUsingDirectives(classDeclarationSyntax);
+            if (usingLocation != null)
             {
-                Flag(context, classDeclarationSyntax.GetLocation());
+                Flag(context, usingLocation);
                 return;
             }
         }
@@ -110,10 +146,11 @@ protected virtual bool HasFrameworkInterfaces(INamedTypeSymbol symbol)
         return null;
     }
 
-    protected virtual bool HasFrameworkTypes(INamedTypeSymbol namedTypeSymbol)
+    protected virtual bool HasFrameworkTypes(SyntaxNodeAnalysisContext context, INamedTypeSymbol namedTypeSymbol, ClassDeclarationSyntax classDeclarationSyntax)
     {
         var members = namedTypeSymbol.GetMembers();
 
+        // Check properties, return types, and fields
         var types = members.OfType<IPropertySymbol>()
                 .Where(x => IsFrameworkType(x.Type))
                 .Select(x => x.Type)
@@ -125,7 +162,49 @@ protected virtual bool HasFrameworkTypes(INamedTypeSymbol namedTypeSymbol)
                 .Select(x => x.Type))
             .ToArray();
 
-        return types.Any();
+        if (types.Any())
+        {
+            return true;
+        }
+
+        // Check for framework type usage in method bodies (e.g., Assert.AreEqual(), CollectionAssert.Contains())
+        var invocationExpressions = classDeclarationSyntax
+            .DescendantNodes()
+            .OfType<InvocationExpressionSyntax>();
+
+        foreach (var invocation in invocationExpressions)
+        {
+            var symbolInfo = context.SemanticModel.GetSymbolInfo(invocation);
+            if (symbolInfo.Symbol is IMethodSymbol methodSymbol)
+            {
+                // Check if the method belongs to a framework type
+                if (IsFrameworkType(methodSymbol.ContainingType))
+                {
+                    return true;
+                }
+            }
+            else if (symbolInfo.Symbol == null)
+            {
+                // Fallback: if symbol resolution fails completely, check the syntax directly
+                // This handles cases where the semantic model hasn't fully resolved types
+                if (invocation.Expression is MemberAccessExpressionSyntax memberAccess)
+                {
+                    var typeExpression = memberAccess.Expression.ToString();
+                    if (IsFrameworkTypeName(typeExpression))
+                    {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
+    protected virtual bool IsFrameworkTypeName(string typeName)
+    {
+        // Override in derived classes to provide framework-specific type names
+        return false;
     }
 
     protected virtual bool IsFrameworkType(ITypeSymbol type)
@@ -151,10 +230,12 @@ protected virtual bool IsFrameworkType(ITypeSymbol type)
                 if (attributeSyntax != null)
                 {
                     // Get the parent AttributeListSyntax to include the brackets [...]
-                    var attributeListSyntax = attributeSyntax.Parent;
-                    if (attributeListSyntax != null)
+                    if (attributeSyntax.Parent is AttributeListSyntax attributeListSyntax)
                     {
-                        return attributeListSyntax.GetLocation();
+                        // Return the location including brackets but excluding leading trivia
+                        return Location.Create(
+                            attributeListSyntax.SyntaxTree,
+                            attributeListSyntax.Span);
                     }
                     return attributeSyntax.GetLocation();
                 }

TUnit.Analyzers/Migrators/Base/MigrationHelpers.cs

@@ -159,7 +159,7 @@ public static CompilationUnitSyntax RemoveFrameworkUsings(CompilationUnitSyntax
         var namespacesToRemove = framework switch
         {
             "XUnit" => new[] { "Xunit", "Xunit.Abstractions" },
-            "NUnit" => new[] { "NUnit.Framework" },
+            "NUnit" => new[] { "NUnit.Framework", "NUnit.Framework.Legacy" },
             "MSTest" => new[] { "Microsoft.VisualStudio.TestTools.UnitTesting" },
             _ => Array.Empty<string>()
         };
@@ -168,7 +168,7 @@ public static CompilationUnitSyntax RemoveFrameworkUsings(CompilationUnitSyntax
             .Where(u =>
             {
                 var nameString = u.Name?.ToString() ?? "";
-                return !namespacesToRemove.Any(ns => 
+                return !namespacesToRemove.Any(ns =>
                     nameString == ns || nameString.StartsWith(ns + "."));
             })
             .ToArray();
@@ -179,22 +179,22 @@ public static CompilationUnitSyntax RemoveFrameworkUsings(CompilationUnitSyntax
     public static CompilationUnitSyntax AddTUnitUsings(CompilationUnitSyntax compilationUnit)
     {
         var tunitUsing = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("TUnit.Core"));
-        var assertionsUsing = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("TUnit.Assertions"))
+        var assertionsUsing = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("TUnit.Assertions.Assert"))
             .WithStaticKeyword(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
         var extensionsUsing = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("TUnit.Assertions.Extensions"));
-        
+
         var existingUsings = compilationUnit.Usings.ToList();
-        
+
         if (!existingUsings.Any(u => u.Name?.ToString() == "TUnit.Core"))
         {
             existingUsings.Add(tunitUsing);
         }
-        
-        if (!existingUsings.Any(u => u.Name?.ToString() == "TUnit.Assertions" && u.StaticKeyword.IsKind(SyntaxKind.StaticKeyword)))
+
+        if (!existingUsings.Any(u => u.Name?.ToString() == "TUnit.Assertions.Assert" && u.StaticKeyword.IsKind(SyntaxKind.StaticKeyword)))
         {
             existingUsings.Add(assertionsUsing);
         }
-        
+
         if (!existingUsings.Any(u => u.Name?.ToString() == "TUnit.Assertions.Extensions"))
         {
             existingUsings.Add(extensionsUsing);

TUnit.Analyzers/Migrators/MSTestMigrationAnalyzer.cs

@@ -23,8 +23,16 @@ protected override bool IsFrameworkNamespace(string? namespaceName)
         {
             return false;
         }
-        
-        return namespaceName == "Microsoft.VisualStudio.TestTools.UnitTesting" || 
+
+        return namespaceName == "Microsoft.VisualStudio.TestTools.UnitTesting" ||
                namespaceName.StartsWith("Microsoft.VisualStudio.TestTools.UnitTesting.");
     }
+
+    protected override bool IsFrameworkTypeName(string typeName)
+    {
+        // Check for MSTest assertion types by name (fallback when semantic model doesn't resolve)
+        return typeName == "Assert" ||
+               typeName == "CollectionAssert" ||
+               typeName == "StringAssert";
+    }
 }

TUnit.Analyzers/Migrators/NUnitMigrationAnalyzer.cs

@@ -24,8 +24,19 @@ protected override bool IsFrameworkNamespace(string? namespaceName)
         {
             return false;
         }
-        
-        return namespaceName == "NUnit.Framework" || 
+
+        return namespaceName == "NUnit.Framework" ||
                namespaceName.StartsWith("NUnit.Framework.");
     }
+
+    protected override bool IsFrameworkTypeName(string typeName)
+    {
+        // Check for NUnit assertion types by name (fallback when semantic model doesn't resolve)
+        return typeName == "Assert" ||
+               typeName == "ClassicAssert" ||
+               typeName == "CollectionAssert" ||
+               typeName == "StringAssert" ||
+               typeName == "FileAssert" ||
+               typeName == "DirectoryAssert";
+    }
 }