Introduced option not to eval parser state on module state change and introduced method to trigger the evaluation manually. Moreover, made changing all module states concurrent.

Author: MDoerner

Rubberduck.Parsing/VBA/ParseCoordinator.cs

@@ -28,6 +28,7 @@ public class ParseCoordinator : IParseCoordinator
         public RubberduckParserState State { get { return _state; } }
 
         private const int _maxDegreeOfParserParallelism = -1;
+        private const int _maxDegreeOfModuleStateChangeParallelism = -1;
 
         private readonly IDictionary<IVBComponent, IDictionary<Tuple<string, DeclarationType>, Attributes>> _componentAttributes
             = new Dictionary<IVBComponent, IDictionary<Tuple<string, DeclarationType>, Attributes>>();
@@ -163,10 +164,12 @@ private void RefreshDeclarationFinder()
 
         private void SetModuleStates(List<IVBComponent> components, ParserState parserState)
         {
-            foreach (var component in components)
-            {
-                State.SetModuleState(component, parserState);
-            }
+            var options = new ParallelOptions();
+            options.MaxDegreeOfParallelism = _maxDegreeOfModuleStateChangeParallelism;
+
+            Parallel.ForEach(components, options, component => State.SetModuleState(component, parserState, null, false));
+            
+            State.EvaluateParserState();
         }
 
         private void CleanUpComponentAttributes(List<IVBComponent> components)
@@ -190,6 +193,8 @@ private void ClearComponentStateCacheForTests()
 
         private void ParseComponents(List<IVBComponent> components, CancellationToken token)
         {
+            SetModuleStates(components, ParserState.Parsing);
+
             var options = new ParallelOptions();
             options.CancellationToken = token;
             options.MaxDegreeOfParallelism = _maxDegreeOfParserParallelism;
@@ -198,12 +203,12 @@ private void ParseComponents(List<IVBComponent> components, CancellationToken to
                 options,
                 component =>
                 {
-                    State.SetModuleState(component, ParserState.Parsing);
                     State.ClearStateCache(component);
                     var finishedParseTask = FinishedParseComponentTask(component, token);
                     ProcessComponentParseResults(component, finishedParseTask);
                 }
             );
+            State.EvaluateParserState();
         }
 
         private Task<ComponentParseTask.ParseCompletionArgs> FinishedParseComponentTask(IVBComponent component, CancellationToken token, TokenStreamRewriter rewriter = null)
@@ -233,6 +238,7 @@ private void ProcessComponentParseResults(IVBComponent component, Task<Component
             finishedParseTask.Wait();
             if (finishedParseTask.IsFaulted)
             {
+                //In contrast to the situation in the success scenario, the overall parser state is reevaluated immediately.
                 State.SetModuleState(component, ParserState.Error, finishedParseTask.Exception.InnerException as SyntaxErrorException);
             }
             else if (finishedParseTask.IsCompleted)
@@ -249,7 +255,9 @@ private void ProcessComponentParseResults(IVBComponent component, Task<Component
                         State.SetModuleAnnotations(component, result.Annotations);
 
                         // This really needs to go last
-                        State.SetModuleState(component, ParserState.Parsed);
+                        //It does not reevaluate the overall parer state to avoid concurrent evaluation of all module states and for performance reasons.
+                        //The evaluation has to be triggered manually in the calling procedure.
+                        State.SetModuleState(component, ParserState.Parsed, null, false);
                     }
                 }
             }
@@ -258,6 +266,8 @@ private void ProcessComponentParseResults(IVBComponent component, Task<Component
 
         private void ResolveAllDeclarations(List<IVBComponent> components, CancellationToken token)
         {
+            SetModuleStates(components, ParserState.ResolvingDeclarations);
+
             var options = new ParallelOptions();
             options.CancellationToken = token;
             options.MaxDegreeOfParallelism = _maxDegreeOfParserParallelism;
@@ -267,7 +277,6 @@ private void ResolveAllDeclarations(List<IVBComponent> components, CancellationT
                 component =>
                 {
                     var qualifiedName = new QualifiedModuleName(component);
-                    State.SetModuleState(component, ParserState.ResolvingDeclarations);
                     ResolveDeclarations(qualifiedName.Component,
                         State.ParseTrees.Find(s => s.Key == qualifiedName).Value);
                 }

Rubberduck.Parsing/VBA/RubberduckParserState.cs

@@ -311,7 +311,7 @@ private void OnModuleStateChanged(IVBComponent component, ParserState state, Par
             }
         }
 
-        public void SetModuleState(IVBComponent component, ParserState state, SyntaxErrorException parserError = null)
+        public void SetModuleState(IVBComponent component, ParserState state, SyntaxErrorException parserError = null, bool evaluateOverallState = true)
         {
             if (AllUserDeclarations.Count > 0)
             {
@@ -339,7 +339,7 @@ public void SetModuleState(IVBComponent component, ParserState state, SyntaxErro
                 {
                     // ghost component shouldn't even exist
                     ClearStateCache(component);
-                    Status = EvaluateParserState();
+                    EvaluateParserState();
                     return;
                 }
             }
@@ -351,10 +351,18 @@ public void SetModuleState(IVBComponent component, ParserState state, SyntaxErro
             _moduleStates.AddOrUpdate(key, new ModuleState(parserError), (c, e) => e.SetModuleException(parserError));
             Logger.Debug("Module '{0}' state is changing to '{1}' (thread {2})", key.ComponentName, state, Thread.CurrentThread.ManagedThreadId);
             OnModuleStateChanged(component, state, oldState);
-            Status = EvaluateParserState();
+            if (evaluateOverallState)
+            {
+                EvaluateParserState();
+            }
+        }
+
+        public void EvaluateParserState()
+        {
+            lock (_statusLockObject) Status = OverallParserStateFromModuleStates();
         }
 
-        private ParserState EvaluateParserState()
+        private ParserState OverallParserStateFromModuleStates()
         {
             if (_moduleStates.IsEmpty)
             {
@@ -497,6 +505,7 @@ public ParserState GetModuleState(IVBComponent component)
             return _moduleStates.GetOrAdd(new QualifiedModuleName(component), new ModuleState(ParserState.Pending)).State;
         }
 
+        private readonly object _statusLockObject = new object(); 
         private ParserState _status;
         public ParserState Status
         {