Update SA1400 for default interface members

Fixes #3682

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/MaintainabilityRules/SA1400CSharp8UnitTests.cs

@@ -3,9 +3,101 @@
 
 namespace StyleCop.Analyzers.Test.CSharp8.MaintainabilityRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis.Testing;
     using StyleCop.Analyzers.Test.CSharp7.MaintainabilityRules;
+    using StyleCop.Analyzers.Test.Helpers;
+    using Xunit;
+    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
+        StyleCop.Analyzers.MaintainabilityRules.SA1400AccessModifierMustBeDeclared,
+        StyleCop.Analyzers.MaintainabilityRules.SA1400CodeFixProvider>;
 
     public partial class SA1400CSharp8UnitTests : SA1400CSharp7UnitTests
     {
+        [Fact]
+        [WorkItem(3002, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3002")]
+        public async Task TestDefaultInterfaceImplementationWithoutAccessModifierAsync()
+        {
+            var testCode = @"
+public interface ITest
+{
+    void M()
+    {
+    }
+
+    int P
+    {
+        get
+        {
+            return 0;
+        }
+    }
+}
+";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        [WorkItem(3002, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3002")]
+        public async Task TestStaticInterfaceMemberWithoutAccessModifierAsync()
+        {
+            var testCode = @"
+public interface ITest
+{
+    static void M()
+    {
+    }
+}
+";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        [WorkItem(3002, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3002")]
+        public async Task TestDelegateDeclarationInsideInterfaceAsync()
+        {
+            var testCode = @"
+public interface ITest
+{
+    delegate void Handler();
+}
+";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        [WorkItem(3002, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3002")]
+        public async Task TestStaticFieldInsideInterfaceAsync()
+        {
+            var testCode = @"
+public interface ITest
+{
+    static int Value = 0;
+}
+";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Theory]
+        [MemberData(nameof(CommonMemberData.BaseTypeDeclarationKeywords), MemberType = typeof(CommonMemberData))]
+        [WorkItem(3002, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3002")]
+        public async Task TestTypeDeclarationInsideInterfaceAsync(string typeKind)
+        {
+            var testCode = $@"
+public interface ITest
+{{
+    {typeKind} NestedType
+    {{
+    }}
+}}
+";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/MaintainabilityRules/SA1400AccessModifierMustBeDeclared.cs

@@ -72,12 +72,22 @@ public override void Initialize(AnalysisContext context)
         private static void HandleBaseTypeDeclaration(SyntaxNodeAnalysisContext context)
         {
             var syntax = (BaseTypeDeclarationSyntax)context.Node;
+            if (syntax.Parent.IsKind(SyntaxKind.InterfaceDeclaration))
+            {
+                return;
+            }
+
             CheckAccessModifiers(context, syntax.Identifier, syntax.Modifiers);
         }
 
         private static void HandleDelegateDeclaration(SyntaxNodeAnalysisContext context)
         {
             var syntax = (DelegateDeclarationSyntax)context.Node;
+            if (syntax.Parent.IsKind(SyntaxKind.InterfaceDeclaration))
+            {
+                return;
+            }
+
             CheckAccessModifiers(context, syntax.Identifier, syntax.Modifiers);
         }
 

documentation/SA1400.md

@@ -25,6 +25,8 @@ C# allows elements to be defined without an access modifier. Depending upon the
 
 This rule requires an access modifier to be explicitly defined for every element. This removes the need for the reader to make assumptions about the code, improving the readability of the code.
 
+Members declared in an `interface` are implicitly `public` and do not need an explicit access modifier. This includes default interface members introduced in C# 8 (instance members with default implementations, static interface members, and nested interface members such as delegates). SA1400 does not report diagnostics for these interface members.
+
 ## How to fix violations
 
 To fix a violation of this rule, add an access modifier to the declaration of the element.