test fields should be readonly

NUnit.Analyzers/Constants/AnalyzerIdentifiers.cs

@@ -0,0 +1,7 @@
+namespace NUnit.Analyzers.Constants
+{
+    internal static class AnalyzerIdentifiers
+    {
+        internal const string TestFieldIsNotReadonly = "NU0001";
+    }
+}

NUnit.Analyzers/Constants/Categories.cs

@@ -0,0 +1,7 @@
+namespace NUnit.Analyzers.Constants
+{
+    internal static class Categories
+    {
+        internal const string ParallelExecution = nameof(ParallelExecution);
+    }
+}

NUnit.Analyzers/Constants/NUnitFrameworkConstants.cs

@@ -0,0 +1,13 @@
+namespace NUnit.Analyzers.Constants
+{
+    public static class NUnitFrameworkConstants
+    {
+        public const string FullNameOfTypeITestBuilder = "NUnit.Framework.Interfaces.ITestBuilder";
+        public const string FullNameOfTypeISimpleTestBuilder = "NUnit.Framework.Interfaces.ISimpleTestBuilder";
+
+        public const string FullNameOfTypeOneTimeSetUpAttribute = "NUnit.Framework.OneTimeSetUpAttribute";
+        public const string FullNameOfTypeOneTimeTearDownAttribute = "NUnit.Framework.OneTimeTearDownAttribute";
+        public const string FullNameOfTypeSetUpAttribute = "NUnit.Framework.SetUpAttribute";
+        public const string FullNameOfTypeTearDownAttribute = "NUnit.Framework.TearDownAttribute";
+    }
+}

NUnit.Analyzers/Extensions/AttributeDataExtensions.cs

@@ -0,0 +1,51 @@
+using Microsoft.CodeAnalysis;
+
+using NUnit.Analyzers.Constants;
+
+namespace NUnit.Analyzers.Extensions
+{
+    public static class AttributeDataExtensions
+    {
+        public static bool DerivesFromISimpleTestBuilder(this AttributeData @this, Compilation compilation)
+        {
+            return DerivesFromInterface(compilation, @this, NUnitFrameworkConstants.FullNameOfTypeISimpleTestBuilder);
+        }
+
+        public static bool DerivesFromITestBuilder(this AttributeData @this, Compilation compilation)
+        {
+            return DerivesFromInterface(compilation, @this, NUnitFrameworkConstants.FullNameOfTypeITestBuilder);
+        }
+
+        public static bool IsTestMethodAttribute(this AttributeData @this, Compilation compilation)
+        {
+            return @this.DerivesFromITestBuilder(compilation) ||
+                   @this.DerivesFromISimpleTestBuilder(compilation);
+        }
+
+        public static bool IsSetUpOrTearDownMethodAttribute(this AttributeData @this, Compilation compilation)
+        {
+            var attributeType = @this.AttributeClass;
+
+            if (attributeType is null)
+                return false;
+
+            return attributeType.IsType(NUnitFrameworkConstants.FullNameOfTypeOneTimeSetUpAttribute, compilation)
+                   || attributeType.IsType(NUnitFrameworkConstants.FullNameOfTypeOneTimeTearDownAttribute, compilation)
+                   || attributeType.IsType(NUnitFrameworkConstants.FullNameOfTypeSetUpAttribute, compilation)
+                   || attributeType.IsType(NUnitFrameworkConstants.FullNameOfTypeTearDownAttribute, compilation);
+        }
+
+        private static bool DerivesFromInterface(Compilation compilation, AttributeData attributeData, string interfaceTypeFullName)
+        {
+            if (attributeData.AttributeClass is null)
+                return false;
+
+            var interfaceType = compilation.GetTypeByMetadataName(interfaceTypeFullName);
+
+            if (interfaceType is null)
+                return false;
+
+            return attributeData.AttributeClass.AllInterfaces.Any(i => SymbolEqualityComparer.Default.Equals(i, interfaceType));
+        }
+    }
+}

NUnit.Analyzers/Extensions/MethodSymbolExtensions.cs

@@ -0,0 +1,19 @@
+using Microsoft.CodeAnalysis;
+
+namespace NUnit.Analyzers.Extensions
+{
+    internal static class MethodSymbolExtensions
+    {
+        internal static bool IsTestRelatedMethod(this IMethodSymbol methodSymbol, Compilation compilation)
+        {
+            return methodSymbol.HasTestRelatedAttributes(compilation) ||
+                   (methodSymbol.OverriddenMethod is not null && methodSymbol.OverriddenMethod.IsTestRelatedMethod(compilation));
+        }
+
+        internal static bool HasTestRelatedAttributes(this IMethodSymbol methodSymbol, Compilation compilation)
+        {
+            return methodSymbol.GetAttributes().Any(
+                a => a.IsTestMethodAttribute(compilation) || a.IsSetUpOrTearDownMethodAttribute(compilation));
+        }
+    }
+}

NUnit.Analyzers/Extensions/TypeSymbolExtensions.cs

@@ -0,0 +1,16 @@
+using System.Diagnostics.CodeAnalysis;
+
+using Microsoft.CodeAnalysis;
+
+namespace NUnit.Analyzers.Extensions
+{
+    public static class TypeSymbolExtensions
+    {
+        internal static bool IsType([NotNullWhen(true)] this ITypeSymbol? @this, string fullMetadataName, Compilation compilation)
+        {
+            var typeSymbol = compilation.GetTypeByMetadataName(fullMetadataName);
+
+            return SymbolEqualityComparer.Default.Equals(typeSymbol, @this);
+        }
+    }
+}

NUnit.Analyzers/NUnit.Analyzers.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.10.0" />
+    </ItemGroup>
+
+</Project>

NUnit.Analyzers/TestFieldIsNotReadonly/TestFieldIsNotReadonlyAnalyzer.cs

@@ -0,0 +1,55 @@
+using System.Collections.Immutable;
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+using NUnit.Analyzers.Constants;
+using NUnit.Analyzers.Extensions;
+
+namespace NUnit.Analyzers.TestFieldIsNotReadonly
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class TestFieldIsNotReadonlyAnalyzer : DiagnosticAnalyzer
+    {
+        private static readonly DiagnosticDescriptor testFieldIsNotReadonly = new DiagnosticDescriptor(
+            AnalyzerIdentifiers.TestFieldIsNotReadonly,
+            TestFieldIsNotReadonlyConstants.TestFieldIsNotReadonlyTitle,
+            TestFieldIsNotReadonlyConstants.TestFieldIsNotReadonlyMessage,
+            Categories.ParallelExecution,
+            DiagnosticSeverity.Warning,
+            true,
+            TestFieldIsNotReadonlyConstants.TestFieldIsNotReadonlyDescription
+        );
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+            context.EnableConcurrentExecution();
+            context.RegisterSymbolAction(AnalyzeType, SymbolKind.NamedType);
+        }
+
+        private static void AnalyzeType(SymbolAnalysisContext context)
+        {
+            var typeSymbol = (INamedTypeSymbol)context.Symbol;
+
+            var hasTests = typeSymbol
+                           .GetMembers()
+                           .OfType<IMethodSymbol>()
+                           .Any(x => x.MethodKind == MethodKind.Ordinary && x.IsTestRelatedMethod(context.Compilation));
+
+            if (!hasTests)
+                return;
+
+            var fields = typeSymbol
+                         .GetMembers()
+                         .OfType<IFieldSymbol>()
+                         .Where(x => !x.IsRequired && !x.IsConst);
+
+            foreach (var field in fields)
+                context.ReportDiagnostic(Diagnostic.Create(testFieldIsNotReadonly, field.Locations[0]));
+        }
+
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics =>
+            ImmutableArray.Create(testFieldIsNotReadonly);
+    }
+}

NUnit.Analyzers/TestFieldIsNotReadonly/TestFieldIsNotReadonlyCodeFix.cs

@@ -0,0 +1,48 @@
+using System.Collections.Immutable;
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+using NUnit.Analyzers.Constants;
+
+namespace NUnit.Analyzers.TestFieldIsNotReadonly
+{
+    [ExportCodeFixProvider(LanguageNames.CSharp)]
+    public class TestFieldIsNotReadonlyCodeFix : CodeFixProvider
+    {
+        public override sealed FixAllProvider GetFixAllProvider()
+        {
+            return WellKnownFixAllProviders.BatchFixer;
+        }
+
+        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+
+            if (root is null)
+            {
+                return;
+            }
+
+            context.CancellationToken.ThrowIfCancellationRequested();
+
+            var node = root.FindNode(context.Span);
+            if (node is not FieldDeclarationSyntax originalExpression)
+                return;
+
+            if (originalExpression.Modifiers.Any(IsReadonlyModifier))
+                return;
+
+            // var newExpression = originalExpression.WithModifiers(originalExpression.Modifiers.Add(Synra))
+        }
+
+        private static bool IsReadonlyModifier(SyntaxToken syntaxToken) =>
+            syntaxToken.IsKind(SyntaxKind.ConstKeyword) ||
+            syntaxToken.IsKind(SyntaxKind.ReadOnlyKeyword);
+
+        public override ImmutableArray<string> FixableDiagnosticIds
+            => ImmutableArray.Create(AnalyzerIdentifiers.TestFieldIsNotReadonly);
+    }
+}

NUnit.Analyzers/TestFieldIsNotReadonly/TestFieldIsNotReadonlyConstants.cs

@@ -0,0 +1,9 @@
+namespace NUnit.Analyzers.TestFieldIsNotReadonly
+{
+    internal class TestFieldIsNotReadonlyConstants
+    {
+        internal const string TestFieldIsNotReadonlyTitle = "The field in test class is not readonly";
+        internal const string TestFieldIsNotReadonlyMessage = "Fields in test classes should be readonly";
+        internal const string TestFieldIsNotReadonlyDescription = "A test fixture should not contain any modifiable shared state to simplify tests parallel execution.";
+    }
+}

nunit-extensions.sln

@@ -6,6 +6,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NUnit.Extensions.Tests", "N
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NUnit.Retries", "NUnit.Retries\NUnit.Retries.csproj", "{7EEE6F2E-F282-410D-A82A-6A5C4B9A9ECF}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NUnit.Analyzers", "NUnit.Analyzers\NUnit.Analyzers.csproj", "{5BEC009E-0FB1-4747-A011-A8B20CBE1EFC}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -24,5 +26,9 @@ Global
 		{7EEE6F2E-F282-410D-A82A-6A5C4B9A9ECF}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{7EEE6F2E-F282-410D-A82A-6A5C4B9A9ECF}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{7EEE6F2E-F282-410D-A82A-6A5C4B9A9ECF}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5BEC009E-0FB1-4747-A011-A8B20CBE1EFC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5BEC009E-0FB1-4747-A011-A8B20CBE1EFC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5BEC009E-0FB1-4747-A011-A8B20CBE1EFC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5BEC009E-0FB1-4747-A011-A8B20CBE1EFC}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 EndGlobal