Merge pull request #5193 from BZngr/5143_FalseNegative

ImplementedInterfaceMemberInspection evals Annotated-only and implemented interfaces

Author: bclothier

Rubberduck.CodeAnalysis/Inspections/Concrete/ImplementedInterfaceMemberInspection.cs

@@ -7,11 +7,13 @@
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Inspections.Inspections.Extensions;
 using Rubberduck.Common;
+using System;
+using Rubberduck.Parsing.Annotations;
 
 namespace Rubberduck.Inspections.Concrete
 {
     /// <summary>
-    /// Identifies members of class modules that are used as interfaces, but that have a concrete implementation.
+    /// Identifies class modules that define an interface with one or more members containing a concrete implementation.
     /// </summary>
     /// <why>
     /// Interfaces provide an abstract, unified programmatic access to different objects; concrete implementations of their members should be in a separate module that 'Implements' the interface.
@@ -43,7 +45,13 @@ public ImplementedInterfaceMemberInspection(Parsing.VBA.RubberduckParserState st
 
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
-            return State.DeclarationFinder.FindAllUserInterfaces()
+            var annotatedAsInterface = State.DeclarationFinder.Classes
+                .Where(cls => cls.Annotations.Any(an => an.Annotation is InterfaceAnnotation)).Cast<ClassModuleDeclaration>();
+
+            var implementedAndOrAnnotatedInterfaceModules = State.DeclarationFinder.FindAllUserInterfaces()
+                .Union(annotatedAsInterface);
+
+            return implementedAndOrAnnotatedInterfaceModules
                 .SelectMany(interfaceModule => interfaceModule.Members
                     .Where(member => ((ModuleBodyElementDeclaration)member).Block.ContainsExecutableStatements(true)))
                 .Select(result => new DeclarationInspectionResult(this,

RubberduckTests/Inspections/ImplementedInterfaceMemberInspectionTests.cs

@@ -4,11 +4,13 @@
 using RubberduckTests.Mocks;
 using Rubberduck.Inspections.Concrete;
 using Rubberduck.VBEditor.SafeComWrappers;
+using Rubberduck.Parsing.Inspections.Abstract;
+using Rubberduck.Parsing.VBA;
 
 namespace RubberduckTests.Inspections
 {
     [TestFixture]
-    public class ImplementedInterfaceMemberInspectionTests
+    public class ImplementedInterfaceMemberInspectionTests : InspectionTestsBase
     {
         [Test]
         [Category("Inspections")]
@@ -38,7 +40,7 @@ End Sub
 Public Sub IClass1_DoSomethingElse(ByVal a As Integer)
     MsgBox ""?""
 End Sub";
-            CheckActualEmptyBlockCountEqualsExpected(interfaceCode, concreteCode, 0);
+            CheckActualEmptyBlockCountEqualsExpected(("IClass1", interfaceCode), ("Class1", concreteCode), 0);
         }
 
         [Test]
@@ -59,7 +61,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer)
 End Sub
 Public Sub IClass1_DoSomethingElse(ByVal a As Integer)
 End Sub";
-            CheckActualEmptyBlockCountEqualsExpected(interfaceCode, concreteCode, 1);
+            CheckActualEmptyBlockCountEqualsExpected(("IClass1", interfaceCode), ("Class1", concreteCode), 1);
         }
 
         [Test]
@@ -81,7 +83,7 @@ public void ImplementedInterfaceMember_VariousStatements_DontReturnResult(string
     MsgBox ""?""
 End Sub";
 
-            CheckActualEmptyBlockCountEqualsExpected(interfaceCode, concreteCode, 0);
+            CheckActualEmptyBlockCountEqualsExpected(("IClass1", interfaceCode), ("Class1", concreteCode), 0);
         }
 
         [Test]
@@ -117,28 +119,52 @@ public void ImplementedInterfaceMember_VariousStatements_ReturnResult(string sta
 Sub IClass1_Qux()
 End Sub";
 
-            CheckActualEmptyBlockCountEqualsExpected(interfaceCode, concreteCode, 1);
+            CheckActualEmptyBlockCountEqualsExpected(("IClass1", interfaceCode), ("Class1", concreteCode), 1);
         }
 
-        private void CheckActualEmptyBlockCountEqualsExpected(string interfaceCode, string concreteCode, int expectedCount)
+        //https://github.com/rubberduck-vba/Rubberduck/issues/5143
+        [TestCase(@"MsgBox ""?""","", 1)]   //No implementers, only the annotation marks interface class
+        [TestCase("", "", 0)]   //Annotated only, but no implementers - no result
+        [TestCase(@"MsgBox ""?""", "Implements IClass1", 1)] //Annotated and an Implementer yields a single inspection result
+        [Category("Inspections")]
+        public void ImplementedInterfaceMember_AnnotatedOnly_ReturnsResult(string interfaceBody, string implementsStatement, int expected)
         {
-            var builder = new MockVbeBuilder();
-            var project = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected)
-                .AddComponent("IClass1", ComponentType.ClassModule, interfaceCode)
-                .AddComponent("Class1", ComponentType.ClassModule, concreteCode)
-                .Build();
-            var vbe = builder.AddProject(project).Build();
-
-            using (var state = MockParser.CreateAndParse(vbe.Object))
-            {
+            var interfaceCode =
+$@"
+'@Interface
+
+Public Sub DoSomething(ByVal a As Integer)
+End Sub
+Public Sub DoSomethingElse(ByVal a As Integer)
+    {interfaceBody}
+End Sub";
+            var concreteCode =
+$@"
+
+{implementsStatement}
+
+Private Sub IClass1_DoSomething(ByVal a As Integer)
+    MsgBox ""?""
+End Sub
+Public Sub IClass1_DoSomethingElse(ByVal a As Integer)
+End Sub";
+            CheckActualEmptyBlockCountEqualsExpected(("IClass1", interfaceCode), ("Class1", concreteCode), expected);
+        }
 
-                var inspection = new ImplementedInterfaceMemberInspection(state);
-                var inspector = InspectionsHelper.GetInspector(inspection);
-                var actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
+        private void CheckActualEmptyBlockCountEqualsExpected((string identifier, string code) interfaceDef, (string identifier, string code) implementerDef, int expectedCount)
+        {
+            var modules = new(string, string, ComponentType)[]
+            {
+                (interfaceDef.identifier, interfaceDef.code, ComponentType.ClassModule),
+                (implementerDef.identifier, implementerDef.code, ComponentType.ClassModule)
+            };
 
-                Assert.AreEqual(expectedCount, actualResults.Count());
-            }
+            Assert.AreEqual(expectedCount, InspectionResultsForModules(modules).Count());
+        }
 
+        protected override IInspection InspectionUnderTest(RubberduckParserState state)
+        {
+            return new ImplementedInterfaceMemberInspection(state);
         }
     }
 }