sync w/upstream

README.md

@@ -1,4 +1,4 @@
-![banner](https://user-images.githubusercontent.com/5751684/113501222-8edfe880-94f1-11eb-99a9-64583e413ef3.png)
+<!-- ![banner](https://user-images.githubusercontent.com/5751684/113501222-8edfe880-94f1-11eb-99a9-64583e413ef3.png) -->
 
 [**Installing**](https://github.com/rubberduck-vba/Rubberduck/wiki/Installing) • [Contributing](https://github.com/rubberduck-vba/Rubberduck/blob/next/CONTRIBUTING.md) • [Attributions](https://github.com/rubberduck-vba/Rubberduck/blob/next/docs/Attributions.md) • [Blog](https://rubberduckvba.blog) • [Wiki](https://github.com/rubberduck-vba/Rubberduck/wiki) • [rubberduckvba.com](https://rubberduckvba.com)
 

Rubberduck.CodeAnalysis/Inspections/Concrete/EmptyMethodInspection.cs

@@ -33,7 +33,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// ]]>
     /// </module>
     /// </example>
-    internal class EmptyMethodInspection : DeclarationInspectionBase
+    internal sealed class EmptyMethodInspection : DeclarationInspectionBase
     {
         public EmptyMethodInspection(IDeclarationFinderProvider declarationFinderProvider)
             : base(declarationFinderProvider, DeclarationType.Member)

Rubberduck.CodeAnalysis/Inspections/Concrete/EmptyModuleInspection.cs

@@ -84,7 +84,7 @@ public override bool VisitModuleDeclarations(VBAParser.ModuleDeclarationsContext
         public override bool VisitModuleDeclarationsElement(VBAParser.ModuleDeclarationsElementContext context)
         {
             return context.moduleVariableStmt() == null
-                   && context.constStmt() == null
+                   && context.moduleConstStmt() == null
                    && context.enumerationStmt() == null
                    && context.udtDeclaration() == null
                    && context.eventStmt() == null

Rubberduck.CodeAnalysis/Inspections/Concrete/ProcedureCanBeWrittenAsFunctionInspection.cs

@@ -13,8 +13,8 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// Warns about 'Sub' procedures that could be refactored into a 'Function'.
     /// </summary>
     /// <why>
-    /// Idiomatic VB code uses 'Function' procedures to return a single value. If the procedure isn't side-effecting, consider writing is as a
-    /// 'Function' rather than a 'Sub' the returns a result through a 'ByRef' parameter.
+    /// Idiomatic VB code uses 'Function' procedures to return a single value. If the procedure isn't side-effecting, consider writing it as a
+    /// 'Function' rather than a 'Sub' that returns a result through a 'ByRef' parameter.
     /// </why>
     /// <example hasResult="true">
     /// <module name="MyModule" type="Standard Module">

Rubberduck.CodeAnalysis/Inspections/Concrete/PublicEnumerationDeclaredInWorksheetInspection.cs

@@ -0,0 +1,83 @@
+using Rubberduck.CodeAnalysis.Inspections.Abstract;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Parsing.VBA.DeclarationCaching;
+using Rubberduck.Resources.Inspections;
+using Rubberduck.VBEditor.SafeComWrappers;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Rubberduck.CodeAnalysis.Inspections.Concrete
+{
+    /// <summary>
+    /// Identifies public enumerations declared within worksheet modules.
+    /// </summary>
+    /// <why>
+    /// Copying a worksheet which contains a public Enum declaration will also create a copy of the Enum declaration.  
+    /// The copied Enum declaration will result in an 'Ambiguous name detected' compiler error.  
+    /// Declaring Enumerations in Standard or Class modules avoids unintentional duplication of an Enum declaration.
+    /// </why>
+    /// <example hasResult="true">
+    /// <module name="WorksheetModule" type="Document Module">
+    /// <![CDATA[
+    /// Public Enum ExampleEnum
+    ///     FirstEnum = 0
+    ///     SecondEnum
+    /// End Enum
+    /// ]]>
+    /// </module>
+    /// </example>
+    /// <example hasResult="false">
+    /// <module name="WorksheetModule" type="Document Module">
+    /// <![CDATA[
+    /// Private Enum ExampleEnum
+    ///     FirstEnum = 0
+    ///     SecondEnum
+    /// End Enum
+    /// ]]>
+    /// </module>
+    /// </example>
+    internal sealed class PublicEnumerationDeclaredInWorksheetInspection : DeclarationInspectionBase
+    {
+        private readonly string[] _worksheetSuperTypeNames = new string[] { "Worksheet", "_Worksheet" };
+
+        public PublicEnumerationDeclaredInWorksheetInspection(IDeclarationFinderProvider declarationFinderProvider)
+            : base(declarationFinderProvider, DeclarationType.Enumeration)
+        {}
+
+        protected override bool IsResultDeclaration(Declaration enumeration, DeclarationFinder finder)
+        {
+            if (enumeration.Accessibility != Accessibility.Private
+               && enumeration.QualifiedModuleName.ComponentType == ComponentType.Document)
+            {
+                if (enumeration.ParentDeclaration is ClassModuleDeclaration classModuleDeclaration)
+                {
+                    return RetrieveSuperTypeNames(classModuleDeclaration).Intersect(_worksheetSuperTypeNames).Any();
+                }
+            }
+
+            return false;
+        }
+
+        protected override string ResultDescription(Declaration declaration)
+        {
+            return string.Format(InspectionResults.PublicEnumerationDeclaredInWorksheetInspection,
+                declaration.IdentifierName);
+        }
+
+        /// <summary>
+        /// Supports property injection for testing. 
+        /// </summary>
+        /// <remarks>
+        /// MockParser does not populate SuperTypes/SuperTypeNames.  RetrieveSuperTypeNames Func allows injection
+        /// of ClassModuleDeclaration.SuperTypeNames property results.
+        /// </remarks>
+        public Func<ClassModuleDeclaration, IEnumerable<string>> RetrieveSuperTypeNames { set; private get; } = GetSuperTypeNames;
+
+        private static IEnumerable<string> GetSuperTypeNames(ClassModuleDeclaration classModule)
+        {
+            return classModule.SupertypeNames;
+        }
+    }
+}

Rubberduck.CodeAnalysis/Inspections/Concrete/SheetAccessedUsingStringInspection.cs

@@ -229,9 +229,6 @@ private static string ComponentPropertyValue(IVBComponent component, string prop
             return null;
         }
 
-        protected override string ResultDescription(IdentifierReference reference, string codeName)
-        {
-            return InspectionResults.SheetAccessedUsingStringInspection;
-        }
+        protected override string ResultDescription(IdentifierReference reference, string codeName) => InspectionResults.SheetAccessedUsingStringInspection;
     }
 }

Rubberduck.CodeAnalysis/Inspections/Concrete/ThunderCode/KeywordsUsedAsMemberInspection.cs

@@ -19,7 +19,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete.ThunderCode
     /// While perfectly legal as Type or Enum member names, these identifiers should be avoided: 
     /// they need to be square-bracketed everywhere they are used.
     /// </why>
-    internal class KeywordsUsedAsMemberInspection : DeclarationInspectionBase
+    internal sealed class KeywordsUsedAsMemberInspection : DeclarationInspectionBase
     {
         public KeywordsUsedAsMemberInspection(IDeclarationFinderProvider declarationFinderProvider)
             : base(declarationFinderProvider, DeclarationType.EnumerationMember, DeclarationType.UserDefinedTypeMember)

Rubberduck.CodeAnalysis/Inspections/Concrete/ThunderCode/NonBreakingSpaceIdentifierInspection.cs

@@ -14,7 +14,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete.ThunderCode
     /// code our friend Andrew Jackson would have written to confuse Rubberduck's parser and/or resolver. 
     /// This inspection may accidentally reveal non-breaking spaces in code copied and pasted from a website.
     /// </why>
-    internal class NonBreakingSpaceIdentifierInspection : DeclarationInspectionBase
+    internal sealed class NonBreakingSpaceIdentifierInspection : DeclarationInspectionBase
     {
         private const string Nbsp = "\u00A0";
 

Rubberduck.CodeAnalysis/Inspections/Concrete/UDTMemberNotUsedInspection.cs

@@ -0,0 +1,83 @@
+using Rubberduck.CodeAnalysis.Inspections.Abstract;
+using Rubberduck.CodeAnalysis.Inspections.Extensions;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Parsing.VBA.DeclarationCaching;
+using Rubberduck.Resources.Inspections;
+using System.Linq;
+
+namespace Rubberduck.CodeAnalysis.Inspections.Concrete
+{
+    /// <summary>
+    /// Warns about User Defined Type (UDT) members that are never referenced.
+    /// </summary>
+    /// <why>
+    /// Declarations that are never used should be removed.
+    /// </why>
+    /// <example hasResult="true">
+    /// <module name="MyModule" type="Standard Module">
+    /// <![CDATA[
+    /// Private Type TTestModule
+    ///     FirstVal As Long
+    /// End Type
+    /// 
+    /// Private this As TTestModule
+    /// ]]>
+    /// </module>
+    /// </example>
+    /// <example hasResult="false">
+    /// <module name="MyModule" type="Standard Module">
+    /// <![CDATA[
+    /// Private Type TTestModule
+    ///     FirstVal As Long
+    /// End Type
+    /// 
+    /// Private this As TTestModule
+    /// 
+    /// 'UDT Member is assigned but not used
+    /// Public Sub DoSomething()
+    ///     this.FirstVal = 42
+    /// End Sub
+    /// ]]>
+    /// </module>
+    /// </example>
+    /// <example hasResult="false">
+    /// <module name="MyModule" type="Standard Module">
+    /// <![CDATA[
+    /// Private Type TTestModule
+    ///     FirstVal As Long
+    /// End Type
+    /// 
+    /// Private this As TTestModule
+    /// 
+    /// 'UDT Member is assigned and read
+    /// Public Sub DoSomething()
+    ///     this.FirstVal = 42
+    ///     Debug.Print this.FirstVal
+    /// End Sub
+    /// ]]>
+    /// </module>
+    /// </example>
+    internal sealed class UDTMemberNotUsedInspection : DeclarationInspectionBase
+    {
+        public UDTMemberNotUsedInspection(IDeclarationFinderProvider declarationFinderProvider)
+                : base(declarationFinderProvider, DeclarationType.UserDefinedTypeMember)
+        {}
+
+        protected override bool IsResultDeclaration(Declaration declaration, DeclarationFinder finder)
+        {
+            return declaration.DeclarationType.Equals(DeclarationType.UserDefinedTypeMember)
+                && !declaration.References.Any();
+        }
+
+        protected override string ResultDescription(Declaration declaration)
+        {
+            var declarationType = declaration.DeclarationType.ToLocalizedString();
+            var declarationName = declaration.IdentifierName;
+            return string.Format(
+                InspectionResults.IdentifierNotUsedInspection,
+                declarationType,
+                declarationName);
+        }
+    }
+}

Rubberduck.CodeAnalysis/QuickFixes/Abstract/QuickFixBase.cs

@@ -55,6 +55,22 @@ public void RemoveInspections(params Type[] inspections)
         public virtual CodeKind TargetCodeKind => CodeKind.CodePaneCode;
 
         public abstract void Fix(IInspectionResult result, IRewriteSession rewriteSession);
+
+        /// <summary>
+        /// FixMany defers the enumeration of inspection results to the QuickFix 
+        /// </summary>
+        /// <remarks>
+        /// The default implementation enumerates the results collection calling Fix() for each result.
+        /// Override this funcion when a QuickFix needs operate on results as a group (e.g., RemoveUnusedDeclarationQuickFix)
+        /// </remarks>
+        public virtual void Fix(IReadOnlyCollection<IInspectionResult> results, IRewriteSession rewriteSession)
+        {
+            foreach (var result in results)
+            {
+                Fix(result, rewriteSession);
+            }
+        }
+
         public abstract string Description(IInspectionResult result);
 
         public abstract bool CanFixMultiple { get; }

Rubberduck.CodeAnalysis/QuickFixes/Concrete/RemoveOptionBaseStatementQuickFix.cs → Rubberduck.CodeAnalysis/QuickFixes/Concrete/RemoveRedundantOptionStatementQuickFix.cs

@@ -35,9 +35,9 @@ namespace Rubberduck.CodeAnalysis.QuickFixes.Concrete
     /// ]]>
     /// </after>
     /// </example>
-    internal sealed class RemoveOptionBaseStatementQuickFix : QuickFixBase
+    internal sealed class RemoveRedundantOptionStatementQuickFix : QuickFixBase
     {
-        public RemoveOptionBaseStatementQuickFix()
+        public RemoveRedundantOptionStatementQuickFix()
             : base(typeof(RedundantOptionInspection))
         {}
 
@@ -47,7 +47,12 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio
             rewriter.Remove(result.Context);
         }
 
-        public override string Description(IInspectionResult result) => Resources.Inspections.QuickFixes.RemoveOptionBaseStatementQuickFix;
+        public override string Description(IInspectionResult result)
+        {
+            return string.Format(
+                Resources.Inspections.QuickFixes.RemoveRedundantOptionStatementQuickFix,
+                result.Context.GetText());
+        }
 
         public override bool CanFixMultiple => true;
         public override bool CanFixInProcedure => false;

Rubberduck.CodeAnalysis/QuickFixes/Concrete/RemoveUnassignedIdentifierQuickFix.cs

@@ -2,6 +2,10 @@
 using Rubberduck.CodeAnalysis.Inspections.Concrete;
 using Rubberduck.CodeAnalysis.QuickFixes.Abstract;
 using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Refactorings;
+using Rubberduck.Refactorings.DeleteDeclarations;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace Rubberduck.CodeAnalysis.QuickFixes.Concrete
 {
@@ -35,14 +39,25 @@ namespace Rubberduck.CodeAnalysis.QuickFixes.Concrete
     /// </example>
     internal sealed class RemoveUnassignedIdentifierQuickFix : QuickFixBase
     {
-        public RemoveUnassignedIdentifierQuickFix()
+        private readonly ICodeOnlyRefactoringAction<DeleteDeclarationsModel> _refactoring;
+        public RemoveUnassignedIdentifierQuickFix(DeleteDeclarationsRefactoringAction refactoringAction)
             : base(typeof(VariableNotAssignedInspection))
-        {}
+        {
+            _refactoring = refactoringAction;
+        }
 
         public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
         {
-            var rewriter = rewriteSession.CheckOutModuleRewriter(result.Target.QualifiedModuleName);
-            rewriter.Remove(result.Target);
+            var model = new DeleteDeclarationsModel(result.Target);
+
+            _refactoring.Refactor(model, rewriteSession);
+        }
+
+        public override void Fix(IReadOnlyCollection<IInspectionResult> results, IRewriteSession rewriteSession)
+        {
+            var model = new DeleteDeclarationsModel(results.Select(r => r.Target));
+
+            _refactoring.Refactor(model, rewriteSession);
         }
 
         public override string Description(IInspectionResult result) => Resources.Inspections.QuickFixes.RemoveUnassignedIdentifierQuickFix;

Rubberduck.CodeAnalysis/QuickFixes/Concrete/RemoveUnusedDeclarationQuickFix.cs

@@ -2,6 +2,12 @@
 using Rubberduck.CodeAnalysis.Inspections.Concrete;
 using Rubberduck.CodeAnalysis.QuickFixes.Abstract;
 using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Refactorings;
+using Rubberduck.Refactorings.Common;
+using Rubberduck.Refactorings.DeleteDeclarations;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace Rubberduck.CodeAnalysis.QuickFixes.Concrete
 {
@@ -31,25 +37,37 @@ namespace Rubberduck.CodeAnalysis.QuickFixes.Concrete
     /// Option Explicit
     /// 
     /// Public Sub DoSomething()
-    ///     
     ///     Debug.Print 42
     /// End Sub
     /// ]]>
     /// </after>
     /// </example>
     internal sealed class RemoveUnusedDeclarationQuickFix : QuickFixBase
     {
-        public RemoveUnusedDeclarationQuickFix()
+        private readonly ICodeOnlyRefactoringAction<DeleteDeclarationsModel> _refactoring;
+
+        public RemoveUnusedDeclarationQuickFix(DeleteDeclarationsRefactoringAction refactoringAction)
             : base(typeof(ConstantNotUsedInspection), 
                   typeof(ProcedureNotUsedInspection), 
                   typeof(VariableNotUsedInspection), 
-                  typeof(LineLabelNotUsedInspection))
-        {}
+                  typeof(LineLabelNotUsedInspection),
+                  typeof(UDTMemberNotUsedInspection))
+        {
+            _refactoring = refactoringAction;
+        }
 
         public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
         {
-            var rewriter = rewriteSession.CheckOutModuleRewriter(result.Target.QualifiedModuleName);
-            rewriter.Remove(result.Target);
+            var model = new DeleteDeclarationsModel(result.Target);
+
+            _refactoring.Refactor(model, rewriteSession);
+        }
+
+        public override void Fix(IReadOnlyCollection<IInspectionResult> results, IRewriteSession rewriteSession)
+        {
+            var model = new DeleteDeclarationsModel(results.Select(r => r.Target));
+
+            _refactoring.Refactor(model, rewriteSession);
         }
 
         public override string Description(IInspectionResult result) => Resources.Inspections.QuickFixes.RemoveUnusedDeclarationQuickFix;

Rubberduck.CodeAnalysis/QuickFixes/IQuickFix.cs

@@ -9,6 +9,7 @@ namespace Rubberduck.CodeAnalysis.QuickFixes
     public interface IQuickFix
     {
         void Fix(IInspectionResult result, IRewriteSession rewriteSession);
+        void Fix(IReadOnlyCollection<IInspectionResult> results, IRewriteSession rewriteSession);
         string Description(IInspectionResult result);
 
         bool CanFixMultiple { get; }