Cleanup for ParserState when starting beginning to parse a component

Vogel612 · Vogel612 · commit c8700fe91bc0 · 2016-03-28T23:41:05.000+02:00
diff --git a/Rubberduck.Parsing/Rubberduck.Parsing.csproj b/Rubberduck.Parsing/Rubberduck.Parsing.csproj
@@ -179,6 +179,8 @@
     <Compile Include="Symbols\ValuedDeclaration.cs" />
     <Compile Include="VBA\AttributeParser.cs" />
     <Compile Include="VBA\Attributes.cs" />
+    <Compile Include="VBA\CombinedParseTreeListener.cs" />
+    <Compile Include="VBA\ComponentParseTask.cs" />
     <Compile Include="VBA\EnumerableExtensions.cs" />
     <Compile Include="VBA\IAttributeParser.cs" />
     <Compile Include="VBA\IModuleExporter.cs" />
diff --git a/Rubberduck.Parsing/VBA/ComponentParseTask.cs b/Rubberduck.Parsing/VBA/ComponentParseTask.cs
@@ -93,7 +93,7 @@ public void Start(CancellationToken token)
             {
                 Debug.WriteLine("Operation was Cancelled", cancel);
                 // no results to be used, so no results "returned"
-                ParseCompleted.Invoke(this, new ParseCompletionArgs());
+                //ParseCompleted.Invoke(this, new ParseCompletionArgs());
             }
         }
 
@@ -151,7 +151,7 @@ public class ParseFailureArgs
             public Exception Cause { get; internal set; }
         }
 
-        private class CommentListener : VBABaseListener
+        private class CommentListener : VBAParserBaseListener
         {
             private readonly IList<VBAParser.RemCommentContext> _remComments = new List<VBAParser.RemCommentContext>();
             public IEnumerable<VBAParser.RemCommentContext> RemComments { get { return _remComments; } }
diff --git a/Rubberduck.Parsing/VBA/RubberduckParser.cs b/Rubberduck.Parsing/VBA/RubberduckParser.cs
@@ -20,11 +20,11 @@
 
 namespace Rubberduck.Parsing.VBA
 {
-    public class RubberduckParser : IRubberduckParser
+    public class RubberduckParserLegacy : IRubberduckParser
     {
         private readonly ReferencedDeclarationsCollector _comReflector;
 
-        public RubberduckParser(VBE vbe, RubberduckParserState state, IAttributeParser attributeParser)
+        public RubberduckParserLegacy(VBE vbe, RubberduckParserState state, IAttributeParser attributeParser)
         {
             _vbe = vbe;
             _state = state;
diff --git a/Rubberduck.Parsing/VBA/RubberduckParserReimpl.cs b/Rubberduck.Parsing/VBA/RubberduckParserReimpl.cs
@@ -17,7 +17,7 @@
 
 namespace Rubberduck.Parsing.VBA
 {
-    class RubberduckParserReimpl : IRubberduckParser
+    public class RubberduckParser : IRubberduckParser
     {
         public RubberduckParserState State
         {
@@ -27,8 +27,8 @@ public RubberduckParserState State
             }
         }
 
-        private readonly CancellationTokenSource _central = new CancellationTokenSource();
-        private readonly CancellationTokenSource _resolverTokenSource; // linked to _central later
+        private CancellationTokenSource _central = new CancellationTokenSource();
+        private CancellationTokenSource _resolverTokenSource; // linked to _central later
         private readonly Dictionary<VBComponent, Tuple<Task, CancellationTokenSource>> _currentTasks = new Dictionary<VBComponent, Tuple<Task, CancellationTokenSource>>();
 
         private readonly Dictionary<VBComponent, IParseTree> _parseTrees = new Dictionary<VBComponent, IParseTree>();
@@ -45,7 +45,7 @@ private readonly IDictionary<VBComponent, IDictionary<Tuple<string, DeclarationT
         private readonly RubberduckParserState _state;
         private readonly IAttributeParser _attributeParser;
 
-        public RubberduckParserReimpl(VBE vbe, RubberduckParserState state, IAttributeParser attributeParser)
+        public RubberduckParser(VBE vbe, RubberduckParserState state, IAttributeParser attributeParser)
         {
             _resolverTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_central.Token);
             _vbe = vbe;
@@ -60,11 +60,13 @@ public RubberduckParserReimpl(VBE vbe, RubberduckParserState state, IAttributePa
 
         private void StateOnStateChanged(object sender, EventArgs e)
         {
-            var args = e as ParserStateEventArgs;
+            ParserStateEventArgs args = e as ParserStateEventArgs;
+            Debug.WriteLine("RubberduckParser handles OnStateChanged ({0})", _state.Status);
+            // why access _state and not pass through EventArgs?
             if (args.State == ParserState.Parsed)
             {
+                Debug.WriteLine("(handling OnStateChanged) Starting resolver task");
                 Task.Run(() => Resolve(_central.Token));
-                // Resolving should be triggered.. not our job?
             }
         }
 
@@ -79,7 +81,18 @@ private void ReparseRequested(object sender, EventArgs e)
             else
             {
                 Cancel(args.Component);
-                ParseAsync(args.Component, CancellationToken.None, _state.GetRewriter(args.Component));
+                ParseAsync(args.Component, CancellationToken.None);
+            }
+        }
+
+        public void Parse()
+        {
+            try
+            {
+                ParseAll();
+            } catch (Exception e)
+            {
+                Debug.WriteLine(e);
             }
         }
 
@@ -103,16 +116,20 @@ private void ParseAll()
             {
                 while (!_state.ClearDeclarations(vbComponent)) { }
 
-                ParseAsync(vbComponent, CancellationToken.None, _state.GetRewriter(vbComponent));
+                ParseAsync(vbComponent, CancellationToken.None);
             }
         }
 
         public Task ParseAsync(VBComponent component, CancellationToken token, TokenStreamRewriter rewriter = null)
         {
-            // FIXME remove invalidated "things"from _state
-            // this includes: Declarations, Comments, Attributes, "InspectionResults" (ObsoleteCall, ObsoleteLet, EmptyStringLiteral, ArgLists with OneByRef) and possibly more...
+            // Remove invalidated "things" from _state
+            // this includes: Declarations, Comments, Attributes, Exceptions, ParseTree and TokenStream
+            // how that works with the Inspecion results is not quite clear
             _state.ClearDeclarations(component);
-            _state.SetModuleState(component, ParserState.Pending);
+            _state.AddParseTree(component, null);
+            _state.AddTokenStream(component, null);
+            
+            _state.SetModuleState(component, ParserState.Pending); // also clears module-exceptions
             _state.SetModuleComments(component, Enumerable.Empty<CommentNode>());
             _state.SetModuleAttributes(component, new Dictionary<Tuple<string, DeclarationType>, Attributes>());
 
@@ -127,35 +144,49 @@ public Task ParseAsync(VBComponent component, CancellationToken token, TokenStre
         }
 
         public void Cancel(VBComponent component = null)
-        {            
-            if (component == null)
-            {
-                _central.Cancel(false);
-            }
-            else
-            {
-                _resolverTokenSource.Cancel(false);
-                Tuple<Task, CancellationTokenSource> result;
-                if (_currentTasks.TryGetValue(component, out result))
+        {
+            lock (_central)
+            lock (_resolverTokenSource)
                 {
-                    result.Item2.Cancel(false);
+                    if (component == null)
+                    {
+                        _central.Cancel(false);
+
+                        _central.Dispose();
+                        _central = new CancellationTokenSource();
+                        _resolverTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_central.Token);
+                    }
+                    else
+                    {
+                        _resolverTokenSource.Cancel(false);
+                        _resolverTokenSource.Dispose();
+
+                        _resolverTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_central.Token);
+                        Tuple<Task, CancellationTokenSource> result;
+                        if (_currentTasks.TryGetValue(component, out result))
+                        {
+                            result.Item2.Cancel(false);
+                            result.Item2.Dispose();
+                        }
+                    }
+
                 }
-            }
         }
 
         private void ParseAsyncInternal(VBComponent component, CancellationToken token, TokenStreamRewriter rewriter = null)
         {
             var preprocessor = new VBAPreprocessor(double.Parse(_vbe.Version, CultureInfo.InvariantCulture));
-            var parser = new ComponentParseTask(component, preprocessor, _attributeParser, _state.GetRewriter(component));
+            var parser = new ComponentParseTask(component, preprocessor, _attributeParser, rewriter);
             parser.ParseFailure += (sender, e) => _state.SetModuleState(component, ParserState.Error, e.Cause as SyntaxErrorException);
             parser.ParseCompleted += (sender, e) =>
             {
                 // possibly lock _state
-                _state.SetModuleState(component, ParserState.Parsed);
                 _state.SetModuleAttributes(component, e.Attributes);
                 _state.AddParseTree(component, e.ParseTree);
                 _state.AddTokenStream(component, e.Tokens);
                 _state.SetModuleComments(component, e.Comments);
+                // This really needs to go last
+                _state.SetModuleState(component, ParserState.Parsed);
             };
             _state.SetModuleState(component, ParserState.Parsing);
             parser.Start(token);
@@ -219,7 +250,7 @@ private void ResolveDeclarations(VBComponent component, IParseTree tree)
             _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))
+            _state.ObsoleteCallContexts = obsoleteCallStatementListener.Contexts.Select(context => new QualifiedContext(qualifiedModuleName, context));
         }
         
         private void ResolveReferences(DeclarationFinder finder, VBComponent component, IParseTree tree)
@@ -255,7 +286,7 @@ private void ResolveReferences(DeclarationFinder finder, VBComponent component,
         }
 
         #region Listener classes
-        private class ObsoleteCallStatementListener : VBABaseListener
+        private class ObsoleteCallStatementListener : VBAParserBaseListener
         {
             private readonly IList<VBAParser.ExplicitCallStmtContext> _contexts = new List<VBAParser.ExplicitCallStmtContext>();
             public IEnumerable<VBAParser.ExplicitCallStmtContext> Contexts { get { return _contexts; } }
@@ -279,7 +310,7 @@ public override void ExitExplicitCallStmt(VBAParser.ExplicitCallStmtContext cont
             }
         }
 
-        private class ObsoleteLetStatementListener : VBABaseListener
+        private class ObsoleteLetStatementListener : VBAParserBaseListener
         {
             private readonly IList<VBAParser.LetStmtContext> _contexts = new List<VBAParser.LetStmtContext>();
             public IEnumerable<VBAParser.LetStmtContext> Contexts { get { return _contexts; } }
@@ -293,7 +324,7 @@ public override void ExitLetStmt(VBAParser.LetStmtContext context)
             }
         }
 
-        private class EmptyStringLiteralListener : VBABaseListener
+        private class EmptyStringLiteralListener : VBAParserBaseListener
         {
             private readonly IList<VBAParser.LiteralContext> _contexts = new List<VBAParser.LiteralContext>();
             public IEnumerable<VBAParser.LiteralContext> Contexts { get { return _contexts; } }
@@ -308,7 +339,7 @@ public override void ExitLiteral(VBAParser.LiteralContext context)
             }
         }
 
-        private class ArgListWithOneByRefParamListener : VBABaseListener
+        private class ArgListWithOneByRefParamListener : VBAParserBaseListener
         {
             private readonly IList<VBAParser.ArgListContext> _contexts = new List<VBAParser.ArgListContext>();
             public IEnumerable<VBAParser.ArgListContext> Contexts { get { return _contexts; } }
diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs
@@ -69,14 +69,14 @@ public IReadOnlyList<Tuple<VBComponent, SyntaxErrorException>> ModuleExceptions
             get { return _moduleExceptions.Select(kvp => Tuple.Create(kvp.Key, kvp.Value)).Where(item => item.Item2 != null).ToList(); }
         }
 
-        public event EventHandler StateChanged;
+        public event EventHandler<ParserStateEventArgs> StateChanged;
 
-        private void OnStateChanged()
+        private void OnStateChanged(ParserState state = ParserState.Pending)
         {
             var handler = StateChanged;
             if (handler != null)
             {
-                handler.Invoke(this, EventArgs.Empty);
+                handler.Invoke(this, new ParserStateEventArgs(state));
             }
         }
         public event EventHandler<ParseProgressEventArgs> ModuleStateChanged;
@@ -99,6 +99,8 @@ public void SetModuleState(VBComponent component, ParserState state, SyntaxError
             Debug.WriteLine("Module '{0}' state is changing to '{1}' (thread {2})", component.Name, state, Thread.CurrentThread.ManagedThreadId);
             OnModuleStateChanged(component, state);
             Status = EvaluateParserState();
+
+            OnStateChanged(Status);
         }
 
         private ParserState EvaluateParserState()
@@ -128,7 +130,7 @@ private set
                 {
                     _status = value; 
                     Debug.WriteLine("ParserState changed to '{0}', raising OnStateChanged", value);
-                    OnStateChanged();
+                    OnStateChanged(_status);
                 }
             } 
         }

Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ public void Start(CancellationToken token)`
`93`	`93`	`{`
`94`	`94`	`Debug.WriteLine("Operation was Cancelled", cancel);`
`95`	`95`	`// no results to be used, so no results "returned"`
`96`		`- ParseCompleted.Invoke(this, new ParseCompletionArgs());`
	`96`	`+ //ParseCompleted.Invoke(this, new ParseCompletionArgs());`
`97`	`97`	`}`
`98`	`98`	`}`
`99`	`99`
`@@ -151,7 +151,7 @@ public class ParseFailureArgs`
`151`	`151`	`public Exception Cause { get; internal set; }`
`152`	`152`	`}`
`153`	`153`
`154`		`- private class CommentListener : VBABaseListener`
	`154`	`+ private class CommentListener : VBAParserBaseListener`
`155`	`155`	`{`
`156`	`156`	`private readonly IList<VBAParser.RemCommentContext> _remComments = new List<VBAParser.RemCommentContext>();`
`157`	`157`	`public IEnumerable<VBAParser.RemCommentContext> RemComments { get { return _remComments; } }`
Original file line number	Diff line number	Diff line change
`@@ -20,11 +20,11 @@`
`20`	`20`
`21`	`21`	`namespace Rubberduck.Parsing.VBA`
`22`	`22`	`{`
`23`		`- public class RubberduckParser : IRubberduckParser`
	`23`	`+ public class RubberduckParserLegacy : IRubberduckParser`
`24`	`24`	`{`
`25`	`25`	`private readonly ReferencedDeclarationsCollector _comReflector;`
`26`	`26`
`27`		`- public RubberduckParser(VBE vbe, RubberduckParserState state, IAttributeParser attributeParser)`
	`27`	`+ public RubberduckParserLegacy(VBE vbe, RubberduckParserState state, IAttributeParser attributeParser)`
`28`	`28`	`{`
`29`	`29`	`_vbe = vbe;`
`30`	`30`	`_state = state;`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@`
`17`	`17`
`18`	`18`	`namespace Rubberduck.Parsing.VBA`
`19`	`19`	`{`
`20`		`- class RubberduckParserReimpl : IRubberduckParser`
	`20`	`+ public class RubberduckParser : IRubberduckParser`
`21`	`21`	`{`
`22`	`22`	`public RubberduckParserState State`
`23`	`23`	`{`
`@@ -27,8 +27,8 @@ public RubberduckParserState State`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`
`30`		`- private readonly CancellationTokenSource _central = new CancellationTokenSource();`
`31`		`- private readonly CancellationTokenSource _resolverTokenSource; // linked to _central later`
	`30`	`+ private CancellationTokenSource _central = new CancellationTokenSource();`
	`31`	`+ private CancellationTokenSource _resolverTokenSource; // linked to _central later`
`32`	`32`	`private readonly Dictionary<VBComponent, Tuple<Task, CancellationTokenSource>> _currentTasks = new Dictionary<VBComponent, Tuple<Task, CancellationTokenSource>>();`
`33`	`33`
`34`	`34`	`private readonly Dictionary<VBComponent, IParseTree> _parseTrees = new Dictionary<VBComponent, IParseTree>();`
`@@ -45,7 +45,7 @@ private readonly IDictionary<VBComponent, IDictionary<Tuple<string, DeclarationT`
`45`	`45`	`private readonly RubberduckParserState _state;`
`46`	`46`	`private readonly IAttributeParser _attributeParser;`
`47`	`47`
`48`		`- public RubberduckParserReimpl(VBE vbe, RubberduckParserState state, IAttributeParser attributeParser)`
	`48`	`+ public RubberduckParser(VBE vbe, RubberduckParserState state, IAttributeParser attributeParser)`
`49`	`49`	`{`
`50`	`50`	`_resolverTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_central.Token);`
`51`	`51`	`_vbe = vbe;`
`@@ -60,11 +60,13 @@ public RubberduckParserReimpl(VBE vbe, RubberduckParserState state, IAttributePa`
`60`	`60`
`61`	`61`	`private void StateOnStateChanged(object sender, EventArgs e)`
`62`	`62`	`{`
`63`		`- var args = e as ParserStateEventArgs;`
	`63`	`+ ParserStateEventArgs args = e as ParserStateEventArgs;`
	`64`	`+ Debug.WriteLine("RubberduckParser handles OnStateChanged ({0})", _state.Status);`
	`65`	`+ // why access _state and not pass through EventArgs?`
`64`	`66`	`if (args.State == ParserState.Parsed)`
`65`	`67`	`{`
	`68`	`+ Debug.WriteLine("(handling OnStateChanged) Starting resolver task");`
`66`	`69`	`Task.Run(() => Resolve(_central.Token));`
`67`		`- // Resolving should be triggered.. not our job?`
`68`	`70`	`}`
`69`	`71`	`}`
`70`	`72`
`@@ -79,7 +81,18 @@ private void ReparseRequested(object sender, EventArgs e)`
`79`	`81`	`else`
`80`	`82`	`{`
`81`	`83`	`Cancel(args.Component);`
`82`		`- ParseAsync(args.Component, CancellationToken.None, _state.GetRewriter(args.Component));`
	`84`	`+ ParseAsync(args.Component, CancellationToken.None);`
	`85`	`+ }`
	`86`	`+ }`
	`87`	`+`
	`88`	`+ public void Parse()`
	`89`	`+ {`
	`90`	`+ try`
	`91`	`+ {`
	`92`	`+ ParseAll();`
	`93`	`+ } catch (Exception e)`
	`94`	`+ {`
	`95`	`+ Debug.WriteLine(e);`
`83`	`96`	`}`
`84`	`97`	`}`
`85`	`98`
`@@ -103,16 +116,20 @@ private void ParseAll()`
`103`	`116`	`{`
`104`	`117`	`while (!_state.ClearDeclarations(vbComponent)) { }`
`105`	`118`
`106`		`- ParseAsync(vbComponent, CancellationToken.None, _state.GetRewriter(vbComponent));`
	`119`	`+ ParseAsync(vbComponent, CancellationToken.None);`
`107`	`120`	`}`
`108`	`121`	`}`
`109`	`122`
`110`	`123`	`public Task ParseAsync(VBComponent component, CancellationToken token, TokenStreamRewriter rewriter = null)`
`111`	`124`	`{`
`112`		`- // FIXME remove invalidated "things"from _state`
`113`		`- // this includes: Declarations, Comments, Attributes, "InspectionResults" (ObsoleteCall, ObsoleteLet, EmptyStringLiteral, ArgLists with OneByRef) and possibly more...`
	`125`	`+ // Remove invalidated "things" from _state`
	`126`	`+ // this includes: Declarations, Comments, Attributes, Exceptions, ParseTree and TokenStream`
	`127`	`+ // how that works with the Inspecion results is not quite clear`
`114`	`128`	`_state.ClearDeclarations(component);`
`115`		`- _state.SetModuleState(component, ParserState.Pending);`
	`129`	`+ _state.AddParseTree(component, null);`
	`130`	`+ _state.AddTokenStream(component, null);`
	`131`	`+`
	`132`	`+ _state.SetModuleState(component, ParserState.Pending); // also clears module-exceptions`
`116`	`133`	`_state.SetModuleComments(component, Enumerable.Empty<CommentNode>());`
`117`	`134`	`_state.SetModuleAttributes(component, new Dictionary<Tuple<string, DeclarationType>, Attributes>());`
`118`	`135`
`@@ -127,35 +144,49 @@ public Task ParseAsync(VBComponent component, CancellationToken token, TokenStre`
`127`	`144`	`}`
`128`	`145`
`129`	`146`	`public void Cancel(VBComponent component = null)`
`130`		`- {`
`131`		`- if (component == null)`
`132`		`- {`
`133`		`- _central.Cancel(false);`
`134`		`- }`
`135`		`- else`
`136`		`- {`
`137`		`- _resolverTokenSource.Cancel(false);`
`138`		`- Tuple<Task, CancellationTokenSource> result;`
`139`		`- if (_currentTasks.TryGetValue(component, out result))`
	`147`	`+ {`
	`148`	`+ lock (_central)`
	`149`	`+ lock (_resolverTokenSource)`
`140`	`150`	`{`
`141`		`- result.Item2.Cancel(false);`
	`151`	`+ if (component == null)`
	`152`	`+ {`
	`153`	`+ _central.Cancel(false);`
	`154`	`+`
	`155`	`+ _central.Dispose();`
	`156`	`+ _central = new CancellationTokenSource();`
	`157`	`+ _resolverTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_central.Token);`
	`158`	`+ }`
	`159`	`+ else`
	`160`	`+ {`
	`161`	`+ _resolverTokenSource.Cancel(false);`
	`162`	`+ _resolverTokenSource.Dispose();`
	`163`	`+`
	`164`	`+ _resolverTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_central.Token);`
	`165`	`+ Tuple<Task, CancellationTokenSource> result;`
	`166`	`+ if (_currentTasks.TryGetValue(component, out result))`
	`167`	`+ {`
	`168`	`+ result.Item2.Cancel(false);`
	`169`	`+ result.Item2.Dispose();`
	`170`	`+ }`
	`171`	`+ }`
	`172`	`+`
`142`	`173`	`}`
`143`		`- }`
`144`	`174`	`}`
`145`	`175`
`146`	`176`	`private void ParseAsyncInternal(VBComponent component, CancellationToken token, TokenStreamRewriter rewriter = null)`
`147`	`177`	`{`
`148`	`178`	`var preprocessor = new VBAPreprocessor(double.Parse(_vbe.Version, CultureInfo.InvariantCulture));`
`149`		`- var parser = new ComponentParseTask(component, preprocessor, _attributeParser, _state.GetRewriter(component));`
	`179`	`+ var parser = new ComponentParseTask(component, preprocessor, _attributeParser, rewriter);`
`150`	`180`	`parser.ParseFailure += (sender, e) => _state.SetModuleState(component, ParserState.Error, e.Cause as SyntaxErrorException);`
`151`	`181`	`parser.ParseCompleted += (sender, e) =>`
`152`	`182`	`{`
`153`	`183`	`// possibly lock _state`
`154`		`- _state.SetModuleState(component, ParserState.Parsed);`
`155`	`184`	`_state.SetModuleAttributes(component, e.Attributes);`
`156`	`185`	`_state.AddParseTree(component, e.ParseTree);`
`157`	`186`	`_state.AddTokenStream(component, e.Tokens);`
`158`	`187`	`_state.SetModuleComments(component, e.Comments);`
	`188`	`+ // This really needs to go last`
	`189`	`+ _state.SetModuleState(component, ParserState.Parsed);`
`159`	`190`	`};`
`160`	`191`	`_state.SetModuleState(component, ParserState.Parsing);`
`161`	`192`	`parser.Start(token);`
`@@ -219,7 +250,7 @@ private void ResolveDeclarations(VBComponent component, IParseTree tree)`
`219`	`250`	`_state.ArgListsWithOneByRefParam = argListWithOneByRefParamListener.Contexts.Select(context => new QualifiedContext(qualifiedModuleName, context));`
`220`	`251`	`_state.EmptyStringLiterals = emptyStringLiteralListener.Contexts.Select(context => new QualifiedContext(qualifiedModuleName, context));`
`221`	`252`	`_state.ObsoleteLetContexts = obsoleteLetStatementListener.Contexts.Select(context => new QualifiedContext(qualifiedModuleName, context));`
`222`		`- _state.ObsoleteCallContexts = obsoleteCallStatementListener.Contexts.Select(context => new QualifiedContext(qualifiedModuleName, context))`
	`253`	`+ _state.ObsoleteCallContexts = obsoleteCallStatementListener.Contexts.Select(context => new QualifiedContext(qualifiedModuleName, context));`
`223`	`254`	`}`
`224`	`255`
`225`	`256`	`private void ResolveReferences(DeclarationFinder finder, VBComponent component, IParseTree tree)`
`@@ -255,7 +286,7 @@ private void ResolveReferences(DeclarationFinder finder, VBComponent component,`
`255`	`286`	`}`
`256`	`287`
`257`	`288`	`#region Listener classes`
`258`		`- private class ObsoleteCallStatementListener : VBABaseListener`
	`289`	`+ private class ObsoleteCallStatementListener : VBAParserBaseListener`
`259`	`290`	`{`
`260`	`291`	`private readonly IList<VBAParser.ExplicitCallStmtContext> _contexts = new List<VBAParser.ExplicitCallStmtContext>();`
`261`	`292`	`public IEnumerable<VBAParser.ExplicitCallStmtContext> Contexts { get { return _contexts; } }`
`@@ -279,7 +310,7 @@ public override void ExitExplicitCallStmt(VBAParser.ExplicitCallStmtContext cont`
`279`	`310`	`}`
`280`	`311`	`}`
`281`	`312`
`282`		`- private class ObsoleteLetStatementListener : VBABaseListener`
	`313`	`+ private class ObsoleteLetStatementListener : VBAParserBaseListener`
`283`	`314`	`{`
`284`	`315`	`private readonly IList<VBAParser.LetStmtContext> _contexts = new List<VBAParser.LetStmtContext>();`
`285`	`316`	`public IEnumerable<VBAParser.LetStmtContext> Contexts { get { return _contexts; } }`
`@@ -293,7 +324,7 @@ public override void ExitLetStmt(VBAParser.LetStmtContext context)`
`293`	`324`	`}`
`294`	`325`	`}`
`295`	`326`
`296`		`- private class EmptyStringLiteralListener : VBABaseListener`
	`327`	`+ private class EmptyStringLiteralListener : VBAParserBaseListener`
`297`	`328`	`{`
`298`	`329`	`private readonly IList<VBAParser.LiteralContext> _contexts = new List<VBAParser.LiteralContext>();`
`299`	`330`	`public IEnumerable<VBAParser.LiteralContext> Contexts { get { return _contexts; } }`
`@@ -308,7 +339,7 @@ public override void ExitLiteral(VBAParser.LiteralContext context)`
`308`	`339`	`}`
`309`	`340`	`}`
`310`	`341`
`311`		`- private class ArgListWithOneByRefParamListener : VBABaseListener`
	`342`	`+ private class ArgListWithOneByRefParamListener : VBAParserBaseListener`
`312`	`343`	`{`
`313`	`344`	`private readonly IList<VBAParser.ArgListContext> _contexts = new List<VBAParser.ArgListContext>();`
`314`	`345`	`public IEnumerable<VBAParser.ArgListContext> Contexts { get { return _contexts; } }`
Original file line number	Diff line number	Diff line change
`@@ -69,14 +69,14 @@ public IReadOnlyList<Tuple<VBComponent, SyntaxErrorException>> ModuleExceptions`
`69`	`69`	`get { return _moduleExceptions.Select(kvp => Tuple.Create(kvp.Key, kvp.Value)).Where(item => item.Item2 != null).ToList(); }`
`70`	`70`	`}`
`71`	`71`
`72`		`- public event EventHandler StateChanged;`
	`72`	`+ public event EventHandler<ParserStateEventArgs> StateChanged;`
`73`	`73`
`74`		`- private void OnStateChanged()`
	`74`	`+ private void OnStateChanged(ParserState state = ParserState.Pending)`
`75`	`75`	`{`
`76`	`76`	`var handler = StateChanged;`
`77`	`77`	`if (handler != null)`
`78`	`78`	`{`
`79`		`- handler.Invoke(this, EventArgs.Empty);`
	`79`	`+ handler.Invoke(this, new ParserStateEventArgs(state));`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`	`public event EventHandler<ParseProgressEventArgs> ModuleStateChanged;`
`@@ -99,6 +99,8 @@ public void SetModuleState(VBComponent component, ParserState state, SyntaxError`
`99`	`99`	`Debug.WriteLine("Module '{0}' state is changing to '{1}' (thread {2})", component.Name, state, Thread.CurrentThread.ManagedThreadId);`
`100`	`100`	`OnModuleStateChanged(component, state);`
`101`	`101`	`Status = EvaluateParserState();`
	`102`	`+`
	`103`	`+ OnStateChanged(Status);`
`102`	`104`	`}`
`103`	`105`
`104`	`106`	`private ParserState EvaluateParserState()`
`@@ -128,7 +130,7 @@ private set`
`128`	`130`	`{`
`129`	`131`	`_status = value;`
`130`	`132`	`Debug.WriteLine("ParserState changed to '{0}', raising OnStateChanged", value);`
`131`		`- OnStateChanged();`
	`133`	`+ OnStateChanged(_status);`
`132`	`134`	`}`
`133`	`135`	`}`
`134`	`136`	`}`