First refactoring of Parse and ParseAll

Author: MDoerner

Rubberduck.Parsing/VBA/EnumerableExtensions.cs

@@ -20,5 +20,10 @@ public static IEnumerable<T> DistinctBy<T, TKey>(this IEnumerable<T> source, Fun
             var hashSet = new HashSet<TKey>();
             return source.Where(item => hashSet.Add(keySelector(item)));
         }
+
+        public static HashSet<T> ToHashSet<T>(this IEnumerable<T> source)
+        {
+            return new HashSet<T>(source);
+        }
     }
 }

Rubberduck.Parsing/VBA/ParseCoordinator.cs

@@ -26,7 +26,7 @@ namespace Rubberduck.Parsing.VBA
     public class ParseCoordinator : IParseCoordinator
     {
         public RubberduckParserState State { get { return _state; } }
-        
+
         private readonly ConcurrentDictionary<IVBComponent, Tuple<Task, CancellationTokenSource>> _currentTasks =
             new ConcurrentDictionary<IVBComponent, Tuple<Task, CancellationTokenSource>>();
 
@@ -91,44 +91,69 @@ public void Parse(CancellationTokenSource token)
         {
             State.RefreshProjects(_vbe);
 
-            var components = new List<IVBComponent>();
-            foreach (var project in State.Projects)
-            {
-                foreach (var component in project.VBComponents)
-                {
-                    components.Add(component);
-                }
-            }
+            var components = State.Projects.SelectMany(project => project.VBComponents).ToList();
 
             // tests do not fire events when components are removed--clear components
-            foreach (var tree in State.ParseTrees)
-            {
-                State.ClearStateCache(tree.Key);    // handle potentially removed components without crashing
-            }
+            ClearComponentStateCacheForTests();
 
             SyncComReferences(State.Projects);
             State.RefreshFinder(_hostApp);
-
+            
             AddBuiltInDeclarations();
             State.RefreshFinder(_hostApp);
 
+            SetModuleStates(components, ParserState.Pending);
+
+            // invalidation cleanup should go into ParseAsync?
+            CleanUpComponentAttributes(components);
+
+            _projectDeclarations.Clear();
+            State.ClearBuiltInReferences();
+
+            ParseComponents(components, token);
+
+            if (token.IsCancellationRequested || State.Status >= ParserState.Error)
+            {
+                return;
+            }
+
+            State.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations);
+
+            ResolveReferences(token.Token);
+            
+            State.RebuildSelectionCache();
+
+        }
+
+        private void SetModuleStates(List<IVBComponent> components, ParserState parserState)
+        {
             foreach (var component in components)
             {
-                State.SetModuleState(component, ParserState.Pending);
+                State.SetModuleState(component, parserState);
             }
+        }
 
-            // invalidation cleanup should go into ParseAsync?
+        private void CleanUpComponentAttributes(List<IVBComponent> components)
+        {
             foreach (var key in _componentAttributes.Keys)
             {
                 if (!components.Contains(key))
                 {
                     _componentAttributes.Remove(key);
                 }
             }
+        }
 
-            _projectDeclarations.Clear();
-            State.ClearBuiltInReferences();
+        private void ClearComponentStateCacheForTests()
+        {
+            foreach (var tree in State.ParseTrees)
+            {
+                State.ClearStateCache(tree.Key);    // handle potentially removed components without crashing
+            }
+        }
 
+        private void ParseComponents(List<IVBComponent> components, CancellationTokenSource token)
+        {
             var parseTasks = new Task[components.Count];
             for (var i = 0; i < components.Count; i++)
             {
@@ -147,74 +172,35 @@ public void Parse(CancellationTokenSource token)
                     var qualifiedName = new QualifiedModuleName(components[index]);
 
                     State.SetModuleState(components[index], ParserState.ResolvingDeclarations);
+
                     ResolveDeclarations(qualifiedName.Component,
                         State.ParseTrees.Find(s => s.Key == qualifiedName).Value);
                 });
 
                 parseTasks[i].Start();
             }
-
             Task.WaitAll(parseTasks);
+        }
 
-            if (State.Status < ParserState.Error)
-            {
-                State.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations);
-                Task.WaitAll(ResolveReferencesAsync(token.Token));
-                State.RebuildSelectionCache();
-            }
+        private void ResolveReferences(CancellationToken token)
+        {
+            Task.WaitAll(ResolveReferencesAsync(token));
         }
 
+
         /// <summary>
         /// Starts parsing all components of all unprotected VBProjects associated with the VBE-Instance passed to the constructor of this parser instance.
         /// </summary>
         private void ParseAll(object requestor, CancellationTokenSource token)
         {
             State.RefreshProjects(_vbe);
-
-            var components = new List<IVBComponent>();
-            foreach (var project in State.Projects)
-            {
-                foreach (IVBComponent component in project.VBComponents)
-                {
-                    components.Add(component);
-                }
-            }
-
-            var componentsRemoved = false;
-            foreach (var declaration in State.AllUserDeclarations)
-            {
-                if (!declaration.DeclarationType.HasFlag(DeclarationType.Module))
-                {
-                    continue;
-                }
-
-                var componentExists = false;
-                foreach (var component in components)
-                {
-                    if (component.Name == declaration.ComponentName &&
-                        component.Collection.Parent.HelpFile == declaration.ProjectId)
-                    {
-                        componentExists = true;
-                        break;
-                    }
-                }
-
-                if (!componentExists)
-                {
-                    componentsRemoved = true;
-                    State.ClearStateCache(declaration.QualifiedName.QualifiedModuleName);
-                }
-            }
-
-            var toParse = new List<IVBComponent>();
-            foreach (var component in components)
-            {
-                if (State.IsNewOrModified(component))
-                {
-                    toParse.Add(component);
-                }
-            }
-
+           
+            var components = State.Projects.SelectMany(project => project.VBComponents).ToList();
+            
+            var componentsRemoved = ClearStateCashForRemovedComponents(components);
+           
+            var toParse = components.Where(component => State.IsNewOrModified(component)).ToList();     
+            
             if (toParse.Count == 0)
             {
                 if (componentsRemoved)  // trigger UI updates
@@ -225,11 +211,8 @@ private void ParseAll(object requestor, CancellationTokenSource token)
                 State.SetStatusAndFireStateChanged(requestor, State.Status);
                 //return; // returning here leaves state in 'ResolvedDeclarations' when a module is removed, which disables refresh
             }
-            
-            foreach (var component in toParse)
-            {
-                State.SetModuleState(component, ParserState.Pending);
-            }
+
+            SetModuleStates(toParse, ParserState.Pending);
 
             SyncComReferences(State.Projects);
             State.RefreshFinder(_hostApp);
@@ -238,13 +221,7 @@ private void ParseAll(object requestor, CancellationTokenSource token)
             State.RefreshFinder(_hostApp);
 
             // invalidation cleanup should go into ParseAsync?
-            foreach (var key in _componentAttributes.Keys)
-            {
-                if (!components.Contains(key))
-                {
-                    _componentAttributes.Remove(key);
-                }
-            }
+            CleanUpComponentAttributes(components);
 
             if (token.IsCancellationRequested)
             {
@@ -254,53 +231,46 @@ private void ParseAll(object requestor, CancellationTokenSource token)
             _projectDeclarations.Clear();
             State.ClearBuiltInReferences();
 
-            var parseTasks = new Task[toParse.Count];
-            for (var i = 0; i < toParse.Count; i++)
-            {
-                var index = i;
-                parseTasks[i] = new Task(() =>
-                {
-                    ParseAsync(toParse[index], token).Wait(token.Token);
+            ParseComponents(toParse, token);
 
-                    if (token.IsCancellationRequested)
-                    {
-                        return;
-                    }
-
-                    if (State.Status == ParserState.Error) { return; }
-
-                    var qualifiedName = new QualifiedModuleName(toParse[index]);
-
-                    State.SetModuleState(toParse[index], ParserState.ResolvingDeclarations);
-
-                    ResolveDeclarations(qualifiedName.Component,
-                        State.ParseTrees.Find(s => s.Key == qualifiedName).Value);
-                });
-
-                parseTasks[i].Start();
-            }
-
-            if (token.IsCancellationRequested)
+            if (token.IsCancellationRequested || State.Status >= ParserState.Error)
             {
                 return;
             }
 
-            Task.WaitAll(parseTasks);
+            Debug.Assert(State.ParseTrees.Count == components.Count, string.Format("ParserState has {0} parse trees for {1} components.", State.ParseTrees.Count, components.Count));
+                
+            State.SetStatusAndFireStateChanged(requestor, ParserState.ResolvedDeclarations);
+            
+            ResolveReferences(token.Token);
+            
+            State.RebuildSelectionCache();
+        }
 
-            if (token.IsCancellationRequested)
+        /// <summary>
+        /// Clears state cach for removed components.
+        /// Returns whether components have been removed.
+        /// </summary>
+        private bool ClearStateCashForRemovedComponents(List<IVBComponent> components)
+        {
+            var removedModuledecalrations = RemovedModuleDeclarations(components);
+            var componentRemoved = removedModuledecalrations.Any();
+            foreach (var declaration in removedModuledecalrations)
             {
-                return;
+                State.ClearStateCache(declaration.QualifiedName.QualifiedModuleName);
             }
+            return componentRemoved;
+        }
 
-            if (State.Status < ParserState.Error)
-            {
-                Debug.Assert(State.ParseTrees.Count == components.Count, string.Format("ParserState has {0} parse trees for {1} components.", State.ParseTrees.Count, components.Count));
-                State.SetStatusAndFireStateChanged(requestor, ParserState.ResolvedDeclarations);
-                Task.WaitAll(ResolveReferencesAsync(token.Token));
-                State.RebuildSelectionCache();
-            }
+        private IEnumerable<Declaration> RemovedModuleDeclarations(List<IVBComponent> components)
+        {
+            var moduleDeclarations = State.AllUserDeclarations.Where(declaration => declaration.DeclarationType.HasFlag(DeclarationType.Module));
+            var componentKeys = components.Select(component => new { name = component.Name, projectId = component.Collection.Parent.HelpFile }).ToHashSet();
+            var removedModuledecalrations = moduleDeclarations.Where(declaration => !componentKeys.Contains(new { name = declaration.ComponentName, projectId = declaration.ProjectId }));
+            return removedModuledecalrations;
         }
 
+
         private Task[] ResolveReferencesAsync(CancellationToken token)
         {
             foreach (var kvp in State.ParseTrees)