Pass a CancellationToken on (module)state changed events.

MDoerner · MDoerner · commit 2b3f368b2c03 · 2018-02-28T01:28:33.000+01:00
diff --git a/Rubberduck.Parsing/IParseResultProvider.cs b/Rubberduck.Parsing/IParseResultProvider.cs
@@ -1,24 +1,23 @@
 ﻿using System;
+using System.Threading;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.VBEditor;
 
 namespace Rubberduck.Parsing
 {
     public class ParseProgressEventArgs : EventArgs
     {
-        private readonly QualifiedModuleName _module;
-        private readonly ParserState _state;
-        private readonly ParserState _oldState;
-
-        public ParseProgressEventArgs(QualifiedModuleName module, ParserState state, ParserState oldState)
+        public ParseProgressEventArgs(QualifiedModuleName module, ParserState state, ParserState oldState, CancellationToken token)
         {
-            _module = module;
-            _state = state;
-            _oldState = oldState;
+            Module = module;
+            State = state;
+            OldState = oldState;
+            Token = token;
         }
 
-        public QualifiedModuleName Module { get { return _module; } }
-        public ParserState State { get { return _state; } }
-        public ParserState OldState { get { return _oldState; } }
+        public QualifiedModuleName Module { get; }
+        public ParserState State { get; }
+        public ParserState OldState { get; }
+        public CancellationToken Token { get; }
     }
 }
diff --git a/Rubberduck.Parsing/VBA/ParserStateManagerBase.cs b/Rubberduck.Parsing/VBA/ParserStateManagerBase.cs
@@ -38,7 +38,7 @@ public ParserState GetModuleState(QualifiedModuleName module)
 
         public void EvaluateOverallParserState(CancellationToken token)
         {
-            _state.EvaluateParserState();
+            _state.EvaluateParserState(token);
         }
 
         public void SetModuleState(QualifiedModuleName module, ParserState parserState, CancellationToken token, bool evaluateOverallParserState = true)
@@ -48,7 +48,7 @@ public void SetModuleState(QualifiedModuleName module, ParserState parserState,
 
         public void SetStatusAndFireStateChanged(object requestor, ParserState status, CancellationToken token)
         {
-            _state.SetStatusAndFireStateChanged(requestor, status);
+            _state.SetStatusAndFireStateChanged(requestor, status, token);
         }
     }
 }
diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs
@@ -25,12 +25,14 @@ namespace Rubberduck.Parsing.VBA
 {
     public class ParserStateEventArgs : EventArgs
     {
-        public ParserStateEventArgs(ParserState state)
+        public ParserStateEventArgs(ParserState state, CancellationToken token)
         {
             State = state;
+            Token = token;
         }
 
         public ParserState State { get; }
+        public CancellationToken Token { get; }
     }
 
     public class RubberduckStatusMessageEventArgs : EventArgs
@@ -256,11 +258,11 @@ public void RefreshProjects()
             _projectRepository.Refresh();
         }
 
-        private void RefreshProject(string projectId, bool notifyStateChanged = false)
+        private void RefreshProject(string projectId)
         {
             _projectRepository.Refresh(projectId);
 
-            ClearStateCache(projectId, notifyStateChanged);
+            ClearStateCache(projectId);
         }
 
         public List<IVBProject> Projects => _projectRepository.Projects().Select(tpl => tpl.Project).ToList();
@@ -289,37 +291,44 @@ public IReadOnlyList<Tuple<QualifiedModuleName, SyntaxErrorException>> ModuleExc
         public event EventHandler<ParserStateEventArgs> StateChanged;
 
         private int _stateChangedInvocations;
-        private void OnStateChanged(object requestor, ParserState state = ParserState.Pending)
+        private void OnStateChanged(object requestor, CancellationToken token, ParserState state = ParserState.Pending)
         {
             Interlocked.Increment(ref _stateChangedInvocations);
 
             Logger.Info($"{nameof(RubberduckParserState)} ({_stateChangedInvocations}) is invoking {nameof(StateChanged)} ({Status})");
-            StateChanged?.Invoke(requestor, new ParserStateEventArgs(state));
+            var handler = StateChanged;
+            if (handler != null && !token.IsCancellationRequested)
+            {
+                var args = new ParserStateEventArgs(state, token);
+                handler.Invoke(requestor, args);
+            }
         }
 
         public event EventHandler<ParseProgressEventArgs> ModuleStateChanged;
 
         //Never spawn new threads changing module states in the handler! This will cause deadlocks. 
-        private void OnModuleStateChanged(QualifiedModuleName module, ParserState state, ParserState oldState)
+        private void OnModuleStateChanged(QualifiedModuleName module, ParserState state, ParserState oldState, CancellationToken token)
         {
             var handler = ModuleStateChanged;
-            if (handler != null)
+            if (handler != null && !token.IsCancellationRequested)
             {
-                var args = new ParseProgressEventArgs(module, state, oldState);
+                var args = new ParseProgressEventArgs(module, state, oldState, token);
                 handler.Invoke(this, args);
             }
         }
 
+        public void SetModuleState(QualifiedModuleName module, ParserState state, SyntaxErrorException parserError = null, bool evaluateOverallState = true)
+        {
+            SetModuleState(module, state, CancellationToken.None, parserError, evaluateOverallState);
+        }
+
         public void SetModuleState(QualifiedModuleName module, ParserState state, CancellationToken token, SyntaxErrorException parserError = null, bool evaluateOverallState = true)
         {
-            if (!token.IsCancellationRequested)
+            if (token.IsCancellationRequested)
             {
-                SetModuleState(module, state, parserError, evaluateOverallState);
+                return;
             }
-        }
 
-        public void SetModuleState(QualifiedModuleName module, ParserState state, SyntaxErrorException parserError = null, bool evaluateOverallState = true)
-        {
             if (AllUserDeclarations.Any())
             {
                 var projectId = module.ProjectId;
@@ -339,21 +348,30 @@ public void SetModuleState(QualifiedModuleName module, ParserState state, Syntax
             _moduleStates.AddOrUpdate(module, new ModuleState(state), (c, e) => e.SetState(state));
             _moduleStates.AddOrUpdate(module, new ModuleState(parserError), (c, e) => e.SetModuleException(parserError));
             Logger.Debug("Module '{0}' state is changing to '{1}' (thread {2})", module.ComponentName, state, Thread.CurrentThread.ManagedThreadId);
-            OnModuleStateChanged(module, state, oldState);
+            OnModuleStateChanged(module, state, oldState, token);
             if (evaluateOverallState)
             {
-                EvaluateParserState();
+                EvaluateParserState(token);
             }
         }
 
         private IVBProject GetProject(string projectId)
         {
             return _projectRepository.Project(projectId);
-                        }
+        }
 
         public void EvaluateParserState()
         {
-            lock (_statusLockObject) Status = OverallParserStateFromModuleStates();
+            EvaluateParserState(CancellationToken.None);
+        }
+
+        public void EvaluateParserState(CancellationToken token)
+        {
+            lock (_statusLockObject)
+            {
+                var newState = OverallParserStateFromModuleStates();
+                SetStatusWithCancellation(newState, token);
+            }
         }
 
         private ParserState OverallParserStateFromModuleStates()
@@ -489,26 +507,33 @@ public ParserState GetModuleState(QualifiedModuleName module)
         private ParserState _status;
         public ParserState Status
         {
-            get { return _status; }
-            private set
+            get => _status;
+            private set => SetStatusWithCancellation(value, CancellationToken.None);
+        }
+
+        private void SetStatusWithCancellation(ParserState value, CancellationToken token)
+        {
+            if (_status != value)
             {
-                if (_status != value)
-                {
-                    _status = value;
-                    OnStateChanged(this, _status);
-                }
+                _status = value;
+                OnStateChanged(this, token, _status);
             }
         }
 
         public void SetStatusAndFireStateChanged(object requestor, ParserState status)
+        {
+            SetStatusAndFireStateChanged(requestor, status, CancellationToken.None);
+        }
+
+        public void SetStatusAndFireStateChanged(object requestor, ParserState status, CancellationToken token)
         {
             if (Status == status)
             {
-                OnStateChanged(requestor, status);
+                OnStateChanged(requestor, token, status);
             }
             else
             {
-                Status = status;
+                SetStatusWithCancellation(status, token);
             }
         }
 
@@ -654,8 +679,7 @@ public void AddUnresolvedMemberDeclaration(UnboundMemberDeclaration declaration)
 
             if (declarations.ContainsKey(declaration))
             {
-                byte _;
-                while (!declarations.TryRemove(declaration, out _))
+                while (!declarations.TryRemove(declaration, out var _))
                 {
                     Logger.Warn("Could not remove existing unresolved member declaration for '{0}' ({1}). Retrying.", declaration.IdentifierName, declaration.DeclarationType);
                 }
@@ -666,7 +690,7 @@ public void AddUnresolvedMemberDeclaration(UnboundMemberDeclaration declaration)
             }
         }
 
-        public void ClearStateCache(string projectId, bool notifyStateChanged = false)
+        public void ClearStateCache(string projectId)
         {
             try
             {
@@ -696,16 +720,10 @@ public void ClearStateCache(string projectId, bool notifyStateChanged = false)
                 Logger.Error(exception, $"Unexpected COMException while clearing the project with projectId {projectId}. Clearing all modules.");
                 _moduleStates.Clear();
             }
-
-            if (notifyStateChanged)
-            {
-                OnStateChanged(this, ParserState.ResolvedDeclarations);   // trigger test explorer and code explorer updates
-                OnStateChanged(this, ParserState.Ready);   // trigger find all references &c. updates
-            }
         }
 
 
-        public bool ClearStateCache(QualifiedModuleName module, bool notifyStateChanged = false)
+        public bool ClearStateCache(QualifiedModuleName module)
         {
             var keys = new List<QualifiedModuleName> { module };
             foreach (var key in _moduleStates.Keys)
@@ -718,12 +736,6 @@ public bool ClearStateCache(QualifiedModuleName module, bool notifyStateChanged
 
             var success = RemoveKeysFromCollections(keys);
 
-            if (notifyStateChanged)
-            {
-                OnStateChanged(this, ParserState.ResolvedDeclarations);   // trigger test explorer and code explorer updates
-                OnStateChanged(this, ParserState.Ready);   // trigger find all references &c. updates
-            }
-
             return success;
         }
 

Original file line number	Diff line number	Diff line change
`@@ -1,24 +1,23 @@`
`1`	`1`	`using System;`
	`2`	`+using System.Threading;`
`2`	`3`	`using Rubberduck.Parsing.VBA;`
`3`	`4`	`using Rubberduck.VBEditor;`
`4`	`5`
`5`	`6`	`namespace Rubberduck.Parsing`
`6`	`7`	`{`
`7`	`8`	`public class ParseProgressEventArgs : EventArgs`
`8`	`9`	`{`
`9`		`- private readonly QualifiedModuleName _module;`
`10`		`- private readonly ParserState _state;`
`11`		`- private readonly ParserState _oldState;`
`12`		`-`
`13`		`- public ParseProgressEventArgs(QualifiedModuleName module, ParserState state, ParserState oldState)`
	`10`	`+ public ParseProgressEventArgs(QualifiedModuleName module, ParserState state, ParserState oldState, CancellationToken token)`
`14`	`11`	`{`
`15`		`- _module = module;`
`16`		`- _state = state;`
`17`		`- _oldState = oldState;`
	`12`	`+ Module = module;`
	`13`	`+ State = state;`
	`14`	`+ OldState = oldState;`
	`15`	`+ Token = token;`
`18`	`16`	`}`
`19`	`17`
`20`		`- public QualifiedModuleName Module { get { return _module; } }`
`21`		`- public ParserState State { get { return _state; } }`
`22`		`- public ParserState OldState { get { return _oldState; } }`
	`18`	`+ public QualifiedModuleName Module { get; }`
	`19`	`+ public ParserState State { get; }`
	`20`	`+ public ParserState OldState { get; }`
	`21`	`+ public CancellationToken Token { get; }`
`23`	`22`	`}`
`24`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public ParserState GetModuleState(QualifiedModuleName module)`
`38`	`38`
`39`	`39`	`public void EvaluateOverallParserState(CancellationToken token)`
`40`	`40`	`{`
`41`		`- _state.EvaluateParserState();`
	`41`	`+ _state.EvaluateParserState(token);`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`public void SetModuleState(QualifiedModuleName module, ParserState parserState, CancellationToken token, bool evaluateOverallParserState = true)`
`@@ -48,7 +48,7 @@ public void SetModuleState(QualifiedModuleName module, ParserState parserState,`
`48`	`48`
`49`	`49`	`public void SetStatusAndFireStateChanged(object requestor, ParserState status, CancellationToken token)`
`50`	`50`	`{`
`51`		`- _state.SetStatusAndFireStateChanged(requestor, status);`
	`51`	`+ _state.SetStatusAndFireStateChanged(requestor, status, token);`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,12 +25,14 @@ namespace Rubberduck.Parsing.VBA`
`25`	`25`	`{`
`26`	`26`	`public class ParserStateEventArgs : EventArgs`
`27`	`27`	`{`
`28`		`- public ParserStateEventArgs(ParserState state)`
	`28`	`+ public ParserStateEventArgs(ParserState state, CancellationToken token)`
`29`	`29`	`{`
`30`	`30`	`State = state;`
	`31`	`+ Token = token;`
`31`	`32`	`}`
`32`	`33`
`33`	`34`	`public ParserState State { get; }`
	`35`	`+ public CancellationToken Token { get; }`
`34`	`36`	`}`
`35`	`37`
`36`	`38`	`public class RubberduckStatusMessageEventArgs : EventArgs`
`@@ -256,11 +258,11 @@ public void RefreshProjects()`
`256`	`258`	`_projectRepository.Refresh();`
`257`	`259`	`}`
`258`	`260`
`259`		`- private void RefreshProject(string projectId, bool notifyStateChanged = false)`
	`261`	`+ private void RefreshProject(string projectId)`
`260`	`262`	`{`
`261`	`263`	`_projectRepository.Refresh(projectId);`
`262`	`264`
`263`		`- ClearStateCache(projectId, notifyStateChanged);`
	`265`	`+ ClearStateCache(projectId);`
`264`	`266`	`}`
`265`	`267`
`266`	`268`	`public List<IVBProject> Projects => _projectRepository.Projects().Select(tpl => tpl.Project).ToList();`
`@@ -289,37 +291,44 @@ public IReadOnlyList<Tuple<QualifiedModuleName, SyntaxErrorException>> ModuleExc`
`289`	`291`	`public event EventHandler<ParserStateEventArgs> StateChanged;`
`290`	`292`
`291`	`293`	`private int _stateChangedInvocations;`
`292`		`- private void OnStateChanged(object requestor, ParserState state = ParserState.Pending)`
	`294`	`+ private void OnStateChanged(object requestor, CancellationToken token, ParserState state = ParserState.Pending)`
`293`	`295`	`{`
`294`	`296`	`Interlocked.Increment(ref _stateChangedInvocations);`
`295`	`297`
`296`	`298`	`Logger.Info($"{nameof(RubberduckParserState)} ({_stateChangedInvocations}) is invoking {nameof(StateChanged)} ({Status})");`
`297`		`- StateChanged?.Invoke(requestor, new ParserStateEventArgs(state));`
	`299`	`+ var handler = StateChanged;`
	`300`	`+ if (handler != null && !token.IsCancellationRequested)`
	`301`	`+ {`
	`302`	`+ var args = new ParserStateEventArgs(state, token);`
	`303`	`+ handler.Invoke(requestor, args);`
	`304`	`+ }`
`298`	`305`	`}`
`299`	`306`
`300`	`307`	`public event EventHandler<ParseProgressEventArgs> ModuleStateChanged;`
`301`	`308`
`302`	`309`	`//Never spawn new threads changing module states in the handler! This will cause deadlocks.`
`303`		`- private void OnModuleStateChanged(QualifiedModuleName module, ParserState state, ParserState oldState)`
	`310`	`+ private void OnModuleStateChanged(QualifiedModuleName module, ParserState state, ParserState oldState, CancellationToken token)`
`304`	`311`	`{`
`305`	`312`	`var handler = ModuleStateChanged;`
`306`		`- if (handler != null)`
	`313`	`+ if (handler != null && !token.IsCancellationRequested)`
`307`	`314`	`{`
`308`		`- var args = new ParseProgressEventArgs(module, state, oldState);`
	`315`	`+ var args = new ParseProgressEventArgs(module, state, oldState, token);`
`309`	`316`	`handler.Invoke(this, args);`
`310`	`317`	`}`
`311`	`318`	`}`
`312`	`319`
	`320`	`+ public void SetModuleState(QualifiedModuleName module, ParserState state, SyntaxErrorException parserError = null, bool evaluateOverallState = true)`
	`321`	`+ {`
	`322`	`+ SetModuleState(module, state, CancellationToken.None, parserError, evaluateOverallState);`
	`323`	`+ }`
	`324`	`+`
`313`	`325`	`public void SetModuleState(QualifiedModuleName module, ParserState state, CancellationToken token, SyntaxErrorException parserError = null, bool evaluateOverallState = true)`
`314`	`326`	`{`
`315`		`- if (!token.IsCancellationRequested)`
	`327`	`+ if (token.IsCancellationRequested)`
`316`	`328`	`{`
`317`		`- SetModuleState(module, state, parserError, evaluateOverallState);`
	`329`	`+ return;`
`318`	`330`	`}`
`319`		`- }`
`320`	`331`
`321`		`- public void SetModuleState(QualifiedModuleName module, ParserState state, SyntaxErrorException parserError = null, bool evaluateOverallState = true)`
`322`		`- {`
`323`	`332`	`if (AllUserDeclarations.Any())`
`324`	`333`	`{`
`325`	`334`	`var projectId = module.ProjectId;`
`@@ -339,21 +348,30 @@ public void SetModuleState(QualifiedModuleName module, ParserState state, Syntax`
`339`	`348`	`_moduleStates.AddOrUpdate(module, new ModuleState(state), (c, e) => e.SetState(state));`
`340`	`349`	`_moduleStates.AddOrUpdate(module, new ModuleState(parserError), (c, e) => e.SetModuleException(parserError));`
`341`	`350`	`Logger.Debug("Module '{0}' state is changing to '{1}' (thread {2})", module.ComponentName, state, Thread.CurrentThread.ManagedThreadId);`
`342`		`- OnModuleStateChanged(module, state, oldState);`
	`351`	`+ OnModuleStateChanged(module, state, oldState, token);`
`343`	`352`	`if (evaluateOverallState)`
`344`	`353`	`{`
`345`		`- EvaluateParserState();`
	`354`	`+ EvaluateParserState(token);`
`346`	`355`	`}`
`347`	`356`	`}`
`348`	`357`
`349`	`358`	`private IVBProject GetProject(string projectId)`
`350`	`359`	`{`
`351`	`360`	`return _projectRepository.Project(projectId);`
`352`		`- }`
	`361`	`+ }`
`353`	`362`
`354`	`363`	`public void EvaluateParserState()`
`355`	`364`	`{`
`356`		`- lock (_statusLockObject) Status = OverallParserStateFromModuleStates();`
	`365`	`+ EvaluateParserState(CancellationToken.None);`
	`366`	`+ }`
	`367`	`+`
	`368`	`+ public void EvaluateParserState(CancellationToken token)`
	`369`	`+ {`
	`370`	`+ lock (_statusLockObject)`
	`371`	`+ {`
	`372`	`+ var newState = OverallParserStateFromModuleStates();`
	`373`	`+ SetStatusWithCancellation(newState, token);`
	`374`	`+ }`
`357`	`375`	`}`
`358`	`376`
`359`	`377`	`private ParserState OverallParserStateFromModuleStates()`
`@@ -489,26 +507,33 @@ public ParserState GetModuleState(QualifiedModuleName module)`
`489`	`507`	`private ParserState _status;`
`490`	`508`	`public ParserState Status`
`491`	`509`	`{`
`492`		`- get { return _status; }`
`493`		`- private set`
	`510`	`+ get => _status;`
	`511`	`+ private set => SetStatusWithCancellation(value, CancellationToken.None);`
	`512`	`+ }`
	`513`	`+`
	`514`	`+ private void SetStatusWithCancellation(ParserState value, CancellationToken token)`
	`515`	`+ {`
	`516`	`+ if (_status != value)`
`494`	`517`	`{`
`495`		`- if (_status != value)`
`496`		`- {`
`497`		`- _status = value;`
`498`		`- OnStateChanged(this, _status);`
`499`		`- }`
	`518`	`+ _status = value;`
	`519`	`+ OnStateChanged(this, token, _status);`
`500`	`520`	`}`
`501`	`521`	`}`
`502`	`522`
`503`	`523`	`public void SetStatusAndFireStateChanged(object requestor, ParserState status)`
	`524`	`+ {`
	`525`	`+ SetStatusAndFireStateChanged(requestor, status, CancellationToken.None);`
	`526`	`+ }`
	`527`	`+`
	`528`	`+ public void SetStatusAndFireStateChanged(object requestor, ParserState status, CancellationToken token)`
`504`	`529`	`{`
`505`	`530`	`if (Status == status)`
`506`	`531`	`{`
`507`		`- OnStateChanged(requestor, status);`
	`532`	`+ OnStateChanged(requestor, token, status);`
`508`	`533`	`}`
`509`	`534`	`else`
`510`	`535`	`{`
`511`		`- Status = status;`
	`536`	`+ SetStatusWithCancellation(status, token);`
`512`	`537`	`}`
`513`	`538`	`}`
`514`	`539`
`@@ -654,8 +679,7 @@ public void AddUnresolvedMemberDeclaration(UnboundMemberDeclaration declaration)`
`654`	`679`
`655`	`680`	`if (declarations.ContainsKey(declaration))`
`656`	`681`	`{`
`657`		`- byte _;`
`658`		`- while (!declarations.TryRemove(declaration, out _))`
	`682`	`+ while (!declarations.TryRemove(declaration, out var _))`
`659`	`683`	`{`
`660`	`684`	`Logger.Warn("Could not remove existing unresolved member declaration for '{0}' ({1}). Retrying.", declaration.IdentifierName, declaration.DeclarationType);`
`661`	`685`	`}`
`@@ -666,7 +690,7 @@ public void AddUnresolvedMemberDeclaration(UnboundMemberDeclaration declaration)`
`666`	`690`	`}`
`667`	`691`	`}`
`668`	`692`
`669`		`- public void ClearStateCache(string projectId, bool notifyStateChanged = false)`
	`693`	`+ public void ClearStateCache(string projectId)`
`670`	`694`	`{`
`671`	`695`	`try`
`672`	`696`	`{`
`@@ -696,16 +720,10 @@ public void ClearStateCache(string projectId, bool notifyStateChanged = false)`
`696`	`720`	`Logger.Error(exception, $"Unexpected COMException while clearing the project with projectId {projectId}. Clearing all modules.");`
`697`	`721`	`_moduleStates.Clear();`
`698`	`722`	`}`
`699`		`-`
`700`		`- if (notifyStateChanged)`
`701`		`- {`
`702`		`- OnStateChanged(this, ParserState.ResolvedDeclarations); // trigger test explorer and code explorer updates`
`703`		`- OnStateChanged(this, ParserState.Ready); // trigger find all references &c. updates`
`704`		`- }`
`705`	`723`	`}`
`706`	`724`
`707`	`725`
`708`		`- public bool ClearStateCache(QualifiedModuleName module, bool notifyStateChanged = false)`
	`726`	`+ public bool ClearStateCache(QualifiedModuleName module)`
`709`	`727`	`{`
`710`	`728`	`var keys = new List<QualifiedModuleName> { module };`
`711`	`729`	`foreach (var key in _moduleStates.Keys)`
`@@ -718,12 +736,6 @@ public bool ClearStateCache(QualifiedModuleName module, bool notifyStateChanged`
`718`	`736`
`719`	`737`	`var success = RemoveKeysFromCollections(keys);`
`720`	`738`
`721`		`- if (notifyStateChanged)`
`722`		`- {`
`723`		`- OnStateChanged(this, ParserState.ResolvedDeclarations); // trigger test explorer and code explorer updates`
`724`		`- OnStateChanged(this, ParserState.Ready); // trigger find all references &c. updates`
`725`		`- }`
`726`		`-`
`727`	`739`	`return success;`
`728`	`740`	`}`
`729`	`741`