Rename to add async suffix to async methods

Author: GrahamTheCoder

CodeConverter/CSharp/ProjectMergedDeclarationExtensions.cs

@@ -63,7 +63,7 @@ public static async Task<Project> WithRenamedMergedMyNamespaceAsync(this Project
         var projectDir = Path.Combine(vbProject.GetDirectoryPath(), "My Project");
 
         var compilation = await vbProject.GetCompilationAsync(cancellationToken);
-        var embeddedSourceTexts = await GetAllEmbeddedSourceText(compilation).Select((r, i) => (Text: r, Suffix: $".Static.{i+1}")).ToArrayAsync(cancellationToken);
+        var embeddedSourceTexts = await GetAllEmbeddedSourceTextAsync(compilation).Select((r, i) => (Text: r, Suffix: $".Static.{i+1}")).ToArrayAsync(cancellationToken);
         var generatedSourceTexts = (Text: await GetDynamicallyGeneratedSourceTextAsync(compilation), Suffix: ".Dynamic").Yield();
 
         foreach (var (text, suffix) in embeddedSourceTexts.Concat(generatedSourceTexts)) {
@@ -79,7 +79,7 @@ private static Project WithRenamespacedDocument(string baseName, Project vbProje
         return vbProject.AddDocument(baseName, sourceText.ReNamespace(), filePath: Path.Combine(myProjectDirPath, baseName + ".Designer.vb")).Project;
     }
 
-    private static async IAsyncEnumerable<string> GetAllEmbeddedSourceText(Compilation compilation)
+    private static async IAsyncEnumerable<string> GetAllEmbeddedSourceTextAsync(Compilation compilation)
     {
         var roots = await compilation.SourceModule.GlobalNamespace.Locations.
             Where(l => !l.IsInSource).Select(CachedReflectedDelegates.GetEmbeddedSyntaxTree)

CodeConverter/CSharp/VBToCSProjectContentsConverter.cs

@@ -95,7 +95,7 @@ private static string GetPathRelativeToProject(string projDirPath, string p)
         return p.Replace(projDirPath, "").TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
     }
 
-    public async IAsyncEnumerable<ConversionResult> GetAdditionalConversionResults(IReadOnlyCollection<TextDocument> additionalDocumentsToConvert, [EnumeratorCancellation] CancellationToken cancellationToken)
+    public async IAsyncEnumerable<ConversionResult> GetAdditionalConversionResultsAsync(IReadOnlyCollection<TextDocument> additionalDocumentsToConvert, [EnumeratorCancellation] CancellationToken cancellationToken)
     {
         string projDirPath = SourceProject.GetDirectoryPath();
         foreach (var doc in additionalDocumentsToConvert) {

CodeConverter/Common/AsyncEnumerableTaskExtensions.cs

@@ -18,7 +18,7 @@ public static async Task<TResult[]> SelectManyAsync<TArg, TResult>(this IEnumera
     /// <remarks>
     /// Inspired by https://stackoverflow.com/a/58564740/1128762
     /// </remarks>
-    public static async IAsyncEnumerable<TResult> ParallelSelectAwait<TArg, TResult>(this IEnumerable<TArg> source,
+    public static async IAsyncEnumerable<TResult> ParallelSelectAwaitAsync<TArg, TResult>(this IEnumerable<TArg> source,
         Func<TArg, Task<TResult>> selector, int maxDop, [EnumeratorCancellation] CancellationToken token = default)
     {
         var processor = new TransformBlock<TArg, TResult>(selector, new ExecutionDataflowBlockOptions {

CodeConverter/Common/IProjectContentsConverter.cs

@@ -9,5 +9,5 @@ public interface IProjectContentsConverter
     OptionalOperations OptionalOperations { get; }
     Task<SyntaxNode> SingleFirstPassAsync(Document document);
     Task<(Project project, List<WipFileConversion<DocumentId>> firstPassDocIds)> GetConvertedProjectAsync(WipFileConversion<SyntaxNode>[] firstPassResults);
-    public IAsyncEnumerable<ConversionResult> GetAdditionalConversionResults(IReadOnlyCollection<TextDocument> additionalDocumentsToConvert, CancellationToken cancellationToken);
+    public IAsyncEnumerable<ConversionResult> GetAdditionalConversionResultsAsync(IReadOnlyCollection<TextDocument> additionalDocumentsToConvert, CancellationToken cancellationToken);
 }

CodeConverter/Common/ProjectConversion.cs

@@ -71,10 +71,10 @@ public static async IAsyncEnumerable<ConversionResult> ConvertDocumentsAsync<TLa
         documents = documents.Select(doc => projectContentsConverter.SourceProject.GetDocument(doc.Id)).ToList();
 
         var conversion = new ProjectConversion(projectContentsConverter, documents, Enumerable.Empty<TextDocument>(), languageConversion, cancellationToken);
-        await foreach (var result in conversion.Convert(progress).WithCancellation(cancellationToken)) yield return result;
+        await foreach (var result in conversion.ConvertAsync(progress).WithCancellation(cancellationToken)) yield return result;
     }
 
-    public static async IAsyncEnumerable<ConversionResult> ConvertProject(Project project,
+    public static async IAsyncEnumerable<ConversionResult> ConvertProjectAsync(Project project,
         ILanguageConversion languageConversion, TextReplacementConverter textReplacementConverter,
         IProgress<ConversionProgress> progress,
         [EnumeratorCancellation] CancellationToken cancellationToken,
@@ -83,16 +83,16 @@ public static async IAsyncEnumerable<ConversionResult> ConvertProject(Project pr
         using var roslynEntryPoint = await RoslynEntryPointAsync(progress ??= new Progress<ConversionProgress>());
         var projectContentsConverter = await languageConversion.CreateProjectContentsConverterAsync(project, progress, cancellationToken);
         var sourceFilePaths = project.Documents.Concat(projectContentsConverter.SourceProject.AdditionalDocuments).Select(d => d.FilePath).ToImmutableHashSet();
-        var convertProjectContents = ConvertProjectContents(projectContentsConverter, languageConversion, progress, cancellationToken);
+        var convertProjectContents = ConvertProjectContentsAsync(projectContentsConverter, languageConversion, progress, cancellationToken);
 
-        var results = WithProjectFile(projectContentsConverter, textReplacementConverter, languageConversion, sourceFilePaths, convertProjectContents, replacements);
+        var results = WithProjectFileAsync(projectContentsConverter, textReplacementConverter, languageConversion, sourceFilePaths, convertProjectContents, replacements);
         await foreach (var result in results.WithCancellation(cancellationToken)) yield return result;
 
         progress.Report(new ConversionProgress($"Finished converting {project.Name} at {DateTime.Now:HH:mm:ss}..."));
     }
 
     /// <remarks>Perf: Keep lazy so that we don't keep an extra copy of all files in memory at once</remarks>
-    private static async IAsyncEnumerable<ConversionResult> WithProjectFile(IProjectContentsConverter projectContentsConverter, TextReplacementConverter textReplacementConverter,
+    private static async IAsyncEnumerable<ConversionResult> WithProjectFileAsync(IProjectContentsConverter projectContentsConverter, TextReplacementConverter textReplacementConverter,
         ILanguageConversion languageConversion, ImmutableHashSet<string> originalSourcePaths,
         IAsyncEnumerable<ConversionResult> convertProjectContents, (string Find, string Replace, bool FirstOnly)[] replacements)
     {
@@ -158,7 +158,7 @@ private static (string Find, string Replace, bool FirstOnly) AddCompiledItemsReg
     }
 
 
-    private static async IAsyncEnumerable<ConversionResult> ConvertProjectContents(
+    private static async IAsyncEnumerable<ConversionResult> ConvertProjectContentsAsync(
         IProjectContentsConverter projectContentsConverter, ILanguageConversion languageConversion,
         IProgress<ConversionProgress> progress, [EnumeratorCancellation] CancellationToken cancellationToken)
     {
@@ -171,15 +171,15 @@ private static async IAsyncEnumerable<ConversionResult> ConvertProjectContents(
 
         var projectConversion = new ProjectConversion(projectContentsConverter, documentsToConvert, projectContentsConverter.SourceProject.AdditionalDocuments, languageConversion, cancellationToken);
 
-        var results = projectConversion.Convert(progress);
+        var results = projectConversion.ConvertAsync(progress);
         await foreach (var result in results.WithCancellation(cancellationToken)) yield return result;
     }
 
 
-    private async IAsyncEnumerable<ConversionResult> Convert(IProgress<ConversionProgress> progress)
+    private async IAsyncEnumerable<ConversionResult> ConvertAsync(IProgress<ConversionProgress> progress)
     {
         var phaseProgress = StartPhase(progress, "Phase 1 of 2:");
-        var firstPassResults = _documentsToConvert.ParallelSelectAwait(d => FirstPassLoggedAsync(d, phaseProgress), Env.MaxDop, _cancellationToken);
+        var firstPassResults = _documentsToConvert.ParallelSelectAwaitAsync(d => FirstPassLoggedAsync(d, phaseProgress), Env.MaxDop, _cancellationToken);
         var (proj1, docs1) = await _projectContentsConverter.GetConvertedProjectAsync(await firstPassResults.ToArrayAsync(_cancellationToken));
 
         var warnings = await GetProjectWarningsAsync(_projectContentsConverter.SourceProject, proj1);
@@ -189,11 +189,11 @@ private async IAsyncEnumerable<ConversionResult> Convert(IProgress<ConversionPro
         }
 
         phaseProgress = StartPhase(progress, "Phase 2 of 2:");
-        var secondPassResults = proj1.GetDocuments(docs1).ParallelSelectAwait(d => SecondPassLoggedAsync(d, phaseProgress), Env.MaxDop, _cancellationToken);
+        var secondPassResults = proj1.GetDocuments(docs1).ParallelSelectAwaitAsync(d => SecondPassLoggedAsync(d, phaseProgress), Env.MaxDop, _cancellationToken);
         await foreach (var result in secondPassResults.Select(CreateConversionResult).WithCancellation(_cancellationToken)) {
             yield return result;
         }
-        await foreach (var result in _projectContentsConverter.GetAdditionalConversionResults(_additionalDocumentsToConvert, _cancellationToken)) {
+        await foreach (var result in _projectContentsConverter.GetAdditionalConversionResultsAsync(_additionalDocumentsToConvert, _cancellationToken)) {
             yield return result;
         }
     }

CodeConverter/Common/SolutionConverter.cs

@@ -69,7 +69,7 @@ private SolutionConverter(string solutionFilePath,
         _textReplacementConverter = new TextReplacementConverter(fileSystem);
     }
 
-    public async IAsyncEnumerable<ConversionResult> Convert()
+    public async IAsyncEnumerable<ConversionResult> ConvertAsync()
     {
         var projectsToUpdateReferencesOnly = _projectsToConvert.First().Solution.Projects.Except(_projectsToConvert);
         var solutionResult = string.IsNullOrWhiteSpace(_sourceSolutionContents) ? Enumerable.Empty<ConversionResult>() : ConvertSolutionFile().Yield();
@@ -82,14 +82,14 @@ public async IAsyncEnumerable<ConversionResult> Convert()
 
     private async Task<IAsyncEnumerable<ConversionResult>> ConvertProjectsAsync()
     {
-        return _projectsToConvert.ToAsyncEnumerable().SelectMany(ConvertProject);
+        return _projectsToConvert.ToAsyncEnumerable().SelectMany(ConvertProjectAsync);
     }
 
-    private IAsyncEnumerable<ConversionResult> ConvertProject(Project project)
+    private IAsyncEnumerable<ConversionResult> ConvertProjectAsync(Project project)
     {
         var replacements = _projectReferenceReplacements.ToArray();
         _progress.Report(new ConversionProgress($"Begin converting {project.Name} at {DateTime.Now:HH:mm:ss}..."));
-        return ProjectConversion.ConvertProject(project, _languageConversion, _textReplacementConverter, _progress, _cancellationToken, replacements);
+        return ProjectConversion.ConvertProjectAsync(project, _languageConversion, _textReplacementConverter, _progress, _cancellationToken, replacements);
     }
 
     private IEnumerable<ConversionResult> UpdateProjectReferences(IEnumerable<Project> projectsToUpdateReferencesOnly)

CodeConverter/VB/CSToVBProjectContentsConverter.cs

@@ -67,7 +67,7 @@ public async Task<SyntaxNode> SingleFirstPassAsync(Document document)
         return _convertedVbProject.WithDocuments(firstPassResults);
     }
 
-    public async IAsyncEnumerable<ConversionResult> GetAdditionalConversionResults(IReadOnlyCollection<TextDocument> additionalDocumentsToConvert, [EnumeratorCancellation] CancellationToken cancellationToken)
+    public async IAsyncEnumerable<ConversionResult> GetAdditionalConversionResultsAsync(IReadOnlyCollection<TextDocument> additionalDocumentsToConvert, [EnumeratorCancellation] CancellationToken cancellationToken)
     {
         yield break;
     }

CommandLine/CodeConv.Shared/MSBuildWorkspaceConverter.cs

@@ -63,7 +63,7 @@ public async IAsyncEnumerable<ConversionResult> ConvertProjectsWhereAsync(Func<P
             : LanguageNames.CSharp;
 
         var projectsToConvert = solution.Projects.Where(p => p.Language == languageNameToConvert && shouldConvertProject(p)).ToArray();
-        var results = SolutionConverter.CreateFor(languageConversion, projectsToConvert, progress, token).Convert();
+        var results = SolutionConverter.CreateFor(languageConversion, projectsToConvert, progress, token).ConvertAsync();
         await foreach (var r in results.WithCancellation(token)) yield return r;
     }
 
@@ -98,7 +98,7 @@ private async Task<string> GetCompilationErrorsAsync(
         IEnumerable<Project> projectsToConvert)
     {
         var workspaceErrors = (await _workspace.GetValueAsync()).Diagnostics.GetErrorString();
-        var errors = await projectsToConvert.ParallelSelectAwait(async x => {
+        var errors = await projectsToConvert.ParallelSelectAwaitAsync(async x => {
             var c = await x.GetCompilationAsync() ?? throw new InvalidOperationException($"Compilation could not be created for {x.Language}");
             return new[] { CompilationWarnings.WarningsForCompilation(c, c.AssemblyName) };
         }, Env.MaxDop).ToArrayAsync();

Tests/LanguageAgnostic/ParallelSelectAwaitTests.cs

@@ -14,7 +14,7 @@ public class ParallelSelectAwaitTests
     [Fact]
     public async Task ExceptionDoesNotHaltPipelineAsync()
     {
-        var asyncEnumerable = Input.ParallelSelectAwait(async i => {
+        var asyncEnumerable = Input.ParallelSelectAwaitAsync(async i => {
             await Task.Delay(1);
             return i > 3 ? i : throw new ObjectDisposedException("Original");
         }, MaxDop);
@@ -25,7 +25,7 @@ public async Task ExceptionDoesNotHaltPipelineAsync()
     [Fact]
     public async Task ExceptionDoesNotHaltPipelineSyncAsync()
     {
-        var asyncEnumerable = Input.ParallelSelectAwait(
+        var asyncEnumerable = Input.ParallelSelectAwaitAsync(
             async i => i > 3 ? i : throw new ObjectDisposedException("Original")
             , MaxDop
         );
@@ -36,7 +36,7 @@ public async Task ExceptionDoesNotHaltPipelineSyncAsync()
     [Fact]
     public async Task AllElementsProcessedAsync()
     {
-        var array = await Input.ParallelSelectAwait(
+        var array = await Input.ParallelSelectAwaitAsync(
             async i => i
             , MaxDop
         ).ToArrayAsync();

Tests/LanguageAgnostic/SolutionFileTextEditorTests.cs

@@ -576,7 +576,7 @@ private Project AddTestProject(string projFileName, string projDirName, string p
 
     private static async Task<string> GetConvertedCodeAsync(SolutionConverter slnConverter, Project referencingProject)
     {
-        var conversionResult = await slnConverter.Convert()
+        var conversionResult = await slnConverter.ConvertAsync()
             .SingleAsync(result => result.SourcePathOrNull == referencingProject.FilePath);
 
         return conversionResult.ConvertedCode;