feat: enhance AbstractTestClassWithDataSourcesAnalyzer to conditionally report diagnostics based on inheriting classes with [InheritsTests] (#3519)

Author: thomhurst

TUnit.Analyzers.Tests/AbstractTestClassWithDataSourcesAnalyzerTests.cs

@@ -170,4 +170,83 @@ public void DataDrivenTest(TestData data)
                     .WithArguments("AbstractTestBase")
             );
     }
+
+    [Test]
+    public async Task No_Warning_When_Concrete_Class_With_InheritsTests_Exists()
+    {
+        await Verifier
+            .VerifyAnalyzerAsync(
+                """
+                using TUnit.Core;
+
+                [InheritsTests]
+                public class Tests1 : Tests { }
+
+                [InheritsTests]
+                public class Tests2 : Tests { }
+
+                public abstract class Tests
+                {
+                    [Test]
+                    [Arguments(true)]
+                    [Arguments(false)]
+                    public void TestName(bool flag) { }
+
+                    [Test]
+                    public void TestName2() { }
+                }
+                """
+            );
+    }
+
+    [Test]
+    public async Task No_Warning_When_Single_Concrete_Class_With_InheritsTests_Exists()
+    {
+        await Verifier
+            .VerifyAnalyzerAsync(
+                """
+                using TUnit.Core;
+                using System.Collections.Generic;
+
+                [InheritsTests]
+                public class ConcreteTest : AbstractTestBase { }
+
+                public abstract class AbstractTestBase
+                {
+                    public static IEnumerable<int> TestData() => new[] { 1, 2, 3 };
+
+                    [Test]
+                    [MethodDataSource(nameof(TestData))]
+                    public void DataDrivenTest(int value)
+                    {
+                    }
+                }
+                """
+            );
+    }
+
+    [Test]
+    public async Task Warning_When_Concrete_Class_Exists_But_No_InheritsTests()
+    {
+        await Verifier
+            .VerifyAnalyzerAsync(
+                """
+                using TUnit.Core;
+
+                public class Tests1 : Tests { }
+
+                public abstract class {|#0:Tests|}
+                {
+                    [Test]
+                    [Arguments(true)]
+                    [Arguments(false)]
+                    public void TestName(bool flag) { }
+                }
+                """,
+
+                Verifier.Diagnostic(Rules.AbstractTestClassWithDataSources)
+                    .WithLocation(0)
+                    .WithArguments("Tests")
+            );
+    }
 }

TUnit.Analyzers/AbstractTestClassWithDataSourcesAnalyzer.cs

@@ -82,11 +82,95 @@ private void AnalyzeSymbol(SymbolAnalysisContext context)
 
         if (hasDataSourceAttributes)
         {
-            context.ReportDiagnostic(Diagnostic.Create(
-                Rules.AbstractTestClassWithDataSources,
-                namedTypeSymbol.Locations.FirstOrDefault(),
-                namedTypeSymbol.Name)
-            );
+            // Check if there are any concrete classes that inherit from this abstract class with [InheritsTests]
+            var hasInheritingClasses = HasConcreteInheritingClassesWithInheritsTests(context, namedTypeSymbol);
+
+            // Only report the diagnostic if no inheriting classes are found
+            if (!hasInheritingClasses)
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                    Rules.AbstractTestClassWithDataSources,
+                    namedTypeSymbol.Locations.FirstOrDefault(),
+                    namedTypeSymbol.Name)
+                );
+            }
+        }
+    }
+
+    private static bool HasConcreteInheritingClassesWithInheritsTests(SymbolAnalysisContext context, INamedTypeSymbol abstractClass)
+    {
+        // Get all named types in the compilation
+        var allTypes = GetAllNamedTypes(context.Compilation.Assembly.GlobalNamespace);
+
+        // Check if any concrete class inherits from the abstract class and has [InheritsTests]
+        foreach (var type in allTypes)
+        {
+            // Skip abstract classes
+            if (type.IsAbstract)
+            {
+                continue;
+            }
+
+            // Check if this type inherits from our abstract class
+            var baseType = type.BaseType;
+            while (baseType != null)
+            {
+                if (SymbolEqualityComparer.Default.Equals(baseType, abstractClass))
+                {
+                    // Check if this type has [InheritsTests] attribute
+                    var hasInheritsTests = type.GetAttributes().Any(attr =>
+                        attr.AttributeClass?.GloballyQualified() ==
+                        WellKnown.AttributeFullyQualifiedClasses.InheritsTestsAttribute.WithGlobalPrefix);
+
+                    if (hasInheritsTests)
+                    {
+                        return true;
+                    }
+
+                    break;
+                }
+
+                baseType = baseType.BaseType;
+            }
+        }
+
+        return false;
+    }
+
+    private static IEnumerable<INamedTypeSymbol> GetAllNamedTypes(INamespaceSymbol namespaceSymbol)
+    {
+        foreach (var member in namespaceSymbol.GetMembers())
+        {
+            if (member is INamedTypeSymbol namedType)
+            {
+                yield return namedType;
+
+                // Recursively get nested types
+                foreach (var nestedType in GetNestedTypes(namedType))
+                {
+                    yield return nestedType;
+                }
+            }
+            else if (member is INamespaceSymbol childNamespace)
+            {
+                foreach (var type in GetAllNamedTypes(childNamespace))
+                {
+                    yield return type;
+                }
+            }
+        }
+    }
+
+    private static IEnumerable<INamedTypeSymbol> GetNestedTypes(INamedTypeSymbol typeSymbol)
+    {
+        foreach (var member in typeSymbol.GetTypeMembers())
+        {
+            yield return member;
+
+            foreach (var nestedType in GetNestedTypes(member))
+            {
+                yield return nestedType;
+            }
         }
     }
 }