tried (failed) to add ItemAdded/ItemRemoved support for ReferencesEvents.

Author: retailcoder

RetailCoder.VBE/App.cs

@@ -93,6 +93,20 @@ public App(VBE vbe, IMessageBox messageBox,
             UiDispatcher.Initialize();
         }
 
+        private void ReferencesEvents_ItemAdded(Reference reference)
+        {
+            var state = _parser.State.Status;
+            _parser.LoadComReference(reference);
+            _parser.State.SetModuleState(state);
+        }
+
+        private void ReferencesEvents_ItemRemoved(Reference reference)
+        {
+            var state = _parser.State.Status;
+            _parser.UnloadComReference(reference);
+            _parser.State.SetModuleState(state);
+        }
+
         private void _hooks_MessageReceived(object sender, HookEventArgs e)
         {
             var hookType = sender.GetType();
@@ -145,14 +159,15 @@ public void Startup()
                 {
                     _parser.State.OnParseRequested(this);
                 });
-            }, new StaTaskScheduler()).ConfigureAwait(false);
+            }).ConfigureAwait(false);
 
             _hooks.HookHotkeys();
         }
 
         #region sink handlers. todo: move to another class
         async void sink_ProjectRemoved(object sender, DispatcherEventArgs<VBProject> e)
         {
+            _vbe.Events.ReferencesEvents[e.Item].ItemAdded -= ReferencesEvents_ItemAdded;
             _parser.State.RemoveProject(e.Item);
 
             Debug.WriteLine(string.Format("Project '{0}' was removed.", e.Item.Name));
@@ -168,6 +183,8 @@ async void sink_ProjectRemoved(object sender, DispatcherEventArgs<VBProject> e)
 
         async void sink_ProjectAdded(object sender, DispatcherEventArgs<VBProject> e)
         {
+            _vbe.Events.ReferencesEvents[e.Item].ItemAdded += ReferencesEvents_ItemAdded;
+            _vbe.Events.ReferencesEvents[e.Item].ItemRemoved += ReferencesEvents_ItemRemoved;
             _parser.State.AddProject(e.Item);
 
             if (!_parser.State.AllDeclarations.Any())

Rubberduck.Parsing/IRubberduckParser.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 using Antlr4.Runtime;
@@ -9,6 +10,8 @@ namespace Rubberduck.Parsing
     public interface IRubberduckParser
     {
         RubberduckParserState State { get; }
+        void LoadComReference(Reference item);
+        void UnloadComReference(Reference reference);
         void ParseComponent(VBComponent component, TokenStreamRewriter rewriter = null);
         Task ParseAsync(VBComponent component, CancellationToken token,  TokenStreamRewriter rewriter = null);
         void Cancel(VBComponent component = null);

Rubberduck.Parsing/VBA/RubberduckParser.cs

@@ -102,23 +102,9 @@ public void Parse()
                 .ToList();
 
             var components = projects.SelectMany(p => p.VBComponents.Cast<VBComponent>()).ToList();
-            foreach (var component in components)
-            {
-                _state.SetModuleState(component, ParserState.LoadingReference);
-            }
+            _state.SetModuleState(ParserState.LoadingReference);
 
-            if (!_state.AllDeclarations.Any(item => item.IsBuiltIn))
-            {
-                var references = projects.SelectMany(p => p.References.Cast<Reference>()).ToList();
-                foreach (var reference in references)
-                {
-                    var items = _comReflector.GetDeclarationsForReference(reference);
-                    foreach (var declaration in items)
-                    {
-                        _state.AddDeclaration(declaration);
-                    }
-                }
-            }
+            LoadComReferences(projects);
 
             foreach (var component in components)
             {
@@ -152,7 +138,9 @@ private void ParseAll()
 
             var components = projects.SelectMany(p => p.VBComponents.Cast<VBComponent>()).ToList();
             var modified = components.Where(_state.IsModified).ToList();
-            LoadComReferences(components, projects);
+
+            _state.SetModuleState(ParserState.LoadingReference);
+            LoadComReferences(projects);
 
             foreach (var component in modified)
             {
@@ -173,26 +161,51 @@ private void ParseAll()
             }
         }
 
-        private void LoadComReferences(IEnumerable<VBComponent> components, IEnumerable<VBProject> projects)
+        private readonly HashSet<Guid> _loadedReferences = new HashSet<Guid>();
+        private void LoadComReferences(IEnumerable<VBProject> projects)
+        {
+            var references = projects.SelectMany(p => p.References.Cast<Reference>()).ToList();
+            var newReferences = references
+                .Select(reference => new {Guid = new Guid(reference.Guid), Reference = reference})
+                .Where(item => !_loadedReferences.Contains(item.Guid));
+
+            foreach (var item in newReferences)
+            {
+                LoadComReference(item.Reference);
+            }
+        }
+
+        public void LoadComReference(Reference item)
         {
-            if (_state.AllDeclarations.Any(item => item.IsBuiltIn))
+            var guid = new Guid(item.Guid);
+            if (_loadedReferences.Contains(guid))
             {
                 return;
             }
 
-            foreach (var component in components)
+            var items = _comReflector.GetDeclarationsForReference(item).ToList();
+            foreach (var declaration in items)
             {
-                _state.SetModuleState(component, ParserState.LoadingReference);
+                _state.AddDeclaration(declaration);
             }
 
+            _loadedReferences.Add(new Guid(item.Guid));
+        }
+
+        public void UnloadComReference(Reference reference)
+        {
+            var projects = _state.Projects
+                .Where(project => project.Protection == vbext_ProjectProtection.vbext_pp_none)
+                .ToList();
+
             var references = projects.SelectMany(p => p.References.Cast<Reference>()).ToList();
-            foreach (var reference in references)
+            var target = references
+                .Select(item => new { Guid = new Guid(item.Guid), Reference = item })
+                .SingleOrDefault(item =>  _loadedReferences.Contains(item.Guid) && reference.Guid == item.Guid.ToString());
+
+            if (target != null)
             {
-                var items = _comReflector.GetDeclarationsForReference(reference).ToList();
-                foreach (var declaration in items)
-                {
-                    _state.AddDeclaration(declaration);
-                }
+                _state.RemoveBuiltInDeclarations(target.Reference);
             }
         }
 

Rubberduck.Parsing/VBA/RubberduckParserState.cs

@@ -138,6 +138,19 @@ private void OnModuleStateChanged(VBComponent component, ParserState state)
             }
         }
 
+        public void SetModuleState(ParserState state)
+        {
+            var projects = Projects
+                .Where(project => project.Protection == vbext_ProjectProtection.vbext_pp_none)
+                .ToList();
+
+            var components = projects.SelectMany(p => p.VBComponents.Cast<VBComponent>()).ToList();
+            foreach (var component in components)
+            {
+                SetModuleState(component, state);
+            }
+        }
+
         public void SetModuleState(VBComponent component, ParserState state, SyntaxErrorException parserError = null)
         {
             if (AllUserDeclarations.Any())
@@ -551,5 +564,17 @@ private static bool IsSelectedReference(QualifiedSelection selection, Identifier
             return reference.QualifiedModuleName.Equals(selection.QualifiedName)
                    && reference.Selection.ContainsFirstCharacter(selection.Selection);
         }
+
+        public void RemoveBuiltInDeclarations(Reference reference)
+        {
+            var projectName = reference.Name;
+            var key = new QualifiedModuleName(projectName, projectName);
+
+            ConcurrentDictionary<Declaration, byte> items;
+            if (!_declarations.TryRemove(key, out items))
+            {
+                Debug.WriteLine("Could not remove declarations for removed reference '{0}' ({1}).", reference.Name, reference.Guid);
+            }
+        }
     }
 }