Cancel inspections.

Author: MDoerner

RetailCoder.VBE/UI/Inspections/InspectionResultsViewModel.cs

@@ -102,7 +102,7 @@ private void _configService_SettingsChanged(object sender, ConfigurationChangedE
         {            
             if (e.InspectionSettingsChanged)
             {
-                RefreshInspections();
+                RefreshInspections(CancellationToken.None);
             }
             _runInspectionsOnReparse = e.RunInspectionsOnReparse;
         }
@@ -269,7 +269,7 @@ public bool IsBusy
         }
 
         private bool _runInspectionsOnReparse;
-        private void HandleStateChanged(object sender, EventArgs e)
+        private void HandleStateChanged(object sender, ParserStateEventArgs e)
         {
             if(!IsRefreshing && (_state.Status == ParserState.Pending || _state.Status == ParserState.Error || _state.Status == ParserState.ResolverError))
             {
@@ -284,16 +284,27 @@ private void HandleStateChanged(object sender, EventArgs e)
 
             if (_runInspectionsOnReparse || IsRefreshing)
             {
-                RefreshInspections();
+                RefreshInspections(e.Token);
             }
         }
 
-        private async void RefreshInspections()
+        private async void RefreshInspections(CancellationToken token)
         {
             var stopwatch = Stopwatch.StartNew();
             IsBusy = true;
 
-            var results = (await _inspector.FindIssuesAsync(_state, CancellationToken.None)).ToList();
+            List<IInspectionResult> results;
+            try
+            {
+                var inspectionResults = await _inspector.FindIssuesAsync(_state, token);
+                results = inspectionResults.ToList();
+            }
+            catch (OperationCanceledException)
+            {
+                Logger.Debug("Inspections got canceled.");
+                return; //We throw away the partial results.
+            }
+
             if (GroupByInspectionType)
             {
                 results = results.OrderBy(o => o.Inspection.InspectionType)

Rubberduck.Inspections/Inspector.cs

@@ -61,23 +61,27 @@ public async Task<IEnumerable<IInspectionResult>> FindIssuesAsync(RubberduckPars
                 {
                     return new IInspectionResult[] { };
                 }
+                token.ThrowIfCancellationRequested();
 
                 state.OnStatusMessageUpdate(RubberduckUI.CodeInspections_Inspecting);
                 var allIssues = new ConcurrentBag<IInspectionResult>();
+                token.ThrowIfCancellationRequested();
 
                 var config = _configService.LoadConfiguration();
                 UpdateInspectionSeverity(config);
+                token.ThrowIfCancellationRequested();
 
                 var parseTreeInspections = _inspections
                     .Where(inspection => inspection.Severity != CodeInspectionSeverity.DoNotShow)
                     .OfType<IParseTreeInspection>()
                     .ToArray();
+                token.ThrowIfCancellationRequested();
 
-                foreach(var listener in parseTreeInspections.Select(inspection => inspection.Listener))
+                foreach (var listener in parseTreeInspections.Select(inspection => inspection.Listener))
                 {
                     listener.ClearContexts();
                 }
-                
+
                 // Prepare ParseTreeWalker based inspections
                 var passes = Enum.GetValues(typeof (ParsePass)).Cast<ParsePass>();
                 foreach (var parsePass in passes)
@@ -91,8 +95,10 @@ public async Task<IEnumerable<IInspectionResult>> FindIssuesAsync(RubberduckPars
                         LogManager.GetCurrentClassLogger().Warn(e);
                     }
                 }
+                token.ThrowIfCancellationRequested();
 
                 var inspectionsToRun = _inspections.Where(inspection => inspection.Severity != CodeInspectionSeverity.DoNotShow);
+                token.ThrowIfCancellationRequested();
 
                 try
                 {
@@ -102,13 +108,18 @@ public async Task<IEnumerable<IInspectionResult>> FindIssuesAsync(RubberduckPars
                 {
                     if (exception.Flatten().InnerExceptions.All(ex => ex is OperationCanceledException))
                     {
-                        LogManager.GetCurrentClassLogger().Debug("Inspections got canceled.");
+                        //This eliminates the stack trace, but for the cancellation, this is irrelevant.
+                        throw exception.InnerException ?? exception;
                     }
                     else
                     {
                         LogManager.GetCurrentClassLogger().Error(exception);
                     }
                 }
+                catch (OperationCanceledException)
+                {
+                    throw;
+                }
                 catch (Exception e)
                 {
                     LogManager.GetCurrentClassLogger().Error(e);
@@ -137,21 +148,27 @@ private static void RunInspectionsInParallel(IEnumerable<IInspection> inspection
 
                 Parallel.ForEach(inspectionsToRun,
                     options,
-                    inspection => RunInspection(inspection, allIssues)
+                    inspection => RunInspection(inspection, allIssues, token)
                 );
             }
 
-            private static void RunInspection(IInspection inspection, ConcurrentBag<IInspectionResult> allIssues)
+            private static void RunInspection(IInspection inspection, ConcurrentBag<IInspectionResult> allIssues, CancellationToken token)
             {
                 try
                 {
                     var inspectionResults = inspection.GetInspectionResults();
 
+                    token.ThrowIfCancellationRequested();
+
                     foreach (var inspectionResult in inspectionResults)
                     {
                         allIssues.Add(inspectionResult);
                     }
                 }
+                catch (OperationCanceledException)
+                {
+                    throw;
+                }
                 catch (Exception e)
                 {
                     LogManager.GetCurrentClassLogger().Warn(e);