Use only 1 parser and add event to parser state to trigger a parse from anywhere.

Author: Hosch250

RetailCoder.VBE/App.cs

@@ -36,9 +36,6 @@ public class App : IDisposable
 
         private Configuration _config;
 
-        private readonly ConcurrentDictionary<VBComponent, CancellationTokenSource> _tokenSources =
-            new ConcurrentDictionary<VBComponent, CancellationTokenSource>(); 
-
         public App(VBE vbe, IMessageBox messageBox,
             IParserErrorsPresenterFactory parserErrorsPresenterFactory,
             IRubberduckParser parser,
@@ -94,7 +91,7 @@ private async void hooks_MessageReceived(object sender, HookEventArgs e)
                 }
 
                 var component = _vbe.ActiveCodePane.CodeModule.Parent;
-                ParseComponentAsync(component);
+                _parser.ParseComponentAsync(component);
 
                 AwaitNextKey();
                 return;
@@ -141,48 +138,14 @@ private async void hooks_MessageReceived(object sender, HookEventArgs e)
 
         private void _stateBar_Refresh(object sender, EventArgs e)
         {
-            ParseAll();
+            _parser.State.RequestParse();
         }
 
         private void Parser_StateChanged(object sender, EventArgs e)
         {
             _appMenus.EvaluateCanExecute(_parser.State);
         }
 
-        private void ParseComponentAsync(VBComponent component, bool resolve = true)
-        {
-            var tokenSource = RenewTokenSource(component);
-
-            var token = tokenSource.Token;
-            _parser.ParseAsync(component, token);
-
-            if (resolve && !token.IsCancellationRequested)
-            {
-                using (var source = new CancellationTokenSource())
-                {
-                    _parser.Resolve(source.Token);
-                }
-            }
-        }
-
-        private CancellationTokenSource RenewTokenSource(VBComponent component)
-        {
-            if (_tokenSources.ContainsKey(component))
-            {
-                CancellationTokenSource existingTokenSource;
-                _tokenSources.TryRemove(component, out existingTokenSource);
-                if (existingTokenSource != null)
-                {
-                    existingTokenSource.Cancel();
-                    existingTokenSource.Dispose();
-                }
-            }
-
-            var tokenSource = new CancellationTokenSource();
-            _tokenSources[component] = tokenSource;
-            return tokenSource;
-        }
-
         public void Startup()
         {
             CleanReloadConfig();
@@ -193,36 +156,15 @@ public void Startup()
             Task.Delay(1000).ContinueWith(t =>
             {
                 _parser.State.AddBuiltInDeclarations(_vbe.HostApplication());
-                ParseAll();
+                _parser.State.RequestParse();
             });
 
-            Task.Delay(1000).ContinueWith(t =>
-            {
-                _hooks.AddHook(new LowLevelKeyboardHook(_vbe));
-                _hooks.Attach();
-            });
             //_hooks.AddHook(new LowLevelKeyboardHook(_vbe));
             //_hooks.AddHook(new HotKey((IntPtr)_vbe.MainWindow.HWnd, "%^R", Keys.R));
             //_hooks.AddHook(new HotKey((IntPtr)_vbe.MainWindow.HWnd, "%^I", Keys.I));
             //_hooks.Attach();
         }
 
-        private void ParseAll()
-        {
-            var components = _vbe.VBProjects.Cast<VBProject>()
-                .SelectMany(project => project.VBComponents.Cast<VBComponent>());
-
-            var result = Parallel.ForEach(components, component => { ParseComponentAsync(component, false); });
-
-            if (result.IsCompleted)
-            {
-                using (var tokenSource = new CancellationTokenSource())
-                {
-                    _parser.Resolve(tokenSource.Token);
-                }
-            }
-        }
-
         private void CleanReloadConfig()
         {
             LoadConfig();
@@ -267,15 +209,6 @@ public void Dispose()
             _parser.State.StateChanged -= Parser_StateChanged;
 
             _hooks.Dispose();
-
-            if (_tokenSources.Any())
-            {
-                foreach (var tokenSource in _tokenSources)
-                {
-                    tokenSource.Value.Cancel();
-                    tokenSource.Value.Dispose();
-                }
-            }
         }
     }
 }

RetailCoder.VBE/Root/RubberduckModule.cs

@@ -61,6 +61,7 @@ public override void Load()
             Rebind<IIndenter>().To<Indenter>().InSingletonScope();
             Rebind<IIndenterSettings>().To<IndenterSettings>();
             Bind<TestExplorerModelBase>().To<StandardModuleTestExplorerModel>().InSingletonScope();
+            Rebind<IRubberduckParser>().To<RubberduckParser>().InSingletonScope();
 
             Bind<IPresenter>().To<TestExplorerDockablePresenter>()
                 .WhenInjectedInto<TestExplorerCommand>()

Rubberduck.Parsing/IRubberduckParser.cs

@@ -8,6 +8,7 @@ namespace Rubberduck.Parsing
     public interface IRubberduckParser
     {
         RubberduckParserState State { get; }
+        void ParseComponentAsync(VBComponent component, bool resolve = true);
         Task ParseAsync(VBComponent component, CancellationToken token);
         void Resolve(CancellationToken token);
     }

Rubberduck.Parsing/VBA/RubberduckParser.cs

@@ -1,14 +1,13 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
-using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Antlr4.Runtime;
 using Antlr4.Runtime.Tree;
 using Microsoft.Vbe.Interop;
-using NLog;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Nodes;
 using Rubberduck.Parsing.Symbols;
@@ -20,14 +19,76 @@ namespace Rubberduck.Parsing.VBA
 {
     public class RubberduckParser : IRubberduckParser
     {
-        public RubberduckParser(RubberduckParserState state)
+        public RubberduckParser(VBE vbe, RubberduckParserState state)
         {
+            _vbe = vbe;
             _state = state;
+
+            state.ParseRequest += state_ParseRequest;
+        }
+
+        void state_ParseRequest()
+        {
+            ParseAll();
         }
 
+        private readonly VBE _vbe;
         private readonly RubberduckParserState _state;
         public RubberduckParserState State { get { return _state; } }
 
+        private readonly ConcurrentDictionary<VBComponent, CancellationTokenSource> _tokenSources =
+           new ConcurrentDictionary<VBComponent, CancellationTokenSource>();
+
+        public void ParseComponentAsync(VBComponent component, bool resolve = true)
+        {
+            var tokenSource = RenewTokenSource(component);
+
+            var token = tokenSource.Token;
+            ParseAsync(component, token);
+
+            if (resolve && !token.IsCancellationRequested)
+            {
+                using (var source = new CancellationTokenSource())
+                {
+                    Resolve(source.Token);
+                }
+            }
+        }
+
+        private CancellationTokenSource RenewTokenSource(VBComponent component)
+        {
+            if (_tokenSources.ContainsKey(component))
+            {
+                CancellationTokenSource existingTokenSource;
+                _tokenSources.TryRemove(component, out existingTokenSource);
+                if (existingTokenSource != null)
+                {
+                    existingTokenSource.Cancel();
+                    existingTokenSource.Dispose();
+                }
+            }
+
+            var tokenSource = new CancellationTokenSource();
+            _tokenSources[component] = tokenSource;
+            return tokenSource;
+        }
+
+        private void ParseAll()
+        {
+            var components = _vbe.VBProjects.Cast<VBProject>()
+                .SelectMany(project => project.VBComponents.Cast<VBComponent>());
+
+            var result = Parallel.ForEach(components, component => { ParseComponentAsync(component, false); });
+
+            if (result.IsCompleted)
+            {
+                using (var tokenSource = new CancellationTokenSource())
+                {
+                    Resolve(tokenSource.Token);
+                }
+            }
+        }
+
         public Task ParseAsync(VBComponent vbComponent, CancellationToken token)
         {
             var component = vbComponent;

Rubberduck.Parsing/VBA/RubberduckParserState.cs

@@ -18,6 +18,9 @@ public enum ResolutionState
 
     public class RubberduckParserState
     {
+        public delegate void ParseRequestEventHandler();
+        public event ParseRequestEventHandler ParseRequest;
+
         // keys are the declarations; values indicate whether a declaration is resolved.
         private readonly ConcurrentDictionary<Declaration, ResolutionState> _declarations =
             new ConcurrentDictionary<Declaration, ResolutionState>();
@@ -192,5 +195,19 @@ public void AddBuiltInDeclarations(IHostApplication hostApplication)
                 AddDeclaration(declaration);
             }
         }
+
+        public void RequestParse()
+        {
+            OnParseRequest();
+        }
+
+        protected virtual void OnParseRequest()
+        {
+            var handler = ParseRequest;
+            if (handler != null)
+            {
+                handler();
+            }
+        }
     }
 }