Merge remote-tracking branch 'upstream/next' into Issue2964_TestExplorerDisableTestViaContextMenu

Author: IvenBach

Rubberduck.CodeAnalysis/Inspections/Concrete/EmptyMethodInspection.cs

@@ -0,0 +1,58 @@
+using Rubberduck.Inspections.Abstract;
+using Rubberduck.Inspections.Results;
+using Rubberduck.Parsing.Inspections.Abstract;
+using Rubberduck.Resources.Inspections;
+using Rubberduck.Parsing.VBA;
+using System.Collections.Generic;
+using System.Linq;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Inspections.Inspections.Extensions;
+using Rubberduck.Common;
+
+namespace Rubberduck.Inspections.Concrete
+{
+    /// <summary>
+    /// Identifies empty module member blocks.
+    /// </summary>
+    /// <why>
+    /// Methods containing no executable statements are misleading as they appear to be doing something which they actually don't.
+    /// This might be the result of delaying the actual implementation for a later stage of development, and then forgetting all about that.
+    /// </why>
+    /// <example hasResults="true">
+    /// <![CDATA[
+    /// Sub Foo()
+    ///     ' ...
+    /// End Sub
+    /// ]]>
+    /// </example>
+    /// <example hasResults="false">
+    /// <![CDATA[
+    /// Sub Foo()
+    ///     MsgBox "?"
+    /// End Sub
+    /// ]]>
+    /// </example>
+    internal class EmptyMethodInspection : InspectionBase
+    {
+        public EmptyMethodInspection(RubberduckParserState state)
+            : base(state) { }
+
+        protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
+        {
+            var allInterfaces = new HashSet<ClassModuleDeclaration>(State.DeclarationFinder.FindAllUserInterfaces());
+
+            return State.DeclarationFinder.UserDeclarations(DeclarationType.Member)
+                .Where(member => !allInterfaces.Any(userInterface => userInterface.QualifiedModuleName == member.QualifiedModuleName)
+                                 && !member.IsIgnoringInspectionResultFor(AnnotationName)
+                                 && !((ModuleBodyElementDeclaration)member).Block.ContainsExecutableStatements())
+
+                .Select(result => new DeclarationInspectionResult(this,
+                                        string.Format(InspectionResults.EmptyMethodInspection,
+                                                    Resources.RubberduckUI.ResourceManager
+                                                        .GetString("DeclarationType_" + result.DeclarationType)
+                                                        .Capitalize(),
+                                                    result.IdentifierName),
+                                        result));
+        }
+    }
+}

Rubberduck.CodeAnalysis/Inspections/Concrete/ImplementedInterfaceMemberInspection.cs

@@ -0,0 +1,53 @@
+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;
+
+namespace Rubberduck.Inspections.Concrete
+{
+    /// <summary>
+    /// Identifies implemented members of class modules that are used as interfaces.
+    /// </summary>
+    /// <why>
+    /// Interfaces provide a unified programmatic access to different objects, and therefore are rarely instantiated as concrete objects.
+    /// </why>
+    /// <example hasResults="false">
+    /// <![CDATA[
+    /// Sub Foo()
+    ///     ' ...
+    /// End Sub
+    /// ]]>
+    /// </example>
+    /// <example hasResults="true">
+    /// <![CDATA[
+    /// Sub Foo()
+    ///     MsgBox "?"
+    /// End Sub
+    /// ]]>
+    /// </example>
+    internal class ImplementedInterfaceMemberInspection : InspectionBase
+    {
+        public ImplementedInterfaceMemberInspection(Parsing.VBA.RubberduckParserState state)
+            : base(state) { }
+
+        protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
+        {
+            return State.DeclarationFinder.FindAllUserInterfaces()
+                .SelectMany(interfaceModule => interfaceModule.Members
+                    .Where(member => ((ModuleBodyElementDeclaration)member).Block.ContainsExecutableStatements(true)
+                                     && !member.IsIgnoringInspectionResultFor(AnnotationName)))
+                .Select(result => new DeclarationInspectionResult(this,
+                                        string.Format(InspectionResults.ImplementedInterfaceMemberInspection,
+                                                    Resources.RubberduckUI.ResourceManager
+                                                        .GetString("DeclarationType_" + result.DeclarationType)
+                                                        .Capitalize(),
+                                                    result.IdentifierName),
+                                        result));
+        }
+    }
+}

Rubberduck.CodeAnalysis/Inspections/Extensions/ExecutableBlocksExtensions.cs

@@ -0,0 +1,62 @@
+using Antlr4.Runtime.Tree;
+using static Rubberduck.Parsing.Grammar.VBAParser;
+
+namespace Rubberduck.Inspections.Inspections.Extensions
+{
+    public static class ExecutableBlocksExtensions
+    {
+        /// <summary>
+        /// Checks a block of code for executable statments and returns true if are present.
+        /// </summary>
+        /// <param name="block">The block to inspect</param>
+        /// <param name="considerAllocations">Determines wheather Dim or Const statements should be considered executables</param>
+        /// <returns></returns>
+        public static bool ContainsExecutableStatements(this BlockContext block, bool considerAllocations = false)
+        {
+            return block?.children != null && ContainsExecutableStatements(block.children, considerAllocations);
+        }
+
+        private static bool ContainsExecutableStatements(System.Collections.Generic.IList<IParseTree> blockChildren,
+                                                         bool considerAllocations = false)
+        {
+            foreach (var child in blockChildren)
+            {
+                if (child is BlockStmtContext blockStmt)
+                {
+                    var mainBlockStmt = blockStmt.mainBlockStmt();
+
+                    if (mainBlockStmt == null)
+                    {
+                        continue;   //We have a lone line label, which is not executable.
+                    }
+
+                    // if inspection does not consider allocations as executables,
+                    // exclude variables and consts because they are not executable statements
+                    if (!considerAllocations && IsConstOrVariable(mainBlockStmt.GetChild(0)))
+                    {
+                        continue;
+                    }
+
+                    return true;
+                }
+
+                if (child is RemCommentContext ||
+                    child is CommentContext ||
+                    child is CommentOrAnnotationContext ||
+                    child is EndOfStatementContext)
+                {
+                    continue;
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        private static bool IsConstOrVariable(IParseTree block)
+        {
+            return block is VariableStmtContext || block is ConstStmtContext;
+        }
+    }
+}