Inheritance works except with interfaces

Author: Vannevelj

VSDiagnostics/VSDiagnostics/VSDiagnostics.Test/Tests/Async/AsyncMethodWithoutAsyncSuffixTests.cs

@@ -1062,5 +1062,114 @@ public Task MyMethodAsync()
             VerifyDiagnostic(original, diagnosticResultClass, diagnosticResultInterface);
             VerifyFix(original, result);
         }
+
+        [TestMethod]
+        public void AsyncMethodWithoutAsyncSuffix_WithVoidReturnType_InvokesWarning()
+        {
+            var original = @"
+    using System;
+    using System.Text;
+    using System.Threading.Tasks;
+
+    namespace ConsoleApplication1
+    {
+        class MyClass
+        {   
+            async void Method()
+            {
+
+            }
+        }
+    }";
+
+            var result = @"
+    using System;
+    using System.Text;
+    using System.Threading.Tasks;
+
+    namespace ConsoleApplication1
+    {
+        class MyClass
+        {   
+            async void MethodAsync()
+            {
+
+            }
+        }
+    }";
+
+            VerifyDiagnostic(original, string.Format(AsyncMethodWithoutAsyncSuffixAnalyzer.Rule.MessageFormat.ToString(), "Method"));
+            VerifyFix(original, result);
+        }
+
+        [TestMethod]
+        public void AsyncMethodWithoutAsyncSuffix_DefinedInBaseClass_WithOverriddenMember_WithLongerInheritanceStructure_WithMultipleAbstractClasses_InvokesWarning()
+        {
+            var original = @"
+    using System;
+    using System.Text;
+    using System.Threading.Tasks;
+
+    namespace ConsoleApplication1
+    {
+        abstract class OtherBaseClass
+        {
+	        public abstract Task MyMethod();
+        }
+
+        abstract class BaseClass : OtherBaseClass
+        {
+	        
+        }
+
+        class MyClass : BaseClass
+        {
+	        public override Task MyMethod()
+	        {
+		        return Task.CompletedTask;
+	        }
+        }
+    }";
+
+            var result = @"
+    using System;
+    using System.Text;
+    using System.Threading.Tasks;
+
+    namespace ConsoleApplication1
+    {
+        abstract class OtherBaseClass
+        {
+	        public abstract Task MyMethodAsync();
+        }
+
+        abstract class BaseClass : OtherBaseClass
+        {
+	        
+        }
+
+        class MyClass : BaseClass
+        {
+	        public override Task MyMethodAsync()
+	        {
+		        return Task.CompletedTask;
+	        }
+        }
+    }";
+
+            var diagnosticResultClass = new DiagnosticResult
+            {
+                Id = AsyncMethodWithoutAsyncSuffixAnalyzer.Rule.Id,
+                Message = string.Format(AsyncMethodWithoutAsyncSuffixAnalyzer.Rule.MessageFormat.ToString(), "MyMethod"),
+                Severity = AsyncMethodWithoutAsyncSuffixAnalyzer.Rule.DefaultSeverity,
+                Locations = new[]
+                {
+                    new DiagnosticResultLocation("Test0.cs", 10, 31)
+                }
+            };
+
+            VerifyDiagnostic(original, diagnosticResultClass);
+            VerifyFix(original, result);
+        }
     }
 }

VSDiagnostics/VSDiagnostics/VSDiagnostics/Diagnostics/Async/AsyncMethodWithoutAsyncSuffix/AsyncMethodWithoutAsyncSuffixAnalyzer.cs

@@ -1,4 +1,5 @@
 using System.Collections.Immutable;
+using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
@@ -45,13 +46,66 @@ private static void AnalyzeSyntaxNode(SyntaxNodeAnalysisContext context)
                 return;
             }
 
-            if (method.Modifiers.Any(SyntaxKind.AsyncKeyword) || returnType.Type.MetadataName == typeof(Task).Name || returnType.Type.MetadataName == typeof(Task<>).Name)
+            var declaredSymbol = context.SemanticModel.GetDeclaredSymbol(method);
+            if (declaredSymbol == null)
+            {
+                return;
+            }
+
+            if (IsDefinedInAncestor(declaredSymbol, context))
+            {
+                return;
+            }
+
+            if (method.Modifiers.Any(SyntaxKind.AsyncKeyword) ||
+                returnType.Type.MetadataName == typeof(Task).Name ||
+                returnType.Type.MetadataName == typeof(Task<>).Name)
             {
                 if (!method.Identifier.Text.EndsWith("Async"))
                 {
                     context.ReportDiagnostic(Diagnostic.Create(Rule, method.Identifier.GetLocation(), method.Identifier.Text));
                 }
             }
         }
+
+        private static bool IsDefinedInAncestor(IMethodSymbol methodSymbol, SyntaxNodeAnalysisContext context)
+        {
+            var type = methodSymbol?.ContainingType;
+            if (type == null)
+            {
+                return false;
+            }
+
+            var interfaces = type.AllInterfaces;
+            foreach (var @interface in interfaces)
+            {
+                var interfaceMethods = @interface.GetMembers().OfType<IMethodSymbol>().ToArray();
+                foreach (var method in interfaceMethods)
+                {
+                    if (method.Equals(methodSymbol))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            // Start with the first ancestor
+            type = type.BaseType;
+            while (type != null)
+            {
+                var methods = type.GetMembers().OfType<IMethodSymbol>().ToArray();
+                foreach (var method in methods)
+                {
+                    if (method.Equals(methodSymbol))
+                    {
+                        return true;
+                    }
+                }
+
+                type = type.BaseType;
+            }
+
+            return false;
+        }
     }
 }