Merge pull request #1372 from Vogel612/ParserFixIdea_2

retailcoder · retailcoder · commit d8df1a374b0b · 2016-04-25T17:52:57.000-04:00
ParserFix to correct ParserState behaviour
diff --git a/RetailCoder.VBE/UI/Command/ShowParserErrorsCommand.cs b/RetailCoder.VBE/UI/Command/ShowParserErrorsCommand.cs
@@ -79,8 +79,9 @@ private Declaration FindModuleDeclaration(VBComponent component)
             var result = _state.AllUserDeclarations.SingleOrDefault(item => item.ProjectId == component.Collection.Parent.HelpFile
                                                              && item.QualifiedName.QualifiedModuleName.ComponentName == component.Name
                                                              && (item.DeclarationType == DeclarationType.ClassModule || item.DeclarationType == DeclarationType.ProceduralModule));
-
-            var declaration = new Declaration(new QualifiedMemberName(new QualifiedModuleName(component), component.Name), project, project.Scope, component.Name, false, false, Accessibility.Global, DeclarationType.ProceduralModule, false);
+           
+            // FIXME dirty hack for project.Scope in case project is null. Clean up!
+            var declaration = new Declaration(new QualifiedMemberName(new QualifiedModuleName(component), component.Name), project, project == null ? null : project.Scope, component.Name, false, false, Accessibility.Global, DeclarationType.ProceduralModule, false);
             return result ?? declaration; // module isn't in parser state - give it a dummy declaration, just so the ViewModel has something to chew on
         }
     }
diff --git a/Rubberduck.Parsing/Symbols/SyntaxErrorException.cs b/Rubberduck.Parsing/Symbols/SyntaxErrorException.cs
@@ -17,7 +17,7 @@ public SyntaxErrorException(string message, RecognitionException innerException,
             _token = offendingSymbol;
             _line = line;
             _position = position;
-            Debug.WriteLine(innerException.ToString());
+            Debug.WriteLine(innerException == null ? "" : innerException.ToString());
             Debug.WriteLine("Token: {0} (L{1}C{2})", offendingSymbol.Text, line, position);
         }
 
diff --git a/Rubberduck.Parsing/VBA/RubberduckParser.cs b/Rubberduck.Parsing/VBA/RubberduckParser.cs
@@ -144,14 +144,18 @@ private void ParseAll()
                 return;
             }
 
-            foreach (var component in toParse)
-            {
-                _state.SetModuleState(component, ParserState.Pending);
-            }
-            foreach (var component in unchanged)
+
+            lock (_state)
             {
-                // note: seting to 'Parsed' would include them in the resolver walk. 'Ready' excludes them.
-                _state.SetModuleState(component, ParserState.Ready); 
+                foreach (var component in toParse)
+                {
+                    _state.SetModuleState(component, ParserState.Pending);
+                }
+                foreach (var component in unchanged)
+                {
+                    // note: seting to 'Parsed' would include them in the resolver walk. 'Ready' excludes them.
+                    _state.SetModuleState(component, ParserState.Ready);
+                }
             }
 
             // invalidation cleanup should go into ParseAsync?
@@ -186,18 +190,21 @@ private void AddBuiltInDeclarations(IReadOnlyList<VBProject> projects)
 
             var qualifiedName = new QualifiedModuleName(vba.IdentifierName, vba.IdentifierName, errObject.IdentifierName);
             var err = new Declaration(new QualifiedMemberName(qualifiedName, Tokens.Err), vba, "Global", errObject.IdentifierName, true, false, Accessibility.Global, DeclarationType.Variable);
-            _state.AddDeclaration(err);
-
             var debugClassName = new QualifiedModuleName(vba.IdentifierName, vba.IdentifierName, "DebugClass");
             var debugClass = new Declaration(new QualifiedMemberName(debugClassName, "DebugClass"), vba, "Global", "DebugClass", false, false, Accessibility.Global, DeclarationType.ClassModule);
             var debugObject = new Declaration(new QualifiedMemberName(debugClassName, "Debug"), vba, "Global", "DebugClass", true, false, Accessibility.Global, DeclarationType.Variable);
             var debugAssert = new Declaration(new QualifiedMemberName(debugClassName, "Assert"), debugObject, debugObject.Scope, null, false, false, Accessibility.Global, DeclarationType.Procedure);
             var debugPrint = new Declaration(new QualifiedMemberName(debugClassName, "Print"), debugObject, debugObject.Scope, null, false, false, Accessibility.Global, DeclarationType.Procedure);
 
-            _state.AddDeclaration(debugClass);
-            _state.AddDeclaration(debugObject);
-            _state.AddDeclaration(debugAssert);
-            _state.AddDeclaration(debugPrint);
+
+            lock (_state)
+            {
+                _state.AddDeclaration(err);
+                _state.AddDeclaration(debugClass);
+                _state.AddDeclaration(debugObject);
+                _state.AddDeclaration(debugAssert);
+                _state.AddDeclaration(debugPrint);
+            }
         }
 
         private readonly HashSet<ReferencePriorityMap> _projectReferences = new HashSet<ReferencePriorityMap>();
@@ -287,8 +294,12 @@ private void UnloadComReference(Reference reference, IReadOnlyList<VBProject> pr
 
         public Task ParseAsync(VBComponent component, CancellationToken token, TokenStreamRewriter rewriter = null)
         {
-            _state.ClearStateCache(component);            
-            _state.SetModuleState(component, ParserState.Pending); // also clears module-exceptions
+            lock (_state)
+            lock(component)
+            {
+                _state.ClearStateCache(component);
+                _state.SetModuleState(component, ParserState.Pending); // also clears module-exceptions
+            }
 
             var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_central.Token, token);
 
@@ -336,20 +347,34 @@ private void ParseAsyncInternal(VBComponent component, CancellationToken token,
         {
             var preprocessor = new VBAPreprocessor(double.Parse(_vbe.Version, CultureInfo.InvariantCulture));
             var parser = new ComponentParseTask(component, preprocessor, _attributeParser, rewriter);
-            parser.ParseFailure += (sender, e) => _state.SetModuleState(component, ParserState.Error, e.Cause as SyntaxErrorException);
+            parser.ParseFailure += (sender, e) =>
+            {
+                lock (_state)
+                lock (component)
+                {
+                    _state.SetModuleState(component, ParserState.Error, e.Cause as SyntaxErrorException);
+                }
+            };
             parser.ParseCompleted += (sender, e) =>
             {
-                // possibly lock _state
-                _state.SetModuleAttributes(component, e.Attributes);
-                _state.AddParseTree(component, e.ParseTree);
-                _state.AddTokenStream(component, e.Tokens);
-                _state.SetModuleComments(component, e.Comments);
-                _state.SetModuleAnnotations(component, e.Annotations);
-
-                // This really needs to go last
-                _state.SetModuleState(component, ParserState.Parsed);
+                lock (_state)
+                lock (component)
+                {
+                    _state.SetModuleAttributes(component, e.Attributes);
+                    _state.AddParseTree(component, e.ParseTree);
+                    _state.AddTokenStream(component, e.Tokens);
+                    _state.SetModuleComments(component, e.Comments);
+                    _state.SetModuleAnnotations(component, e.Annotations);
+
+                    // This really needs to go last
+                    _state.SetModuleState(component, ParserState.Parsed);
+                }
             };
-            _state.SetModuleState(component, ParserState.Parsing);
+            lock (_state)
+            lock (component)
+            {
+                _state.SetModuleState(component, ParserState.Parsing);
+            }
             parser.Start(token);
         }
 
@@ -426,18 +451,26 @@ private void ResolveDeclarations(VBComponent component, IParseTree tree)
                     argListWithOneByRefParamListener,
                 }), tree);
                 // TODO: these are actually (almost) inspection results.. we should handle them as such
-                _state.ArgListsWithOneByRefParam = argListWithOneByRefParamListener.Contexts.Select(context => new QualifiedContext(qualifiedModuleName, context));
-                _state.EmptyStringLiterals = emptyStringLiteralListener.Contexts.Select(context => new QualifiedContext(qualifiedModuleName, context));
-                _state.ObsoleteLetContexts = obsoleteLetStatementListener.Contexts.Select(context => new QualifiedContext(qualifiedModuleName, context));
-                _state.ObsoleteCallContexts = obsoleteCallStatementListener.Contexts.Select(context => new QualifiedContext(qualifiedModuleName, context));
+                lock (_state)
+                lock (component)
+                {
+                    _state.ArgListsWithOneByRefParam = argListWithOneByRefParamListener.Contexts.Select(context => new QualifiedContext(qualifiedModuleName, context));
+                    _state.EmptyStringLiterals = emptyStringLiteralListener.Contexts.Select(context => new QualifiedContext(qualifiedModuleName, context));
+                    _state.ObsoleteLetContexts = obsoleteLetStatementListener.Contexts.Select(context => new QualifiedContext(qualifiedModuleName, context));
+                    _state.ObsoleteCallContexts = obsoleteCallStatementListener.Contexts.Select(context => new QualifiedContext(qualifiedModuleName, context));
+                }
+
                 var project = component.Collection.Parent;
                 var projectQualifiedName = new QualifiedModuleName(project);
                 Declaration projectDeclaration;
                 if (!_projectDeclarations.TryGetValue(projectQualifiedName.ProjectId, out projectDeclaration))
                 {
                     projectDeclaration = CreateProjectDeclaration(projectQualifiedName, project);
                     _projectDeclarations.Add(projectQualifiedName.ProjectId, projectDeclaration);
-                    _state.AddDeclaration(projectDeclaration);
+                    lock(_state)
+                    {
+                        _state.AddDeclaration(projectDeclaration);
+                    }
                 }
                 var declarationsListener = new DeclarationSymbolsListener(qualifiedModuleName, Accessibility.Implicit, component.Type, _state.GetModuleComments(component), _state.GetModuleAnnotations(component), _state.GetModuleAttributes(component), _projectReferences, projectDeclaration);
                 // TODO: should we unify the API? consider working like the other listeners instead of event-based
@@ -451,7 +484,10 @@ private void ResolveDeclarations(VBComponent component, IParseTree tree)
             } catch (Exception exception)
             {
                 Debug.Print("Exception thrown acquiring declarations for '{0}' (thread {2}): {1}", component.Name, exception, Thread.CurrentThread.ManagedThreadId);
-                _state.SetModuleState(component, ParserState.ResolverError);
+                lock (_state)
+                {
+                    _state.SetModuleState(component, ParserState.ResolverError);
+                }
             }
         }
 
diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs
@@ -213,30 +213,43 @@ public void SetModuleState(VBComponent component, ParserState state, SyntaxError
         private ParserState EvaluateParserState()
         {
             var moduleStates = _moduleStates.Values.ToList();
-            if (moduleStates.Count == 0)
+            var state = States.SingleOrDefault(value => moduleStates.All(ps => ps == value));
+
+            if (state != default(ParserState))
             {
-                return 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;
             }
-            if (States.Any(state => moduleStates.All(module => module == state)))
+
+            // error state takes precedence over every other state
+            if (moduleStates.Any(ms => ms == ParserState.Error))
             {
-                // all modules have the same state - we're done here:
-                return moduleStates.First();
+                Debug.WriteLine("ParserState evaluates to '{0}' (thread {1})", ParserState.Error,
+                Thread.CurrentThread.ManagedThreadId);
+                return ParserState.Error;
             }
-
-            if (moduleStates.Any(module => module > ParserState.Ready)) // only states beyond "ready" are error states
+            if (moduleStates.Any(ms => ms == ParserState.ResolverError))
             {
-                // any error state seals the deal:
-                return moduleStates.Max();
+                Debug.WriteLine("ParserState evaluates to '{0}' (thread {1})", ParserState.ResolverError,
+                Thread.CurrentThread.ManagedThreadId);
+                return ParserState.ResolverError;
             }
 
-            if (moduleStates.Any(module => module != ParserState.Ready))
+            // 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))
             {
-                // any module not ready means at least one of them has work in progress;
-                // report the least advanced of them, except if that's 'Pending':
-                return moduleStates.Except(new[] { ParserState.Pending }).Min();
+                result = ParserState.Resolving;
             }
 
-            return default(ParserState); // default value is 'Pending'.
+            Debug.WriteLine("ParserState evaluates to '{0}' (thread {1})", result,
+            Thread.CurrentThread.ManagedThreadId);
+            return result;
         }
 
         public ParserState GetModuleState(VBComponent component)

Original file line number	Diff line number	Diff line change
`@@ -79,8 +79,9 @@ private Declaration FindModuleDeclaration(VBComponent component)`
`79`	`79`	`var result = _state.AllUserDeclarations.SingleOrDefault(item => item.ProjectId == component.Collection.Parent.HelpFile`
`80`	`80`	`&& item.QualifiedName.QualifiedModuleName.ComponentName == component.Name`
`81`	`81`	`&& (item.DeclarationType == DeclarationType.ClassModule \|\| item.DeclarationType == DeclarationType.ProceduralModule));`
`82`		`-`
`83`		`- var declaration = new Declaration(new QualifiedMemberName(new QualifiedModuleName(component), component.Name), project, project.Scope, component.Name, false, false, Accessibility.Global, DeclarationType.ProceduralModule, false);`
	`82`	`+`
	`83`	`+ // FIXME dirty hack for project.Scope in case project is null. Clean up!`
	`84`	`+ var declaration = new Declaration(new QualifiedMemberName(new QualifiedModuleName(component), component.Name), project, project == null ? null : project.Scope, component.Name, false, false, Accessibility.Global, DeclarationType.ProceduralModule, false);`
`84`	`85`	`return result ?? declaration; // module isn't in parser state - give it a dummy declaration, just so the ViewModel has something to chew on`
`85`	`86`	`}`
`86`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public SyntaxErrorException(string message, RecognitionException innerException,`
`17`	`17`	`_token = offendingSymbol;`
`18`	`18`	`_line = line;`
`19`	`19`	`_position = position;`
`20`		`- Debug.WriteLine(innerException.ToString());`
	`20`	`+ Debug.WriteLine(innerException == null ? "" : innerException.ToString());`
`21`	`21`	`Debug.WriteLine("Token: {0} (L{1}C{2})", offendingSymbol.Text, line, position);`
`22`	`22`	`}`
`23`	`23`