Merge pull request #1547 from Noryoko/fix-1529

Add additional null checks to SA1313 analyzer

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test/NamingRules/SA1313UnitTests.cs

@@ -474,6 +474,37 @@ public void MethodName(int _)
             await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// This is a regression test for DotNetAnalyzers/StyleCopAnalyzers#1529:
+        /// https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/1529
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task TestInheritedInterfacesWithOverloadedMembersAsync()
+        {
+            var testCode = @"
+public interface ITest
+{
+    void Method(int Param1, int param2, int Param3);
+    void Method();
+}
+
+public interface IEmptyInterface { }
+
+public interface IDerivedTest : ITest, IEmptyInterface
+{
+    void Method(int Param1, int param2, int param3);
+}";
+            var expected = new[]
+            {
+                this.CSharpDiagnostic().WithLocation(4, 21).WithArguments("Param1"),
+                this.CSharpDiagnostic().WithLocation(4, 45).WithArguments("Param3"),
+                this.CSharpDiagnostic().WithLocation(12, 21).WithArguments("Param1"),
+            };
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+        }
+
         protected override IEnumerable<DiagnosticAnalyzer> GetCSharpDiagnosticAnalyzers()
         {
             yield return new SA1313ParameterNamesMustBeginWithLowerCaseLetter();

StyleCop.Analyzers/StyleCop.Analyzers/NamingRules/SA1313ParameterNamesMustBeginWithLowerCaseLetter.cs

@@ -142,17 +142,20 @@ private static bool NameMatchesAbstraction(ParameterSyntax syntax, SemanticModel
             }
             else
             {
-                var implementedInterfaces = methodSymbol.ContainingType.Interfaces;
-                if (implementedInterfaces.Length != 0)
+                var containingType = methodSymbol.ContainingType;
+                if (containingType == null)
                 {
-                    foreach (var @interface in implementedInterfaces)
+                    return false;
+                }
+
+                var implementedInterfaces = containingType.Interfaces;
+                foreach (var implementedInterface in implementedInterfaces)
+                {
+                    foreach (var member in implementedInterface.GetMembers(methodSymbol.Name).OfType<IMethodSymbol>())
                     {
-                        foreach (var member in @interface.GetMembers(methodSymbol.Name).OfType<IMethodSymbol>())
+                        if (containingType.FindImplementationForInterfaceMember(member) == methodSymbol)
                         {
-                            if (methodSymbol.ContainingType.FindImplementationForInterfaceMember(member).Equals(methodSymbol))
-                            {
-                                return member.Parameters[index].Name == syntax.Identifier.ValueText;
-                            }
+                            return member.Parameters[index].Name == syntax.Identifier.ValueText;
                         }
                     }
                 }