Merge e5198b1 into e037d01

rubberduck-vba · Oct 13, 2021 · 9c574e2 · 9c574e2
2 parents e037d01 + e5198b1
commit 9c574e2
Show file tree

Hide file tree

Showing 67 changed files with 8,398 additions and 452 deletions.
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/Abstract/QuickFixBase.cs b/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 FixMany(IReadOnlyCollection<IInspectionResult> results, IRewriteSession rewriteSession)
+        {
+            foreach (var result in results)
+            {
+                Fix(result, rewriteSession);
+            }
+        }
+
         public abstract string Description(IInspectionResult result);
 
         public abstract bool CanFixMultiple { get; }

diff --git a/Rubberduck.CodeAnalysis/QuickFixes/Concrete/RemoveUnassignedIdentifierQuickFix.cs b/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 FixMany(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;

diff --git a/Rubberduck.CodeAnalysis/QuickFixes/Concrete/RemoveUnusedDeclarationQuickFix.cs b/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,36 @@ 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))
-        {}
+        {
+            _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 FixMany(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;

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

diff --git a/Rubberduck.CodeAnalysis/QuickFixes/Logistics/QuickFixProvider.cs b/Rubberduck.CodeAnalysis/QuickFixes/Logistics/QuickFixProvider.cs
@@ -80,22 +80,22 @@ public void Fix(IQuickFix fix, IInspectionResult result)
 
         public void Fix(IQuickFix fix, IEnumerable<IInspectionResult> resultsToFix)
         {
-            var results = resultsToFix.ToList();
+            var fixableResults = resultsToFix.Where(r => CanFix(fix, r)).ToList();
 
-            if (!results.Any())
+            if (!fixableResults.Any())
             {
                 return;
             }
 
             var rewriteSession = RewriteSession(fix.TargetCodeKind);
-            foreach (var result in results)
-            {
-                if (!CanFix(fix, result))
-                {
-                    continue;
-                }
 
-                fix.Fix(result, rewriteSession);
+            try
+            {
+                fix.FixMany(fixableResults, rewriteSession);
+            }
+            catch (RewriteFailedException)
+            {
+                _failureNotifier.NotifyQuickFixExecutionFailure(rewriteSession.Status);
             }
             Apply(rewriteSession);
         }

diff --git a/Rubberduck.Main/Root/RubberduckIoCInstaller.cs b/Rubberduck.Main/Root/RubberduckIoCInstaller.cs
@@ -393,6 +393,8 @@ private void RegisterSpecialFactories(IWindsorContainer container)
             RegisterUnreachableCaseFactories(container);
 
             RegisterEncapsulateFieldRefactoringFactories(container);
+
+            RegisterDeleteDeclarationsRefactoringActionFactories(container);
         }
 
         private void RegisterUnreachableCaseFactories(IWindsorContainer container)
@@ -421,6 +423,22 @@ private void RegisterEncapsulateFieldRefactoringFactories(IWindsorContainer cont
                  .LifestyleSingleton());
         }
 
+        private void RegisterDeleteDeclarationsRefactoringActionFactories(IWindsorContainer container)
+        {
+            container.Kernel.Register(Component.For<IDeclarationDeletionTargetFactory>()
+                .ImplementedBy<DeclarationDeletionTargetFactory>());
+
+            container.Kernel.Register(
+                Component.For<IDeclarationDeletionGroup>()
+                    .ImplementedBy<DeclarationDeletionGroup>().LifestyleTransient(),
+                Component.For<IDeclarationDeletionGroupFactory>().AsFactory().LifestyleSingleton());
+
+            container.Kernel.Register(
+                Component.For<IDeclarationDeletionGroupsGenerator>()
+                    .ImplementedBy<DeletionGroupsGenerator>().LifestyleTransient(),
+                Component.For<IDeclarationDeletionGroupsGeneratorFactory>().AsFactory().LifestyleSingleton());
+        }
+
         private void RegisterQuickFixes(IWindsorContainer container, Assembly[] assembliesToRegister)
         {
             foreach (var assembly in assembliesToRegister)

diff --git a/Rubberduck.Refactorings/Common/IModuleRewriterExtensions.cs b/Rubberduck.Refactorings/Common/IModuleRewriterExtensions.cs