Propagate progress and errors better

Author: GrahamTheCoder

ICSharpCode.CodeConverter/Shared/ProjectConversion.cs

@@ -36,7 +36,7 @@ private ProjectConversion(IProjectContentsConverter projectContentsConverter, IE
             _returnSelectedNode = returnSelectedNode;
         }
 
-        public static async Task<ConversionResult> ConvertText<TLanguageConversion>(string text, TextConversionOptions conversionOptions) where TLanguageConversion : ILanguageConversion, new()
+        public static async Task<ConversionResult> ConvertText<TLanguageConversion>(string text, TextConversionOptions conversionOptions, IProgress<ConversionProgress> progress = null) where TLanguageConversion : ILanguageConversion, new()
         {
             await new SynchronizationContextRemover();
 
@@ -45,11 +45,11 @@ private ProjectConversion(IProjectContentsConverter projectContentsConverter, IE
             if (textSpan.HasValue) conversionOptions.SelectedTextSpan = textSpan.Value;
             using (var workspace = new AdhocWorkspace()) {
                 var document = languageConversion.CreateProjectDocumentFromTree(workspace, syntaxTree, conversionOptions.References);
-                return await ConvertSingle<TLanguageConversion>(document, conversionOptions);
+                return await ConvertSingle<TLanguageConversion>(document, conversionOptions, progress);
             }
         }
 
-        public static async Task<ConversionResult> ConvertSingle<TLanguageConversion>(Document document, SingleConversionOptions conversionOptions) where TLanguageConversion : ILanguageConversion, new()
+        public static async Task<ConversionResult> ConvertSingle<TLanguageConversion>(Document document, SingleConversionOptions conversionOptions, IProgress<ConversionProgress> progress = null) where TLanguageConversion : ILanguageConversion, new()
         {
             await new SynchronizationContextRemover();
 
@@ -65,7 +65,7 @@ private ProjectConversion(IProjectContentsConverter projectContentsConverter, IE
             document = projectContentsConverter.Project.GetDocument(document.Id);
 
             var conversion = new ProjectConversion(projectContentsConverter, new[] { document }, languageConversion, returnSelectedNode);
-            var conversionResults = (await ConvertProjectContents(conversion, new Progress<ConversionProgress>())).ToList();
+            var conversionResults = (await ConvertProjectContents(conversion, progress ?? new Progress<ConversionProgress>())).ToList();
             var codeResult = conversionResults.SingleOrDefault(x => !string.IsNullOrWhiteSpace(x.ConvertedCode))
                              ?? conversionResults.First();
             codeResult.Exceptions = conversionResults.SelectMany(x => x.Exceptions).ToArray();
@@ -207,7 +207,7 @@ private static Action<Exception> ExchangeFatalErrorHandler(Action<Exception> err
             if (firstPassResult.document != null) {
                 progress.Report(firstPassResult.Path);
                 var (convertedNode, errors) = await SingleSecondPassHandled(firstPassResult.document);
-                return (firstPassResult.Path, convertedNode, firstPassResult.Errors.Concat(errors).ToArray());
+                return (firstPassResult.Path, convertedNode, firstPassResult.Errors.Concat(errors).Union(GetErrorsFromAnnotations(convertedNode)).ToArray());
             }
 
             return (firstPassResult.Path, null, firstPassResult.Errors);
@@ -236,7 +236,8 @@ private static Action<Exception> ExchangeFatalErrorHandler(Action<Exception> err
                 errors = new[] {e.ToString()};
             }
 
-            return (selectedNode ?? await convertedDocument.GetSyntaxRootAsync(), errors);
+            var convertedNode = selectedNode ?? await convertedDocument.GetSyntaxRootAsync();
+            return (convertedNode, errors);
         }
 
         private async Task<string> GetProjectWarnings(Project source, (string Path, SyntaxNode Node, string[] Errors)[] converted)
@@ -254,17 +255,22 @@ private async Task<string> GetProjectWarnings(Project source, (string Path, Synt
             progress.Report(treeFilePath);
             try {
                 var convertedNode = await _projectContentsConverter.SingleFirstPass(document);
-                var errorAnnotations = convertedNode.GetAnnotations(AnnotationConstants.ConversionErrorAnnotationKind).ToList();
-                string[] errors = errorAnnotations.Select(a => a.Data).ToArray();
+                string[] errors = GetErrorsFromAnnotations(convertedNode);
 
                 return (treeFilePath, convertedNode, errors);
-            }
-            catch (Exception e)
+            } catch (Exception e)
             {
                 return (treeFilePath, null, new[]{e.ToString()});
             }
         }
 
+        private static string[] GetErrorsFromAnnotations(SyntaxNode convertedNode)
+        {
+            var errorAnnotations = convertedNode.GetAnnotations(AnnotationConstants.ConversionErrorAnnotationKind).ToList();
+            string[] errors = errorAnnotations.Select(a => a.Data).ToArray();
+            return errors;
+        }
+
         private static async Task<Document> WithAnnotatedSelection(Document document, TextSpan selected)
         {
             var root = await document.GetSyntaxRootAsync();

Vsix/CodeConversion.cs

@@ -230,10 +230,10 @@ private async Task<string> GetConversionSummaryAsync(IReadOnlyCollection<string>
             }
             var document = _visualStudioWorkspace.CurrentSolution.GetDocument(documentId);
             var selectedTextSpan = new TextSpan(selected.Start, selected.Length);
-            return await ProjectConversion.ConvertSingle<TLanguageConversion>(document, new SingleConversionOptions {SelectedTextSpan = selectedTextSpan});
+            return await ProjectConversion.ConvertSingle<TLanguageConversion>(document, new SingleConversionOptions {SelectedTextSpan = selectedTextSpan}, CreateOutputWindowProgress());
         }
 
-        private static async Task<ConversionResult> ConvertTextOnlyAsync<TLanguageConversion>(string documentPath, Span selected)
+        private async Task<ConversionResult> ConvertTextOnlyAsync<TLanguageConversion>(string documentPath, Span selected)
             where TLanguageConversion : ILanguageConversion, new()
         {
             var documentText = File.ReadAllText(documentPath);
@@ -242,7 +242,7 @@ private static async Task<ConversionResult> ConvertTextOnlyAsync<TLanguageConver
                 documentText = documentText.Substring(selected.Start, selected.Length);
             }
 
-            var convertTextOnly = await ProjectConversion.ConvertText<TLanguageConversion>(documentText, new TextConversionOptions(DefaultReferences.NetStandard2));
+            var convertTextOnly = await ProjectConversion.ConvertText<TLanguageConversion>(documentText, new TextConversionOptions(DefaultReferences.NetStandard2), CreateOutputWindowProgress());
             convertTextOnly.SourcePathOrNull = documentPath;
             return convertTextOnly;
         }
@@ -263,13 +263,18 @@ private async Task<IEnumerable<ConversionResult>> ConvertProjectUnhandledAsync<T
 #pragma warning restore VSTHRD010 // Invoke single-threaded types on Main thread
             await TaskScheduler.Default;
 
-            var solutionConverter = SolutionConverter.CreateFor<TLanguageConversion>(projects, progress: new Progress<ConversionProgress>(s => {
-                _outputWindow.WriteToOutputWindowAsync(FormatForOutputWindow(s)).ForgetNoThrow();
-            }));
+            var solutionConverter = SolutionConverter.CreateFor<TLanguageConversion>(projects, progress: CreateOutputWindowProgress());
 
             return await solutionConverter.Convert();
         }
 
+        private Progress<ConversionProgress> CreateOutputWindowProgress()
+        {
+            return new Progress<ConversionProgress>(s => {
+                _outputWindow.WriteToOutputWindowAsync(FormatForOutputWindow(s)).ForgetNoThrow();
+            });
+        }
+
         private static string FormatForOutputWindow(ConversionProgress s)
         {
             string preMessage = Environment.NewLine;