Fix ImplementInterfaceMemberInspection

There was an invalid cast because the inspection assumed that everything returnes by ClassModuleDeclaration.Member was a module body element. However, there are module variables as well.

This commit rewrites the inspection completely and makes it use the base class.

Author: MDoerner

Rubberduck.CodeAnalysis/Inspections/Abstract/DeclarationInspectionBase.cs

@@ -4,6 +4,7 @@
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
+using Rubberduck.Parsing.VBA.DeclarationCaching;
 using Rubberduck.VBEditor;
 
 namespace Rubberduck.Inspections.Abstract
@@ -20,11 +21,13 @@ protected DeclarationInspectionBase(RubberduckParserState state, params Declarat
             RelevantDeclarationTypes = relevantDeclarationTypes;
         }
 
-        protected abstract bool IsResultDeclaration(Declaration declaration);
+        protected abstract bool IsResultDeclaration(Declaration declaration, DeclarationFinder finder);
         protected abstract string ResultDescription(Declaration declaration);
 
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
+            var finder = DeclarationFinderProvider.DeclarationFinder;
+
             var results = new List<IInspectionResult>();
             foreach (var moduleDeclaration in State.DeclarationFinder.UserDeclarations(DeclarationType.Module))
             {
@@ -34,23 +37,29 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
                 }
 
                 var module = moduleDeclaration.QualifiedModuleName;
-                results.AddRange(DoGetInspectionResults(module));
+                results.AddRange(DoGetInspectionResults(module, finder));
             }
 
             return results;
         }
 
         private IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module)
         {
-            var objectionableDeclarations = RelevantDeclarationsInModule(module)
-                .Where(IsResultDeclaration);
+            var finder = DeclarationFinderProvider.DeclarationFinder;
+            return DoGetInspectionResults(module, finder);
+        }
+
+        private IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module, DeclarationFinder finder)
+        {
+            var objectionableDeclarations = RelevantDeclarationsInModule(module, finder)
+                .Where(declaration => IsResultDeclaration(declaration, finder));
 
             return objectionableDeclarations
                 .Select(InspectionResult)
                 .ToList();
         }
 
-        protected virtual IEnumerable<Declaration> RelevantDeclarationsInModule(QualifiedModuleName module)
+        protected virtual IEnumerable<Declaration> RelevantDeclarationsInModule(QualifiedModuleName module, DeclarationFinder finder)
         {
             return RelevantDeclarationTypes
                 .SelectMany(declarationType => DeclarationFinderProvider.DeclarationFinder.Members(module, declarationType))

Rubberduck.CodeAnalysis/Inspections/Concrete/FunctionReturnValueAlwaysDiscardedInspection.cs

@@ -53,7 +53,7 @@ public FunctionReturnValueAlwaysDiscardedInspection(RubberduckParserState state)
             :base(state, DeclarationType.Function)
         {}
 
-        protected override bool IsResultDeclaration(Declaration declaration)
+        protected override bool IsResultDeclaration(Declaration declaration, DeclarationFinder finder)
         {
             if (!(declaration is ModuleBodyElementDeclaration moduleBodyElementDeclaration))
             {
@@ -66,8 +66,6 @@ protected override bool IsResultDeclaration(Declaration declaration)
                 return false;
             }
 
-            var finder = DeclarationFinderProvider.DeclarationFinder;
-
             if (moduleBodyElementDeclaration.IsInterfaceMember)
             {
                 return IsInterfaceIssue(moduleBodyElementDeclaration, finder);

Rubberduck.CodeAnalysis/Inspections/Concrete/ImplementedInterfaceMemberInspection.cs

@@ -1,14 +1,11 @@
 using Rubberduck.Inspections.Abstract;
-using Rubberduck.Inspections.Results;
-using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Resources.Inspections;
-using System.Collections.Generic;
 using System.Linq;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Inspections.Inspections.Extensions;
 using Rubberduck.Common;
-using System;
 using Rubberduck.Parsing.Annotations;
+using Rubberduck.Parsing.VBA.DeclarationCaching;
 
 namespace Rubberduck.Inspections.Concrete
 {
@@ -38,30 +35,49 @@ namespace Rubberduck.Inspections.Concrete
     /// End Sub
     /// ]]>
     /// </example>
-    internal class ImplementedInterfaceMemberInspection : InspectionBase
+    internal class ImplementedInterfaceMemberInspection : DeclarationInspectionBase
     {
         public ImplementedInterfaceMemberInspection(Parsing.VBA.RubberduckParserState state)
-            : base(state) { }
+            : base(state, DeclarationType.ClassModule)
+        {}
 
-        protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
+        protected override bool IsResultDeclaration(Declaration declaration, DeclarationFinder finder)
         {
-            var annotatedAsInterface = State.DeclarationFinder.Classes
-                .Where(cls => cls.Annotations.Any(an => an.Annotation is InterfaceAnnotation)).Cast<ClassModuleDeclaration>();
+            if (!IsInterfaceDeclaration(declaration))
+            {
+                return false;
+            }
 
-            var implementedAndOrAnnotatedInterfaceModules = State.DeclarationFinder.FindAllUserInterfaces()
-                .Union(annotatedAsInterface);
+            var moduleBodyElements = finder.Members(declaration, DeclarationType.Member)
+                .OfType<ModuleBodyElementDeclaration>();
 
-            return implementedAndOrAnnotatedInterfaceModules
-                .SelectMany(interfaceModule => interfaceModule.Members
-                    .Where(member => ((ModuleBodyElementDeclaration)member).Block.ContainsExecutableStatements(true)))
-                .Select(result => new DeclarationInspectionResult(this,
-                                        string.Format(InspectionResults.ImplementedInterfaceMemberInspection,
-                                                    result.QualifiedModuleName.ToString(),
-                                                    Resources.RubberduckUI.ResourceManager
-                                                        .GetString("DeclarationType_" + result.DeclarationType)
-                                                        .Capitalize(),
-                                                    result.IdentifierName),
-                                        result));
+            return moduleBodyElements
+                .Any(member => member.Block.ContainsExecutableStatements(true));
+        }
+
+        private static bool IsInterfaceDeclaration(Declaration declaration)
+        {
+            if (!(declaration is ClassModuleDeclaration classModule))
+            {
+                return false;
+            }
+            return classModule.IsInterface
+                || declaration.Annotations.Any(an => an.Annotation is InterfaceAnnotation);
+        }
+
+        protected override string ResultDescription(Declaration declaration)
+        {
+            var qualifiedName = declaration.QualifiedModuleName.ToString();
+            var declarationType = Resources.RubberduckUI.ResourceManager
+                .GetString("DeclarationType_" + declaration.DeclarationType)
+                .Capitalize();
+            var identifierName = declaration.IdentifierName;
+
+            return string.Format(
+                InspectionResults.ImplementedInterfaceMemberInspection,
+                qualifiedName,
+                declarationType,
+                identifierName);
         }
     }
 }