SA1401 now ignores static readonly fields

Author: vweijsters

StyleCop.Analyzers/StyleCop.Analyzers.Test/MaintainabilityRules/SA1401UnitTests.cs

@@ -74,6 +74,21 @@ public async Task TestClassWithConstFieldAsync()
             await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
         }
 
+        [Theory]
+        [InlineData("public")]
+        [InlineData("protected")]
+        [InlineData("protected internal")]
+        public async Task TestClassWithStaticReadonlyFieldAsync(string accessModifier)
+        {
+            var testCode = $@"public class TestClass
+{{
+    {accessModifier} static readonly string TestField = ""qwe"";
+}}
+";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
         protected override IEnumerable<DiagnosticAnalyzer> GetCSharpDiagnosticAnalyzers()
         {
             yield return new SA1401FieldsMustBePrivate();

StyleCop.Analyzers/StyleCop.Analyzers/MaintainabilityRules/SA1401FieldsMustBePrivate.cs

@@ -3,6 +3,7 @@
 
 namespace StyleCop.Analyzers.MaintainabilityRules
 {
+    using System;
     using System.Collections.Immutable;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.Diagnostics;
@@ -49,14 +50,15 @@ public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
         /// <inheritdoc/>
         public override void Initialize(AnalysisContext context)
         {
-            context.RegisterSymbolAction(this.AnalyzeField, SymbolKind.Field);
+            context.RegisterSymbolAction(AnalyzeField, SymbolKind.Field);
         }
 
-        private void AnalyzeField(SymbolAnalysisContext symbolAnalysisContext)
+        private static void AnalyzeField(SymbolAnalysisContext symbolAnalysisContext)
         {
             var fieldDeclarationSyntax = (IFieldSymbol)symbolAnalysisContext.Symbol;
-            if (!this.IsFieldPrivate(fieldDeclarationSyntax) &&
-                this.IsParentAClass(fieldDeclarationSyntax) &&
+            if (!IsFieldPrivate(fieldDeclarationSyntax) &&
+                !IsStaticReadonly(fieldDeclarationSyntax) &&
+                IsParentAClass(fieldDeclarationSyntax) &&
                 !fieldDeclarationSyntax.IsConst)
             {
                 foreach (var location in symbolAnalysisContext.Symbol.Locations)
@@ -77,12 +79,17 @@ private void AnalyzeField(SymbolAnalysisContext symbolAnalysisContext)
             }
         }
 
-        private bool IsFieldPrivate(IFieldSymbol fieldDeclarationSyntax)
+        private static bool IsFieldPrivate(IFieldSymbol fieldDeclarationSyntax)
         {
             return fieldDeclarationSyntax.DeclaredAccessibility == Accessibility.Private;
         }
 
-        private bool IsParentAClass(IFieldSymbol fieldDeclarationSyntax)
+        private static bool IsStaticReadonly(IFieldSymbol fieldDeclarationSyntax)
+        {
+            return fieldDeclarationSyntax.IsStatic && fieldDeclarationSyntax.IsReadOnly;
+        }
+
+        private static bool IsParentAClass(IFieldSymbol fieldDeclarationSyntax)
         {
             if (fieldDeclarationSyntax.ContainingSymbol != null &&
                 fieldDeclarationSyntax.ContainingSymbol.Kind == SymbolKind.NamedType)

documentation/SA1401.md

@@ -25,6 +25,8 @@ A violation of this rule occurs whenever a field in a class is given non-private
 
 Fields located within C# structs are allowed to have any access level.
 
+Fields that are static and readonly will not raise a violation. These kinds of fields are commonly used to represent a constant value when the `const` keyword cannot be used, and therefore they are exempt from this rule.
+
 ## How to fix violations
 
 To fix a violation of this rule, make the field private and add a property to expose the field outside of the class.