Fix EvaluateCanExecute for find all implementations, closes #3045

Author: comintern

Rubberduck.Core/Navigation/CodeExplorer/CodeExplorerViewModel.cs

@@ -681,7 +681,7 @@ public double? FontSize
         public RenameCommand RenameCommand { get; set; }
         public IndentCommand IndenterCommand { get; set; }
         public CodeExplorerFindAllReferencesCommand FindAllReferencesCommand { get; set; }
-        public FindAllImplementationsCommand FindAllImplementationsCommand { get; set; }
+        public CodeExplorerFindAllImplementationsCommand FindAllImplementationsCommand { get; set; }
         public CommandBase CollapseAllSubnodesCommand { get; }
         public CopyResultsCommand CopyResultsCommand { get; set; }
         public CommandBase ExpandAllSubnodesCommand { get; }

Rubberduck.Core/UI/CodeExplorer/Commands/CodeExplorerFindAllImplementationsCommand.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using Rubberduck.Navigation.CodeExplorer;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.UI.Controls;
+
+namespace Rubberduck.UI.CodeExplorer.Commands
+{
+    public class CodeExplorerFindAllImplementationsCommand : CodeExplorerCommandBase
+    {
+        private static readonly Type[] ApplicableNodes =
+        {
+            typeof(CodeExplorerComponentViewModel),
+            typeof(CodeExplorerMemberViewModel)
+        };
+
+        private readonly RubberduckParserState _state;
+        private readonly FindAllImplementationsService _finder;
+
+        public CodeExplorerFindAllImplementationsCommand(RubberduckParserState state, FindAllImplementationsService finder)
+        {
+            _state = state;
+            _finder = finder;
+        }
+
+        protected override void OnExecute(object parameter)
+        {
+            if (_state.Status != ParserState.Ready ||
+                !(parameter is CodeExplorerItemViewModel node) ||
+                node.Declaration == null)
+            {
+                return;
+            }
+
+            _finder.FindAllImplementations(node.Declaration);
+        }
+
+        public override IEnumerable<Type> ApplicableNodeTypes => ApplicableNodes;
+
+        protected override bool EvaluateCanExecute(object parameter)
+        {
+            return base.EvaluateCanExecute(parameter) &&
+                   _state.Status == ParserState.Ready &&
+                   parameter is CodeExplorerItemViewModel node &&
+                   _finder.CanFind(node.Declaration);
+        }
+    }
+}

Rubberduck.Core/UI/Command/FindAllImplementationsCommand.cs

@@ -1,16 +1,8 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Runtime.InteropServices;
 using NLog;
-using Rubberduck.Interaction;
-using Rubberduck.Interaction.Navigation;
 using Rubberduck.Parsing.Symbols;
-using Rubberduck.Parsing.UIContext;
 using Rubberduck.Parsing.VBA;
-using Rubberduck.Resources;
 using Rubberduck.UI.Controls;
-using Rubberduck.VBEditor;
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 
 namespace Rubberduck.UI.Command
@@ -19,100 +11,36 @@ namespace Rubberduck.UI.Command
     /// A command that finds all implementations of a specified method, or of the active interface module.
     /// </summary>
     [ComVisible(false)]
-    public class FindAllImplementationsCommand : CommandBase, IDisposable
+    public class FindAllImplementationsCommand : CommandBase
     {
-        private readonly INavigateCommand _navigateCommand;
-        private readonly IMessageBox _messageBox;
         private readonly RubberduckParserState _state;
-        private readonly ISearchResultsWindowViewModel _viewModel;
-        private readonly SearchResultPresenterInstanceManager _presenterService;
         private readonly IVBE _vbe;
-        private readonly IUiDispatcher _uiDispatcher;
+        private readonly FindAllImplementationsService _finder;
 
-        private new static readonly Logger Logger = LogManager.GetCurrentClassLogger();
-
-        public FindAllImplementationsCommand(INavigateCommand navigateCommand, IMessageBox messageBox,
-            RubberduckParserState state, IVBE vbe, ISearchResultsWindowViewModel viewModel,
-            SearchResultPresenterInstanceManager presenterService, IUiDispatcher uiDispatcher)
+        public FindAllImplementationsCommand(RubberduckParserState state, IVBE vbe, ISearchResultsWindowViewModel viewModel, FindAllImplementationsService finder)
              : base(LogManager.GetCurrentClassLogger())
         {
-            _navigateCommand = navigateCommand;
-            _messageBox = messageBox;
+            _finder = finder;
             _state = state;
             _vbe = vbe;
-            _viewModel = viewModel;
-            _presenterService = presenterService;
-            _uiDispatcher = uiDispatcher;
-
-            _state.StateChanged += _state_StateChanged;
-        }
-
-        private Declaration FindNewDeclaration(Declaration declaration)
-        {
-            return _state.AllUserDeclarations.SingleOrDefault(item =>
-                        item.ProjectId == declaration.ProjectId &&
-                        item.ComponentName == declaration.ComponentName &&
-                        item.ParentScope == declaration.ParentScope &&
-                        item.IdentifierName == declaration.IdentifierName &&
-                        item.DeclarationType == declaration.DeclarationType);
         }
 
-        private void _state_StateChanged(object sender, ParserStateEventArgs e)
-        {
-            if (e.State != ParserState.Ready) { return; }
-
-            if (_viewModel == null) { return; }
-
-            _uiDispatcher.InvokeAsync(UpdateTab);
-        }
-
-        private void UpdateTab()
+        protected override bool EvaluateCanExecute(object parameter)
         {
-            try
-            {
-                var findImplementationsTabs = _viewModel.Tabs.Where(
-                    t => t.Header.StartsWith(RubberduckUI.AllImplementations_Caption.Replace("'{0}'", ""))).ToList();
-
-                foreach (var tab in findImplementationsTabs)
-                {
-                    var newTarget = FindNewDeclaration(tab.Target);
-                    if (newTarget == null)
-                    {
-                        tab.CloseCommand.Execute(null);
-                        return;
-                    }
-
-                    var vm = CreateViewModel(newTarget);
-                    if (vm.SearchResults.Any())
-                    {
-                        tab.SearchResults = vm.SearchResults;
-                        tab.Target = vm.Target;
-                    }
-                    else
-                    {
-                        tab.CloseCommand.Execute(null);
-                    }
-                }
-            }
-            catch (Exception exception)
+            if (_state.Status != ParserState.Ready)
             {
-                Logger.Error(exception, "Exception thrown while trying to update the find implementations tab.");
+                return false;
             }
-        }
 
-        protected override bool EvaluateCanExecute(object parameter)
-        {
             using (var codePane = _vbe.ActiveCodePane)
             {
-                if (codePane == null || codePane.IsWrappingNullReference || _state.Status != ParserState.Ready)
+                if (codePane == null || codePane.IsWrappingNullReference)
                 {
                     return false;
                 }
 
                 var target = FindTarget(parameter);
-                var canExecute = target != null;
-
-                return canExecute;
+                return _finder.CanFind(target);
             }
         }
 
@@ -129,77 +57,7 @@ protected override void OnExecute(object parameter)
                 return;
             }
 
-            var viewModel = CreateViewModel(declaration);
-            if (!viewModel.SearchResults.Any())
-            {
-                _messageBox.NotifyWarn(string.Format(RubberduckUI.AllReferences_NoneFound, declaration.IdentifierName), RubberduckUI.Rubberduck);
-                return;
-            }
-
-            if (viewModel.SearchResults.Count == 1)
-            {
-                _navigateCommand.Execute(viewModel.SearchResults.Single().GetNavigationArgs());
-                return;
-            }
-
-            _viewModel.AddTab(viewModel);
-            _viewModel.SelectedTab = viewModel;
-
-            try
-            {
-                var presenter = _presenterService.Presenter(_viewModel);
-                presenter.Show();
-            }
-            catch (Exception e)
-            {
-                Console.WriteLine(e);
-            }
-        }
-
-        private SearchResultsViewModel CreateViewModel(Declaration target)
-        {
-            IEnumerable<Declaration> implementations;
-            if (target is ClassModuleDeclaration classModule)
-            {
-                implementations = _state.DeclarationFinder.FindAllImplementationsOfInterface(classModule);
-            }
-            else if (target is IInterfaceExposable member && member.IsInterfaceMember)
-            {
-                implementations = _state.DeclarationFinder.FindInterfaceImplementationMembers(target);
-            }
-            else
-            {
-                implementations = target is ModuleBodyElementDeclaration implementation
-                    ? _state.DeclarationFinder.FindInterfaceImplementationMembers(implementation.InterfaceMemberImplemented)
-                    : Enumerable.Empty<Declaration>();
-            }
-
-            var results = implementations.Select(declaration =>
-                new SearchResultItem(
-                    declaration.ParentScopeDeclaration,
-                    new NavigateCodeEventArgs(declaration.QualifiedName.QualifiedModuleName, declaration.Selection),
-                    GetModuleLine(declaration.QualifiedName.QualifiedModuleName, declaration.Selection.StartLine)));
-
-            var accessor = target.DeclarationType.HasFlag(DeclarationType.PropertyGet) ? "(get)"
-                         : target.DeclarationType.HasFlag(DeclarationType.PropertyLet) ? "(let)"
-                         : target.DeclarationType.HasFlag(DeclarationType.PropertySet) ? "(set)"
-                         : string.Empty;
-
-            var tabCaption = $"{target.IdentifierName} {accessor}".Trim();
-
-            var viewModel = new SearchResultsViewModel(_navigateCommand,
-                string.Format(RubberduckUI.SearchResults_AllImplementationsTabFormat, tabCaption), target, results);
-
-            return viewModel;
-        }
-
-        private string GetModuleLine(QualifiedModuleName module, int line)
-        {
-            var component = _state.ProjectsProvider.Component(module);
-            using (var codeModule = component.CodeModule)
-            {
-                return codeModule.GetLines(line, 1).Trim();
-            }
+            _finder.FindAllImplementations(declaration);
         }
 
         private Declaration FindTarget(object parameter)
@@ -214,26 +72,5 @@ private Declaration FindTarget(object parameter)
                 return _state.FindSelectedDeclaration(activePane);
             }
         }
-
-        public void Dispose()
-        {
-            Dispose(true);
-            GC.SuppressFinalize(this);
-        }
-
-        private bool _isDisposed;
-        protected virtual void Dispose(bool disposing)
-        {
-            if (_isDisposed || !disposing)
-            {
-                return;
-            }
-
-            if (_state != null)
-            {
-                _state.StateChanged -= _state_StateChanged;
-            }
-            _isDisposed = true;
-        }
     }
 }

Rubberduck.Core/UI/Command/FindAllReferencesCommand.cs

@@ -17,7 +17,7 @@ public class FindAllReferencesCommand : CommandBase
     {
         private readonly RubberduckParserState _state;
         private readonly IVBE _vbe;
-        private FindAllReferencesService _finder;
+        private readonly FindAllReferencesService _finder;
 
         public FindAllReferencesCommand(RubberduckParserState state, IVBE vbe, ISearchResultsWindowViewModel viewModel, FindAllReferencesService finder)
             : base(LogManager.GetCurrentClassLogger())