Merge pull request #4918 from MDoerner/SpeedUpPArsing

retailcoder · web-flow · commit 63e529a2bd25 · 2019-04-15T07:48:12.000-04:00
Speed up parsing (slightly)
diff --git a/Rubberduck.CodeAnalysis/CodeMetrics/CodeMetricsAnalyst.cs b/Rubberduck.CodeAnalysis/CodeMetrics/CodeMetricsAnalyst.cs
@@ -1,5 +1,4 @@
 ﻿using Antlr4.Runtime.Tree;
-using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.VBEditor;
 using System.Collections.Generic;
@@ -14,11 +13,11 @@ public class CodeMetricsAnalyst : ICodeMetricsAnalyst
     {
         private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
 
-        private readonly CodeMetric[] metrics;
+        private readonly CodeMetric[] _metrics;
 
         public CodeMetricsAnalyst(IEnumerable<CodeMetric> supportedMetrics)
         {
-            metrics = supportedMetrics.ToArray();
+            _metrics = supportedMetrics.ToArray();
         }
 
         public IEnumerable<ICodeMetricResult> GetMetrics(RubberduckParserState state)
@@ -45,7 +44,7 @@ public IEnumerable<ICodeMetricResult> ModuleResults(QualifiedModuleName moduleNa
 
         private IEnumerable<ICodeMetricResult> TraverseModuleTree(IParseTree parseTree, DeclarationFinder declarationFinder, QualifiedModuleName moduleName)
         {
-            var listeners = metrics.Select(metric => metric.TreeListener).ToList();
+            var listeners = _metrics.Select(metric => metric.TreeListener).ToList();
             foreach (var l in listeners)
             {
                 l.Reset();
diff --git a/Rubberduck.CodeAnalysis/CodeMetrics/NestingLevelMetric.cs b/Rubberduck.CodeAnalysis/CodeMetrics/NestingLevelMetric.cs
@@ -1,12 +1,9 @@
 ﻿using Antlr4.Runtime.Misc;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Symbols;
-using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Rubberduck.CodeAnalysis.CodeMetrics
 {
diff --git a/Rubberduck.Core/CodeAnalysis/CodeMetrics/CodeMetricsViewModel.cs b/Rubberduck.Core/CodeAnalysis/CodeMetrics/CodeMetricsViewModel.cs
@@ -65,7 +65,8 @@ private void Synchronize(IEnumerable<Declaration> declarations)
             var metricResults = _analyst.GetMetrics(_state);
             _resultsByDeclaration = metricResults.GroupBy(r => r.Declaration).ToDictionary(g => g.Key, g => g.ToList());
 
-            _uiDispatcher.Invoke(() =>
+            //We have to wait for the task to guarantee that no new parse starts invalidating all cached components.
+            _uiDispatcher.StartTask(() =>
             {
                 var updates = declarations.ToList();
                 var existing = Projects.OfType<CodeExplorerProjectViewModel>().ToList();
@@ -86,7 +87,7 @@ private void Synchronize(IEnumerable<Declaration> declarations)
                     var model = new CodeExplorerProjectViewModel(project, ref updates, _state, _vbe, false);
                     Projects.Add(model);
                 }
-            });
+            }).Wait();
         }
 
         private ICodeExplorerNode _selectedItem;
diff --git a/Rubberduck.Core/Navigation/CodeExplorer/CodeExplorerViewModel.cs b/Rubberduck.Core/Navigation/CodeExplorer/CodeExplorerViewModel.cs
@@ -231,7 +231,8 @@ private void HandleStateChanged(object sender, ParserStateEventArgs e)
             if (e.State == ParserState.Ready)
             {
                 // Finished up resolving references, so we can now update the reference nodes.
-                _uiDispatcher.Invoke(() =>
+                //We have to wait for the task to guarantee that no new parse starts invalidating all cached components.
+                _uiDispatcher.StartTask(() =>
                 {
                     var referenceFolders = Projects.SelectMany(node =>
                         node.Children.OfType<CodeExplorerReferenceFolderViewModel>());
@@ -243,7 +244,7 @@ private void HandleStateChanged(object sender, ParserStateEventArgs e)
                     Unparsed = !Projects.Any();
                     IsBusy = false;
                     ParserReady = true;
-                });
+                }).Wait();
                 return;
             }
 
@@ -264,7 +265,8 @@ private void HandleStateChanged(object sender, ParserStateEventArgs e)
         /// </param>
         private void Synchronize(IEnumerable<Declaration> declarations)
         {
-            _uiDispatcher.Invoke(() =>
+            //We have to wait for the task to guarantee that no new parse starts invalidating all cached components.
+            _uiDispatcher.StartTask(() =>
             {
                 var updates = declarations.ToList();
                 var existing = Projects.OfType<CodeExplorerProjectViewModel>().ToList();
@@ -287,7 +289,7 @@ private void Synchronize(IEnumerable<Declaration> declarations)
                 }
 
                 CanSearch = Projects.Any();
-            });
+            }).Wait();
         }
 
         private void ParserState_ModuleStateChanged(object sender, ParseProgressEventArgs e)
diff --git a/Rubberduck.Parsing/Common/ParsingStageTimer.cs b/Rubberduck.Parsing/Common/ParsingStageTimer.cs
@@ -22,7 +22,7 @@ public static ParsingStageTimer StartNew()
 
         public void Log(string message)
         {
-            Logger.Debug(message, _stopwatch.ElapsedMilliseconds);
+            Logger.Info(message, _stopwatch.ElapsedMilliseconds);
         }
     }
 }
diff --git a/Rubberduck.Parsing/VBA/ParseCoordinator.cs b/Rubberduck.Parsing/VBA/ParseCoordinator.cs
@@ -436,7 +436,7 @@ private void ParseAll(object requestor)
                     ParsingSuspendLock.ExitReadLock();
                 }
             }
-            if (watch != null) Logger.Debug("Parsing run finished after {0}s. (thread {1}).", watch.Elapsed.TotalSeconds, Thread.CurrentThread.ManagedThreadId);
+            if (watch != null) Logger.Info("Parsing run finished after {0}s. (thread {1}).", watch.Elapsed.TotalSeconds, Thread.CurrentThread.ManagedThreadId);
         }
 
         protected void ParseAllInternal(object requestor, CancellationToken token)
diff --git a/Rubberduck.Parsing/VBA/Parsing/IModuleParser.cs b/Rubberduck.Parsing/VBA/Parsing/IModuleParser.cs
@@ -3,7 +3,6 @@
 using Antlr4.Runtime;
 using Antlr4.Runtime.Tree;
 using Rubberduck.Parsing.Annotations;
-using Rubberduck.Parsing.Rewriter;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.VBEditor;
 
diff --git a/Rubberduck.Parsing/VBA/Parsing/ParseRunner.cs b/Rubberduck.Parsing/VBA/Parsing/ParseRunner.cs
@@ -3,7 +3,6 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Rubberduck.Parsing.Common;
 using Rubberduck.VBEditor;
 
 namespace Rubberduck.Parsing.VBA.Parsing
@@ -21,26 +20,41 @@ public ParseRunner(
             parser)
         { }
 
-        public override void ParseModules(IReadOnlyCollection<QualifiedModuleName> modules, CancellationToken token)
+        protected override IReadOnlyCollection<(QualifiedModuleName module, ModuleParseResults results)> ModulePareResults(IReadOnlyCollection<QualifiedModuleName> modules, CancellationToken token)
         {
             if (!modules.Any())
             {
-                return;
+                return new List<(QualifiedModuleName module, ModuleParseResults results)>();
             }
 
             token.ThrowIfCancellationRequested();
 
-            var parsingStageTimer = ParsingStageTimer.StartNew();
+            var results = new List<(QualifiedModuleName module, ModuleParseResults results)>();
+            var lockObject = new object();
 
-            var options = new ParallelOptions();
-            options.CancellationToken = token;
-            options.MaxDegreeOfParallelism = _maxDegreeOfParserParallelism;
+            var options = new ParallelOptions
+            {
+                CancellationToken = token,
+                MaxDegreeOfParallelism = _maxDegreeOfParserParallelism
+            };
 
             try
             {
                 Parallel.ForEach(modules,
                     options,
-                    module => ParseModule(module, token)
+                    () => new List<(QualifiedModuleName module, ModuleParseResults results)>(), 
+                    (module, state, localList) =>
+                    {
+                        localList.Add((module, ModuleParseResults(module, token)));
+                        return localList;
+                    },
+                    (finalResult) =>
+                    {
+                        lock (lockObject)
+                        {
+                            results.AddRange(finalResult);
+                        }
+                    }
                 );
             }
             catch (AggregateException exception)
@@ -53,8 +67,7 @@ public override void ParseModules(IReadOnlyCollection<QualifiedModuleName> modul
                 throw;
             }
 
-            parsingStageTimer.Stop();
-            parsingStageTimer.Log("Parsed user modules in {0}ms.");
+            return results;
         }
     }
 }
diff --git a/Rubberduck.Parsing/VBA/Parsing/ParseRunnerBase.cs b/Rubberduck.Parsing/VBA/Parsing/ParseRunnerBase.cs
@@ -1,6 +1,7 @@
 ﻿using System;
 using System.Collections.Generic;
 using System.Threading;
+using Rubberduck.Parsing.Common;
 using Rubberduck.Parsing.VBA.Parsing.ParsingExceptions;
 using Rubberduck.VBEditor;
 
@@ -36,23 +37,32 @@ protected ParseRunnerBase(
             _parser = parser;
         }
 
+        public void ParseModules(IReadOnlyCollection<QualifiedModuleName> modules, CancellationToken token)
+        {
+            var parsingStageTimer = ParsingStageTimer.StartNew();
+
+            var parseResults = ModulePareResults(modules, token);
+            SaveModuleParseResultsOnState(parseResults, token);
 
-        public abstract void ParseModules(IReadOnlyCollection<QualifiedModuleName> modules, CancellationToken token);
+            parsingStageTimer.Stop();
+            parsingStageTimer.Log("Parsed user modules in {0}ms.");
+        }
 
+        protected abstract IReadOnlyCollection<(QualifiedModuleName module, ModuleParseResults results)> ModulePareResults(IReadOnlyCollection<QualifiedModuleName> modules, CancellationToken token);
 
-        protected void ParseModule(QualifiedModuleName module, CancellationToken token)
+        protected ModuleParseResults ModuleParseResults(QualifiedModuleName module, CancellationToken token)
         {
             _state.ClearStateCache(module);
             try
             {
-                var parseResults = _parser.Parse(module, token);
-                SaveModuleParseResultsOnState(module, parseResults, token);
+                return _parser.Parse(module, token);
             }
             catch (SyntaxErrorException syntaxErrorException)
             {
                 //In contrast to the situation in the success scenario, the overall parser state is reevaluated immediately.
-                //This sets the state directly on the state because it is the sole instance where we have to pass the SyntaxErorException.
+                //This sets the state directly on the state because it is the sole instance where we have to pass the SyntaxErrorException.
                 _state.SetModuleState(module, ParserState.Error, token, syntaxErrorException);
+                return default;
             }
             catch (Exception exception)
             {
@@ -61,30 +71,40 @@ protected void ParseModule(QualifiedModuleName module, CancellationToken token)
             }
         }
 
-        private void SaveModuleParseResultsOnState(QualifiedModuleName module, ModuleParseResults results, CancellationToken token)
+        private void SaveModuleParseResultsOnState(IReadOnlyCollection<(QualifiedModuleName module, ModuleParseResults results)> parseResults, CancellationToken token)
         {
-            lock (_state)
+            foreach (var (module, result) in parseResults)
             {
-                token.ThrowIfCancellationRequested();
+                if (result.CodePaneParseTree == null)
+                {
+                    continue;
+                }
 
-                //This has to come first because it creates the module state if not present.
-                _state.AddModuleStateIfNotPresent(module);
+                SaveModuleParseResultsOnState(module, result, token);
+            }
+        }
 
-                _state.SaveContentHash(module);
-                _state.AddParseTree(module, results.CodePaneParseTree);
-                _state.AddParseTree(module, results.AttributesParseTree, CodeKind.AttributesCode);
-                _state.SetModuleComments(module, results.Comments);
-                _state.SetModuleAnnotations(module, results.Annotations);
-                _state.SetModuleAttributes(module, results.Attributes);
-                _state.SetMembersAllowingAttributes(module, results.MembersAllowingAttributes);
-                _state.SetCodePaneTokenStream(module, results.CodePaneTokenStream);
-                _state.SetAttributesTokenStream(module, results.AttributesTokenStream);
+        private void SaveModuleParseResultsOnState(QualifiedModuleName module, ModuleParseResults results, CancellationToken token)
+        {
+            token.ThrowIfCancellationRequested();
 
-                // This really needs to go last
-                //It does not reevaluate the overall parer state to avoid concurrent evaluation of all module states and for performance reasons.
-                //The evaluation has to be triggered manually in the calling procedure.
-                StateManager.SetModuleState(module, ParserState.Parsed, token, false); //Note that this is ok because locks allow re-entrancy.
-            }
+            //This has to come first because it creates the module state if not present.
+            _state.AddModuleStateIfNotPresent(module);
+
+            _state.SaveContentHash(module);
+            _state.AddParseTree(module, results.CodePaneParseTree);
+            _state.AddParseTree(module, results.AttributesParseTree, CodeKind.AttributesCode);
+            _state.SetModuleComments(module, results.Comments);
+            _state.SetModuleAnnotations(module, results.Annotations);
+            _state.SetModuleAttributes(module, results.Attributes);
+            _state.SetMembersAllowingAttributes(module, results.MembersAllowingAttributes);
+            _state.SetCodePaneTokenStream(module, results.CodePaneTokenStream);
+            _state.SetAttributesTokenStream(module, results.AttributesTokenStream);
+
+            // This really needs to go last
+            //It does not reevaluate the overall parer state to avoid concurrent evaluation of all module states and for performance reasons.
+            //The evaluation has to be triggered manually in the calling procedure.
+            StateManager.SetModuleState(module, ParserState.Parsed, token,false); //Note that this is ok because locks allow re-entrancy.
         }
     }
 }
diff --git a/Rubberduck.Parsing/VBA/Parsing/SynchronousParseRunner.cs b/Rubberduck.Parsing/VBA/Parsing/SynchronousParseRunner.cs
@@ -18,20 +18,22 @@ public SynchronousParseRunner(
         { }
 
 
-        public override void ParseModules(IReadOnlyCollection<QualifiedModuleName> modules, CancellationToken token)
+        protected override IReadOnlyCollection<(QualifiedModuleName module, ModuleParseResults results)> ModulePareResults(IReadOnlyCollection<QualifiedModuleName> modules, CancellationToken token)
         {
             if (!modules.Any())
             {
-                return;
+                return new List<(QualifiedModuleName module, ModuleParseResults results)>();
             }
 
             token.ThrowIfCancellationRequested();
 
+            var results = new List<(QualifiedModuleName module, ModuleParseResults results)>();
+
             try
             {
                 foreach (var module in modules)
                 {
-                    ParseModule(module, token);
+                    results.Add((module, ModuleParseResults(module, token)));
                 }
             }
             catch (OperationCanceledException)
@@ -43,6 +45,8 @@ public override void ParseModules(IReadOnlyCollection<QualifiedModuleName> modul
                 StateManager.SetStatusAndFireStateChanged(this, ParserState.Error, token);
                 throw;
             }
+
+            return results;
         }
     }
 }
diff --git a/RubberduckTests/CodeExplorer/CodeExplorerViewModelTests.cs b/RubberduckTests/CodeExplorer/CodeExplorerViewModelTests.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using System.Windows.Forms;
 using NUnit.Framework;
 using Moq;
@@ -859,6 +860,7 @@ public void UnparsedSetToTrue_NoProjects()
             var dispatcher = new Mock<IUiDispatcher>();
 
             dispatcher.Setup(m => m.Invoke(It.IsAny<Action>())).Callback((Action argument) => argument.Invoke());
+            dispatcher.Setup(m => m.StartTask(It.IsAny<Action>(), It.IsAny<TaskCreationOptions>())).Returns((Action argument, TaskCreationOptions options) => Task.Factory.StartNew(argument.Invoke, options));
 
             var viewModel = new CodeExplorerViewModel(state, null, null, null, dispatcher.Object, vbe.Object, null, new CodeExplorerSyncProvider(vbe.Object, state));
 
diff --git a/RubberduckTests/CodeExplorer/MockedCodeExplorer.cs b/RubberduckTests/CodeExplorer/MockedCodeExplorer.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using System.Windows.Forms;
 using NUnit.Framework;
 using Moq;
@@ -49,6 +50,7 @@ public MockedCodeExplorer()
                 .Returns(new UnitTestSettings(BindingMode.LateBinding,AssertMode.StrictAssert, true, true, false));
 
             _uiDispatcher.Setup(m => m.Invoke(It.IsAny<Action>())).Callback((Action argument) => argument.Invoke());
+            _uiDispatcher.Setup(m => m.StartTask(It.IsAny<Action>(), It.IsAny<TaskCreationOptions>())).Returns((Action argument, TaskCreationOptions options) => Task.Factory.StartNew(argument.Invoke, options));
 
             SaveDialog = new Mock<ISaveFileDialog>();
             SaveDialog.Setup(o => o.OverwritePrompt);

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`using Antlr4.Runtime.Tree;`
`2`		`-using Rubberduck.Parsing.Symbols;`
`3`	`2`	`using Rubberduck.Parsing.VBA;`
`4`	`3`	`using Rubberduck.VBEditor;`
`5`	`4`	`using System.Collections.Generic;`
`@@ -14,11 +13,11 @@ public class CodeMetricsAnalyst : ICodeMetricsAnalyst`
`14`	`13`	`{`
`15`	`14`	`private static readonly Logger Logger = LogManager.GetCurrentClassLogger();`
`16`	`15`
`17`		`- private readonly CodeMetric[] metrics;`
	`16`	`+ private readonly CodeMetric[] _metrics;`
`18`	`17`
`19`	`18`	`public CodeMetricsAnalyst(IEnumerable<CodeMetric> supportedMetrics)`
`20`	`19`	`{`
`21`		`- metrics = supportedMetrics.ToArray();`
	`20`	`+ _metrics = supportedMetrics.ToArray();`
`22`	`21`	`}`
`23`	`22`
`24`	`23`	`public IEnumerable<ICodeMetricResult> GetMetrics(RubberduckParserState state)`
`@@ -45,7 +44,7 @@ public IEnumerable<ICodeMetricResult> ModuleResults(QualifiedModuleName moduleNa`
`45`	`44`
`46`	`45`	`private IEnumerable<ICodeMetricResult> TraverseModuleTree(IParseTree parseTree, DeclarationFinder declarationFinder, QualifiedModuleName moduleName)`
`47`	`46`	`{`
`48`		`- var listeners = metrics.Select(metric => metric.TreeListener).ToList();`
	`47`	`+ var listeners = _metrics.Select(metric => metric.TreeListener).ToList();`
`49`	`48`	`foreach (var l in listeners)`
`50`	`49`	`{`
`51`	`50`	`l.Reset();`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,8 @@ private void Synchronize(IEnumerable<Declaration> declarations)`
`65`	`65`	`var metricResults = _analyst.GetMetrics(_state);`
`66`	`66`	`_resultsByDeclaration = metricResults.GroupBy(r => r.Declaration).ToDictionary(g => g.Key, g => g.ToList());`
`67`	`67`
`68`		`- _uiDispatcher.Invoke(() =>`
	`68`	`+ //We have to wait for the task to guarantee that no new parse starts invalidating all cached components.`
	`69`	`+ _uiDispatcher.StartTask(() =>`
`69`	`70`	`{`
`70`	`71`	`var updates = declarations.ToList();`
`71`	`72`	`var existing = Projects.OfType<CodeExplorerProjectViewModel>().ToList();`
`@@ -86,7 +87,7 @@ private void Synchronize(IEnumerable<Declaration> declarations)`
`86`	`87`	`var model = new CodeExplorerProjectViewModel(project, ref updates, _state, _vbe, false);`
`87`	`88`	`Projects.Add(model);`
`88`	`89`	`}`
`89`		`- });`
	`90`	`+ }).Wait();`
`90`	`91`	`}`
`91`	`92`
`92`	`93`	`private ICodeExplorerNode _selectedItem;`
Original file line number	Diff line number	Diff line change
`@@ -231,7 +231,8 @@ private void HandleStateChanged(object sender, ParserStateEventArgs e)`
`231`	`231`	`if (e.State == ParserState.Ready)`
`232`	`232`	`{`
`233`	`233`	`// Finished up resolving references, so we can now update the reference nodes.`
`234`		`- _uiDispatcher.Invoke(() =>`
	`234`	`+ //We have to wait for the task to guarantee that no new parse starts invalidating all cached components.`
	`235`	`+ _uiDispatcher.StartTask(() =>`
`235`	`236`	`{`
`236`	`237`	`var referenceFolders = Projects.SelectMany(node =>`
`237`	`238`	`node.Children.OfType<CodeExplorerReferenceFolderViewModel>());`
`@@ -243,7 +244,7 @@ private void HandleStateChanged(object sender, ParserStateEventArgs e)`
`243`	`244`	`Unparsed = !Projects.Any();`
`244`	`245`	`IsBusy = false;`
`245`	`246`	`ParserReady = true;`
`246`		`- });`
	`247`	`+ }).Wait();`
`247`	`248`	`return;`
`248`	`249`	`}`
`249`	`250`
`@@ -264,7 +265,8 @@ private void HandleStateChanged(object sender, ParserStateEventArgs e)`
`264`	`265`	`/// </param>`
`265`	`266`	`private void Synchronize(IEnumerable<Declaration> declarations)`
`266`	`267`	`{`
`267`		`- _uiDispatcher.Invoke(() =>`
	`268`	`+ //We have to wait for the task to guarantee that no new parse starts invalidating all cached components.`
	`269`	`+ _uiDispatcher.StartTask(() =>`
`268`	`270`	`{`
`269`	`271`	`var updates = declarations.ToList();`
`270`	`272`	`var existing = Projects.OfType<CodeExplorerProjectViewModel>().ToList();`
`@@ -287,7 +289,7 @@ private void Synchronize(IEnumerable<Declaration> declarations)`
`287`	`289`	`}`
`288`	`290`
`289`	`291`	`CanSearch = Projects.Any();`
`290`		`- });`
	`292`	`+ }).Wait();`
`291`	`293`	`}`
`292`	`294`
`293`	`295`	`private void ParserState_ModuleStateChanged(object sender, ParseProgressEventArgs e)`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public static ParsingStageTimer StartNew()`
`22`	`22`
`23`	`23`	`public void Log(string message)`
`24`	`24`	`{`
`25`		`- Logger.Debug(message, _stopwatch.ElapsedMilliseconds);`
	`25`	`+ Logger.Info(message, _stopwatch.ElapsedMilliseconds);`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -436,7 +436,7 @@ private void ParseAll(object requestor)`
`436`	`436`	`ParsingSuspendLock.ExitReadLock();`
`437`	`437`	`}`
`438`	`438`	`}`
`439`		`- if (watch != null) Logger.Debug("Parsing run finished after {0}s. (thread {1}).", watch.Elapsed.TotalSeconds, Thread.CurrentThread.ManagedThreadId);`
	`439`	`+ if (watch != null) Logger.Info("Parsing run finished after {0}s. (thread {1}).", watch.Elapsed.TotalSeconds, Thread.CurrentThread.ManagedThreadId);`
`440`	`440`	`}`
`441`	`441`
`442`	`442`	`protected void ParseAllInternal(object requestor, CancellationToken token)`
Original file line number	Diff line number	Diff line change
`@@ -18,20 +18,22 @@ public SynchronousParseRunner(`
`18`	`18`	`{ }`
`19`	`19`
`20`	`20`
`21`		`- public override void ParseModules(IReadOnlyCollection<QualifiedModuleName> modules, CancellationToken token)`
	`21`	`+ protected override IReadOnlyCollection<(QualifiedModuleName module, ModuleParseResults results)> ModulePareResults(IReadOnlyCollection<QualifiedModuleName> modules, CancellationToken token)`
`22`	`22`	`{`
`23`	`23`	`if (!modules.Any())`
`24`	`24`	`{`
`25`		`- return;`
	`25`	`+ return new List<(QualifiedModuleName module, ModuleParseResults results)>();`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`token.ThrowIfCancellationRequested();`
`29`	`29`
	`30`	`+ var results = new List<(QualifiedModuleName module, ModuleParseResults results)>();`
	`31`	`+`
`30`	`32`	`try`
`31`	`33`	`{`
`32`	`34`	`foreach (var module in modules)`
`33`	`35`	`{`
`34`		`- ParseModule(module, token);`
	`36`	`+ results.Add((module, ModuleParseResults(module, token)));`
`35`	`37`	`}`
`36`	`38`	`}`
`37`	`39`	`catch (OperationCanceledException)`
`@@ -43,6 +45,8 @@ public override void ParseModules(IReadOnlyCollection<QualifiedModuleName> modul`
`43`	`45`	`StateManager.SetStatusAndFireStateChanged(this, ParserState.Error, token);`
`44`	`46`	`throw;`
`45`	`47`	`}`
	`48`	`+`
	`49`	`+ return results;`
`46`	`50`	`}`
`47`	`51`	`}`
`48`	`52`	`}`