Detect when CollectionDefinition class is not in same assembly as tes…

…t class (xunit/xunit#2311) (#169)

src/xunit.analyzers.tests/Analyzers/X1000/CollectionDefinitionMustBeInTheSameAssemblyTests.cs

@@ -0,0 +1,57 @@
+using Microsoft.CodeAnalysis;
+using Xunit;
+using Verify = CSharpVerifier<Xunit.Analyzers.CollectionDefinitionMustBeInTheSameAssembly>;
+
+public class CollectionDefinitionMustBeInTheSameAssemblyTests
+{
+ public static TheoryData<string, string> NoDiagnosticsCases = new()
+ {
+ {
+ "[Collection(\"Test collection definition\")]",
+ "[CollectionDefinition(\"Test collection definition\")]"
+ },
+ {
+ string.Empty,
+ "[CollectionDefinition(\"Test collection definition\")]"
+ },
+ {
+ string.Empty,
+ string.Empty
+ }
+ };
+
+ static readonly string Template = @"
+using Xunit;
+
+{0}
+public class TestClass {{ }}
+
+namespace TestNamespace {{
+ {1}
+ public class TestDefinition {{ }}
+}}";
+
+ [Theory]
+ [MemberData(nameof(NoDiagnosticsCases))]
+ public async void CollectionDefinitionIsPresentInTheAssembly_NoDiagnostics(string classAttribute, string definitionAttribute)
+ {
+ var source = string.Format(Template, classAttribute, definitionAttribute);
+
+ await Verify.VerifyAnalyzer(source);
+ }
+
+ [Fact]
+ public async void CollectionDefinitionIsMissingInTheAssembly_ReturnsError()
+ {
+ var source = string.Format(Template, "[Collection(\"Test collection definition\")]", string.Empty);
+
+ var expected =
+ Verify
+ .Diagnostic()
+ .WithSpan(5, 14, 5, 23)
+ .WithSeverity(DiagnosticSeverity.Error)
+ .WithArguments("Test collection definition", "TestProject");
+
+ await Verify.VerifyAnalyzer(source, expected);
+ }
+}

src/xunit.analyzers/Utility/Descriptors.cs

@@ -404,7 +404,14 @@ static DiagnosticDescriptor Rule(
  "The type argument {0} from {1}.{2} is nullable, while the type of the corresponding test method parameter {3} is not. Make the TheoryData type non-nullable, or make the test method parameter nullable."
  );
 
- // Placeholder for rule X1041
+ public static DiagnosticDescriptor X1041_CollectionDefinitionMustBeInTheSameAssembly { get; } =
+ Rule(
+ "xUnit1041",
+ "Collection definitions must be in the same assembly as the test that uses them",
+ Extensibility,
+ Error,
+ "A class for '{0}' collection definition must be declared in the '{1}' assembly"
+ );
 
  // Placeholder for rule X1042
 

src/xunit.analyzers/Utility/EmptyCoreContext.cs

@@ -9,6 +9,8 @@ public class EmptyCoreContext : ICoreContext
 
  public INamedTypeSymbol? ClassDataAttributeType => null;
 
+ public INamedTypeSymbol? CollectionAttributeType => null;
+
  public INamedTypeSymbol? CollectionDefinitionAttributeType => null;
 
  public INamedTypeSymbol? DataAttributeType => null;

src/xunit.analyzers/Utility/ICoreContext.cs

@@ -6,6 +6,8 @@ public interface ICoreContext
 {
  INamedTypeSymbol? ClassDataAttributeType { get; }
 
+ INamedTypeSymbol? CollectionAttributeType { get; }
+
  INamedTypeSymbol? CollectionDefinitionAttributeType { get; }
 
  INamedTypeSymbol? DataAttributeType { get; }

src/xunit.analyzers/Utility/SymbolAssemblyVisitor.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+
+namespace Xunit.Analyzers;
+
+/// <summary>
+/// Visits every type in every namespace within an assembly. Expressions are provided which indicate
+/// whether the item being searched for has been found. Searches stop once at least one of the
+/// short circuit expressions returned true.
+/// </summary>
+public class SymbolAssemblyVisitor : SymbolVisitor
+{
+ readonly Func<INamedTypeSymbol, bool>[] shortCircuitExpressions;
+
+ public SymbolAssemblyVisitor(params Func<INamedTypeSymbol, bool>[] shortCircuitExpressions)
+ {
+ this.shortCircuitExpressions = shortCircuitExpressions;
+ }
+
+ public bool ShortCircuitTriggered { get; private set; }
+
+ public override void VisitAssembly(IAssemblySymbol symbol)
+ {
+ symbol.GlobalNamespace.Accept(this);
+ }
+
+ public override void VisitNamespace(INamespaceSymbol symbol)
+ {
+ var namespaceOrTypes = symbol.GetMembers();
+ foreach (var member in namespaceOrTypes)
+ {
+ if (ShortCircuitTriggered)
+ return;
+
+ member.Accept(this);
+ }
+ }
+
+ public override void VisitNamedType(INamedTypeSymbol symbol)
+ {
+ if (shortCircuitExpressions.Any(e => e(symbol)))
+ {
+ ShortCircuitTriggered = true;
+ return;
+ }
+
+ var nestedTypes = symbol.GetTypeMembers();
+ if (nestedTypes.IsDefaultOrEmpty)
+ return;
+
+ foreach (var nestedType in nestedTypes)
+ {
+ if (ShortCircuitTriggered)
+ return;
+
+ nestedType.Accept(this);
+ }
+ }
+}

src/xunit.analyzers/Utility/TypeSymbolFactory.cs

@@ -11,6 +11,9 @@ public class TypeSymbolFactory
  public static INamedTypeSymbol? ClassDataAttribute(Compilation compilation) =>
  compilation.GetTypeByMetadataName("Xunit.ClassDataAttribute");
 
+ public static INamedTypeSymbol? CollectionAttribute(Compilation compilation) =>
+ compilation.GetTypeByMetadataName("Xunit.CollectionAttribute");
+
  public static INamedTypeSymbol? CollectionDefinitionAttribute(Compilation compilation) =>
  compilation.GetTypeByMetadataName("Xunit.CollectionDefinitionAttribute");
 

src/xunit.analyzers/Utility/V2CoreContext.cs

@@ -10,6 +10,7 @@ public class V2CoreContext : ICoreContext
  internal static readonly Version Version_2_4_0 = new("2.4.0");
 
  readonly Lazy<INamedTypeSymbol?> lazyClassDataAttributeType;
+ readonly Lazy<INamedTypeSymbol?> lazyCollectionAttributeType;
  readonly Lazy<INamedTypeSymbol?> lazyCollectionDefinitionAttributeType;
  readonly Lazy<INamedTypeSymbol?> lazyDataAttributeType;
  readonly Lazy<INamedTypeSymbol?> lazyFactAttributeType;
@@ -26,6 +27,7 @@ public class V2CoreContext : ICoreContext
  Version = version;
 
  lazyClassDataAttributeType = new(() => TypeSymbolFactory.ClassDataAttribute(compilation));
+ lazyCollectionAttributeType = new(() => TypeSymbolFactory.CollectionAttribute(compilation));
  lazyCollectionDefinitionAttributeType = new(() => TypeSymbolFactory.CollectionDefinitionAttribute(compilation));
  lazyDataAttributeType = new(() => TypeSymbolFactory.DataAttribute(compilation));
  lazyFactAttributeType = new(() => TypeSymbolFactory.FactAttribute(compilation));
@@ -39,6 +41,9 @@ public class V2CoreContext : ICoreContext
  public INamedTypeSymbol? ClassDataAttributeType =>
  lazyClassDataAttributeType.Value;
 
+ public INamedTypeSymbol? CollectionAttributeType =>
+ lazyCollectionAttributeType.Value;
+
  public INamedTypeSymbol? CollectionDefinitionAttributeType =>
  lazyCollectionDefinitionAttributeType.Value;
 

src/xunit.analyzers/Utility/V3CoreContext.cs

@@ -7,6 +7,7 @@ namespace Xunit.Analyzers;
 public class V3CoreContext : ICoreContext
 {
  readonly Lazy<INamedTypeSymbol?> lazyClassDataAttributeType;
+ readonly Lazy<INamedTypeSymbol?> lazyCollectionAttributeType;
  readonly Lazy<INamedTypeSymbol?> lazyCollectionDefinitionAttributeType;
  readonly Lazy<INamedTypeSymbol?> lazyDataAttributeType;
  readonly Lazy<INamedTypeSymbol?> lazyFactAttributeType;
@@ -23,6 +24,7 @@ public class V3CoreContext : ICoreContext
  Version = version;
 
  lazyClassDataAttributeType = new(() => TypeSymbolFactory.ClassDataAttribute(compilation));
+ lazyCollectionAttributeType = new(() => TypeSymbolFactory.CollectionAttribute(compilation));
  lazyCollectionDefinitionAttributeType = new(() => TypeSymbolFactory.CollectionDefinitionAttribute(compilation));
  lazyDataAttributeType = new(() => TypeSymbolFactory.DataAttribute(compilation));
  lazyFactAttributeType = new(() => TypeSymbolFactory.FactAttribute(compilation));
@@ -36,6 +38,9 @@ public class V3CoreContext : ICoreContext
  public INamedTypeSymbol? ClassDataAttributeType =>
  lazyClassDataAttributeType.Value;
 
+ public INamedTypeSymbol? CollectionAttributeType =>
+ lazyCollectionAttributeType.Value;
+
  public INamedTypeSymbol? CollectionDefinitionAttributeType =>
  lazyCollectionDefinitionAttributeType.Value;
 

src/xunit.analyzers/X1000/CollectionDefinitionMustBeInTheSameAssembly.cs

@@ -0,0 +1,58 @@
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Xunit.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class CollectionDefinitionMustBeInTheSameAssembly : XunitDiagnosticAnalyzer
+{
+ public CollectionDefinitionMustBeInTheSameAssembly() :
+ base(Descriptors.X1041_CollectionDefinitionMustBeInTheSameAssembly)
+ { }
+
+ public override void AnalyzeCompilation(
+ CompilationStartAnalysisContext context,
+ XunitContext xunitContext)
+ {
+ context.RegisterSymbolAction(context =>
+ {
+ if (context.Symbol is not INamedTypeSymbol namedType)
+ return;
+
+ var collectionAttributeType = xunitContext.Core.CollectionAttributeType;
+ var collectionAttribute = namedType
+ .GetAttributes()
+ .FirstOrDefault(a => a.AttributeClass.IsAssignableFrom(collectionAttributeType));
+
+ var collectionDefinitionName = collectionAttribute?.ConstructorArguments[0].Value?.ToString();
+ if (collectionDefinitionName == null)
+ return;
+
+ var collectionDefinitionAttributeType = xunitContext.Core.CollectionDefinitionAttributeType;
+ var visitor = new SymbolAssemblyVisitor(symbol =>
+ symbol
+ .GetAttributes()
+ .Any(a =>
+ a.AttributeClass.IsAssignableFrom(collectionDefinitionAttributeType) &&
+ !a.ConstructorArguments.IsDefaultOrEmpty &&
+ a.ConstructorArguments[0].Value?.ToString() == collectionDefinitionName
+ )
+ );
+
+ var currentAssembly = context.Compilation.Assembly;
+ visitor.Visit(currentAssembly);
+ if (visitor.ShortCircuitTriggered)
+ return;
+
+ context.ReportDiagnostic(
+ Diagnostic.Create(
+ Descriptors.X1041_CollectionDefinitionMustBeInTheSameAssembly,
+ namedType.Locations.First(),
+ collectionDefinitionName,
+ currentAssembly.Name
+ )
+ );
+ }, SymbolKind.NamedType);
+ }
+}