Simplified ParserState updates in RubberduckParserState by defining precedence

Author: Vogel612

Rubberduck.Parsing/VBA/ParserState.cs

@@ -5,34 +5,34 @@ public enum ParserState
         /// <summary>
         /// Parse was requested but hasn't started yet.
         /// </summary>
-        Pending,
+        Pending = 0,
         /// <summary>
         /// Project references are being loaded into parser state.
         /// </summary>
-        LoadingReference,
+        LoadingReference = 1,
         /// <summary>
         /// Code from modified modules is being parsed.
         /// </summary>
-        Parsing,
+        Parsing = 2,
         /// <summary>
         /// Parse tree is waiting to be walked for identifier resolution.
         /// </summary>
-        Parsed,
+        Parsed = 3,
         /// <summary>
         /// Resolving identifier references.
         /// </summary>
-        Resolving,
+        Resolving = 4,
         /// <summary>
         /// Parser state is in sync with the actual code in the VBE.
         /// </summary>
-        Ready,
+        Ready = 5,
         /// <summary>
         /// Parsing could not be completed for one or more modules.
         /// </summary>
-        Error,
+        Error = 99,
         /// <summary>
         /// Parsing completed, but identifier references could not be resolved for one or more modules.
         /// </summary>
-        ResolverError,
+        ResolverError = 6,
     }
 }

Rubberduck.Parsing/VBA/RubberduckParser.cs

@@ -129,8 +129,7 @@ private void AddDeclarationsFromProjectReferences(IReadOnlyList<VBProject> proje
             var references = projects
                 .SelectMany(project => project.References.Cast<Reference>())
                 .DistinctBy(reference => reference.Guid)
-                .Where(reference => reference.Type == vbext_RefKind.vbext_rk_TypeLib)
-                .ToList();
+                .Where(reference => reference.Type == vbext_RefKind.vbext_rk_TypeLib);
             foreach (var reference in references)
             {
                 AddDeclarationsFromReference(reference);

Rubberduck.Parsing/VBA/RubberduckParserState.cs

@@ -96,51 +96,16 @@ public void SetModuleState(VBComponent component, ParserState state, SyntaxError
             Status = EvaluateParserState();
         }
 
-        private static readonly ParserState[] States = Enum.GetValues(typeof (ParserState)).Cast<ParserState>().ToArray();
-
         private ParserState EvaluateParserState()
         {
-            //lock (_lock)
-            {
-                var moduleStates = _moduleStates.Values.ToList();
-                var state = States.SingleOrDefault(value => moduleStates.All(ps => ps == value));
-
-                if (state != default(ParserState))
-                {
-                    // if all modules are in the same state, we have our result.
-                    Debug.WriteLine("ParserState evaluates to '{0}' (thread {1})", state, Thread.CurrentThread.ManagedThreadId);
-                    return state;
-                }
+            var moduleStates = _moduleStates.Values.ToList();
 
-                // error state takes precedence over every other state
-                if (moduleStates.Any(ms => ms == ParserState.Error))
-                {
-                    Debug.WriteLine("ParserState evaluates to '{0}' (thread {1})", ParserState.Error,
-                        Thread.CurrentThread.ManagedThreadId);
-                    return ParserState.Error;
-                }
-                if (moduleStates.Any(ms => ms == ParserState.ResolverError))
-                {
-                    Debug.WriteLine("ParserState evaluates to '{0}' (thread {1})", ParserState.ResolverError,
-                        Thread.CurrentThread.ManagedThreadId);
-                    return ParserState.ResolverError;
-                }
-
-                // intermediate states are toggled when *any* module has them.
-                var result = moduleStates.Min();
-                if (moduleStates.Any(ms => ms == ParserState.Parsing))
-                {
-                    result = ParserState.Parsing;
-                }
-                if (moduleStates.Any(ms => ms == ParserState.Resolving))
-                {
-                    result = ParserState.Resolving;
-                }
-
-                Debug.WriteLine("ParserState evaluates to '{0}' (thread {1})", result,
-                    Thread.CurrentThread.ManagedThreadId);
-                return result;
+            var prelim = moduleStates.Max();
+            if (prelim == ParserState.Parsed && !moduleStates.All(s => s == ParserState.Parsed))
+            {
+                prelim = moduleStates.Where(s => s != ParserState.Parsed).Max();
             }
+            return prelim;
         }
 
         public ParserState GetModuleState(VBComponent component)