internal override async Task <CodeAction> GetFixAsync( ImmutableDictionary <Project, ImmutableArray <Diagnostic> > projectsAndDiagnosticsToFixMap, FixAllState fixAllState, CancellationToken cancellationToken) { if (projectsAndDiagnosticsToFixMap != null && projectsAndDiagnosticsToFixMap.Any()) { FixAllLogger.LogDiagnosticsStats(projectsAndDiagnosticsToFixMap); var fixesBag = new ConcurrentBag <CodeAction>(); using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Fixes, cancellationToken)) { var projects = projectsAndDiagnosticsToFixMap.Keys; var tasks = projects.Select(p => AddProjectFixesAsync(p, projectsAndDiagnosticsToFixMap[p], fixesBag.Add, fixAllState, cancellationToken)) .ToArray(); await Task.WhenAll(tasks).ConfigureAwait(false); } if (fixesBag.Any()) { using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Merge, cancellationToken)) { FixAllLogger.LogFixesToMergeStats(fixesBag); return(await TryGetMergedFixAsync(fixesBag, fixAllState, cancellationToken).ConfigureAwait(false)); } } } return(null); }
internal override async Task <CodeAction> GetFixAsync( ImmutableDictionary <Document, ImmutableArray <Diagnostic> > documentsAndDiagnosticsToFixMap, FixAllState fixAllState, CancellationToken cancellationToken) { if (documentsAndDiagnosticsToFixMap != null && documentsAndDiagnosticsToFixMap.Any()) { FixAllLogger.LogDiagnosticsStats(documentsAndDiagnosticsToFixMap); var fixesBag = new ConcurrentBag <(Diagnostic diagnostic, CodeAction action)>(); using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Fixes, cancellationToken)) { cancellationToken.ThrowIfCancellationRequested(); var documents = documentsAndDiagnosticsToFixMap.Keys; var tasks = documents.Select(d => AddDocumentFixesAsync( d, documentsAndDiagnosticsToFixMap[d], fixesBag, fixAllState, cancellationToken)).ToArray(); await Task.WhenAll(tasks).ConfigureAwait(false); } if (fixesBag.Count > 0) { using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Merge, cancellationToken)) { FixAllLogger.LogFixesToMergeStats(fixesBag.Count); return(await TryGetMergedFixAsync( fixesBag.ToImmutableArray(), fixAllState, cancellationToken).ConfigureAwait(false)); } } } return(null); }
> GetDocumentDiagnosticsToFixWorkerAsync(FixAllContext fixAllContext) { if ( fixAllContext.State.DiagnosticProvider is FixAllState.FixMultipleDiagnosticProvider fixMultipleDiagnosticProvider ) { return(fixMultipleDiagnosticProvider.DocumentDiagnosticsMap); } using ( Logger.LogBlock( FunctionId.CodeFixes_FixAllOccurrencesComputation_Document_Diagnostics, FixAllLogger.CreateCorrelationLogMessage( fixAllContext.State.CorrelationId ), fixAllContext.CancellationToken ) ) { return(await FixAllContextHelper .GetDocumentDiagnosticsToFixAsync(fixAllContext) .ConfigureAwait(false)); } }
private async Task <CodeAction> GetFixAsync( ImmutableDictionary <Document, ImmutableArray <Diagnostic> > documentsAndDiagnosticsToFixMap, FixAllState fixAllState, CancellationToken cancellationToken) { if (documentsAndDiagnosticsToFixMap?.Any() == true) { FixAllLogger.LogDiagnosticsStats(fixAllState.CorrelationId, documentsAndDiagnosticsToFixMap); var diagnosticsAndCodeActions = await GetDiagnosticsAndCodeActionsAsync( documentsAndDiagnosticsToFixMap, fixAllState, cancellationToken).ConfigureAwait(false); if (diagnosticsAndCodeActions.Length > 0) { var functionId = FunctionId.CodeFixes_FixAllOccurrencesComputation_Document_Merge; using (Logger.LogBlock(functionId, FixAllLogger.CreateCorrelationLogMessage(fixAllState.CorrelationId), cancellationToken)) { FixAllLogger.LogFixesToMergeStats(functionId, fixAllState.CorrelationId, diagnosticsAndCodeActions.Length); return(await TryGetMergedFixAsync( diagnosticsAndCodeActions, fixAllState, cancellationToken).ConfigureAwait(false)); } } } return(null); }
public virtual async Task <CodeAction> GetFixAsync( ImmutableDictionary <Document, ImmutableArray <Diagnostic> > documentsAndDiagnosticsToFixMap, FixAllContext fixAllContext) { if (documentsAndDiagnosticsToFixMap != null && documentsAndDiagnosticsToFixMap.Any()) { FixAllLogger.LogDiagnosticsStats(documentsAndDiagnosticsToFixMap); var fixesBag = new ConcurrentBag <CodeAction>(); using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Fixes, fixAllContext.CancellationToken)) { fixAllContext.CancellationToken.ThrowIfCancellationRequested(); var documents = documentsAndDiagnosticsToFixMap.Keys; var tasks = documents.Select(d => AddDocumentFixesAsync(d, documentsAndDiagnosticsToFixMap[d], fixesBag.Add, fixAllContext)) .ToArray(); await Task.WhenAll(tasks).ConfigureAwait(false); } if (fixesBag.Any()) { using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Merge, fixAllContext.CancellationToken)) { FixAllLogger.LogFixesToMergeStats(fixesBag); return(await TryGetMergedFixAsync(fixesBag, fixAllContext).ConfigureAwait(false)); } } } return(null); }
private async Task <ImmutableArray <(Diagnostic diagnostic, CodeAction action)> > GetDiagnosticsAndCodeActionsAsync( ImmutableDictionary <Document, ImmutableArray <Diagnostic> > documentsAndDiagnosticsToFixMap, FixAllState fixAllState, CancellationToken cancellationToken) { var fixesBag = new ConcurrentBag <(Diagnostic diagnostic, CodeAction action)>(); using (Logger.LogBlock( FunctionId.CodeFixes_FixAllOccurrencesComputation_Document_Fixes, FixAllLogger.CreateCorrelationLogMessage(fixAllState.CorrelationId), cancellationToken)) { cancellationToken.ThrowIfCancellationRequested(); var tasks = new List <Task>(); foreach (var kvp in documentsAndDiagnosticsToFixMap) { var document = kvp.Key; var diagnosticsToFix = kvp.Value; Debug.Assert(!diagnosticsToFix.IsDefaultOrEmpty); if (!diagnosticsToFix.IsDefaultOrEmpty) { tasks.Add(AddDocumentFixesAsync( document, diagnosticsToFix, fixesBag, fixAllState, cancellationToken)); } } await Task.WhenAll(tasks).ConfigureAwait(false); } return(fixesBag.ToImmutableArray()); }
internal sealed override Task <Solution> GetChangedSolutionAsync( IProgressTracker progressTracker, CancellationToken cancellationToken ) { cancellationToken.ThrowIfCancellationRequested(); FixAllLogger.LogState( FixAllState, IsInternalCodeFixProvider(FixAllState.CodeFixProvider) ); var service = FixAllState.Project.Solution.Workspace.Services.GetService <IFixAllGetFixesService>(); var fixAllContext = new FixAllContext(FixAllState, progressTracker, cancellationToken); if (progressTracker != null) { progressTracker.Description = FixAllContextHelper.GetDefaultFixAllTitle( fixAllContext ); } return(service.GetFixAllChangedSolutionAsync(fixAllContext)); }
internal override Task <ImmutableArray <CodeActionOperation> > ComputeOperationsAsync( IProgressTracker progressTracker, CancellationToken cancellationToken ) { cancellationToken.ThrowIfCancellationRequested(); FixAllLogger.LogState( FixAllState, IsInternalCodeFixProvider(FixAllState.CodeFixProvider) ); var service = FixAllState.Project.Solution.Workspace.Services.GetService <IFixAllGetFixesService>(); var fixAllContext = new FixAllContext(FixAllState, progressTracker, cancellationToken); if (progressTracker != null) { progressTracker.Description = FixAllContextHelper.GetDefaultFixAllTitle( fixAllContext ); } return(service.GetFixAllOperationsAsync(fixAllContext, _showPreviewChangesDialog)); }
protected override async Task <IEnumerable <CodeActionOperation> > ComputeOperationsAsync(CancellationToken cancellationToken) { FixAllLogger.LogContext(_fixAllContext, IsInternalCodeFixProvider(_fixAllContext.CodeFixProvider)); var service = _fixAllContext.Project.Solution.Workspace.Services.GetService <IFixAllGetFixesService>(); return(await service.GetFixAllOperationsAsync(_fixAllProvider, _fixAllContext).ConfigureAwait(false)); }
protected async override Task <Solution> GetChangedSolutionAsync(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); FixAllLogger.LogContext(_fixAllContext, IsInternalCodeFixProvider(_fixAllContext.CodeFixProvider)); var service = _fixAllContext.Project.Solution.Workspace.Services.GetService <IFixAllGetFixesService>(); // Use the new cancellation token instead of the stale one present inside _fixAllContext. return(await service.GetFixAllChangedSolutionAsync(_fixAllProvider, _fixAllContext.WithCancellationToken(cancellationToken), FixAllWaitDialogAndPreviewChangesTitle, ComputingFixAllWaitDialogMessage).ConfigureAwait(false)); }
protected override async Task <IEnumerable <CodeActionOperation> > ComputeOperationsAsync(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); FixAllLogger.LogContext(_fixAllContext, IsInternalCodeFixProvider(_fixAllContext.CodeFixProvider)); var service = _fixAllContext.Project.Solution.Workspace.Services.GetService <IFixAllGetFixesService>(); // Use the new cancellation token instead of the stale one present inside _fixAllContext. return(await service.GetFixAllOperationsAsync(_fixAllProvider, _fixAllContext.WithCancellationToken(cancellationToken)).ConfigureAwait(false)); }
protected async override Task <Solution> GetChangedSolutionAsync(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); FixAllLogger.LogState(_fixAllState, IsInternalCodeFixProvider(_fixAllState.CodeFixProvider)); var service = _fixAllState.Project.Solution.Workspace.Services.GetService <IFixAllGetFixesService>(); // Use the new cancellation token instead of the stale one present inside _fixAllContext. return(await service.GetFixAllChangedSolutionAsync( _fixAllState.CreateFixAllContext(cancellationToken)).ConfigureAwait(false)); }
internal override Task <ImmutableArray <CodeActionOperation> > ComputeOperationsAsync( IProgressTracker progressTracker, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); FixAllLogger.LogState(FixAllState, IsInternalCodeFixProvider(FixAllState.CodeFixProvider)); var service = FixAllState.Project.Solution.Workspace.Services.GetService <IFixAllGetFixesService>(); // Use the new cancellation token instead of the stale one present inside _fixAllContext. return(service.GetFixAllOperationsAsync( new FixAllContext(FixAllState, progressTracker, cancellationToken), _showPreviewChangesDialog)); }
internal override async Task <IEnumerable <CodeActionOperation> > ComputeOperationsAsync( IProgressTracker progressTracker, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); FixAllLogger.LogState(_fixAllState, IsInternalCodeFixProvider(_fixAllState.CodeFixProvider)); var service = _fixAllState.Project.Solution.Workspace.Services.GetService <IFixAllGetFixesService>(); // Use the new cancellation token instead of the stale one present inside _fixAllContext. return(await service.GetFixAllOperationsAsync( _fixAllState.CreateFixAllContext(progressTracker, cancellationToken), _showPreviewChangesDialog).ConfigureAwait(false)); }
internal virtual async Task <ImmutableDictionary <Document, ImmutableArray <Diagnostic> > > GetDocumentDiagnosticsToFixWorkerAsync( FixAllContext fixAllContext) { using (Logger.LogBlock( FunctionId.CodeFixes_FixAllOccurrencesComputation_Document_Diagnostics, FixAllLogger.CreateCorrelationLogMessage(fixAllContext.State.CorrelationId), fixAllContext.CancellationToken)) { return(await FixAllContextHelper.GetDocumentDiagnosticsToFixAsync( fixAllContext, fixAllContext.ProgressTracker, (document, cancellationToken) => document.IsGeneratedCode(cancellationToken)).ConfigureAwait(false)); } }
internal virtual async Task <ImmutableDictionary <Project, ImmutableArray <Diagnostic> > > GetProjectDiagnosticsToFixAsync( FixAllContext fixAllContext) { using (Logger.LogBlock( FunctionId.CodeFixes_FixAllOccurrencesComputation_Project_Diagnostics, FixAllLogger.CreateCorrelationLogMessage(fixAllContext.State.CorrelationId), fixAllContext.CancellationToken)) { var project = fixAllContext.Project; if (project != null) { switch (fixAllContext.Scope) { case FixAllScope.Project: var diagnostics = await fixAllContext.GetProjectDiagnosticsAsync(project).ConfigureAwait(false); var kvp = SpecializedCollections.SingletonEnumerable(KeyValuePairUtil.Create(project, diagnostics)); return(ImmutableDictionary.CreateRange(kvp)); case FixAllScope.Solution: var projectsAndDiagnostics = ImmutableDictionary.CreateBuilder <Project, ImmutableArray <Diagnostic> >(); var tasks = project.Solution.Projects.Select(async p => new { Project = p, Diagnostics = await fixAllContext.GetProjectDiagnosticsAsync(p).ConfigureAwait(false) }).ToArray(); await Task.WhenAll(tasks).ConfigureAwait(false); foreach (var task in tasks) { var projectAndDiagnostics = await task.ConfigureAwait(false); if (projectAndDiagnostics.Diagnostics.Any()) { projectsAndDiagnostics[projectAndDiagnostics.Project] = projectAndDiagnostics.Diagnostics; } } return(projectsAndDiagnostics.ToImmutable()); } } return(ImmutableDictionary <Project, ImmutableArray <Diagnostic> > .Empty); } }
private async Task <ImmutableArray <(Diagnostic diagnostic, CodeAction action)> > GetDiagnosticsAndCodeActionsAsync( ImmutableDictionary <Document, ImmutableArray <Diagnostic> > documentsAndDiagnosticsToFixMap, FixAllContext fixAllContext) { var cancellationToken = fixAllContext.CancellationToken; var fixAllState = fixAllContext.State; var fixesBag = new ConcurrentBag <(Diagnostic diagnostic, CodeAction action)>(); using (Logger.LogBlock( FunctionId.CodeFixes_FixAllOccurrencesComputation_Document_Fixes, FixAllLogger.CreateCorrelationLogMessage(fixAllState.CorrelationId), cancellationToken)) { cancellationToken.ThrowIfCancellationRequested(); var progressTracker = fixAllContext.GetProgressTracker(); progressTracker.Description = WorkspaceExtensionsResources.Applying_fix_all; using var _1 = ArrayBuilder <Task> .GetInstance(out var tasks); using var _2 = ArrayBuilder <Document> .GetInstance(out var documentsToFix); // Determine the set of documents to actually fix. We can also use this to update the progress bar with // the amount of remaining work to perform. We'll update the progress bar as we compute each fix in // AddDocumentFixesAsync. foreach (var(document, diagnosticsToFix) in documentsAndDiagnosticsToFixMap) { if (!diagnosticsToFix.IsDefaultOrEmpty) { documentsToFix.Add(document); } } progressTracker.AddItems(documentsToFix.Count); foreach (var document in documentsToFix) { var diagnosticsToFix = documentsAndDiagnosticsToFixMap[document]; tasks.Add(AddDocumentFixesAsync( document, diagnosticsToFix, fixesBag, fixAllState, progressTracker, cancellationToken)); } await Task.WhenAll(tasks).ConfigureAwait(false); } return(fixesBag.ToImmutableArray()); }
static async Task <ImmutableDictionary <Document, ImmutableArray <Diagnostic> > > GetDocumentDiagnosticsToFixWorkerAsync(FixAllContext fixAllContext) { if (fixAllContext.State.DiagnosticProvider is FixAllState.FixMultipleDiagnosticProvider fixMultipleDiagnosticProvider) { return(fixMultipleDiagnosticProvider.DocumentDiagnosticsMap); } using (Logger.LogBlock( FunctionId.CodeFixes_FixAllOccurrencesComputation_Document_Diagnostics, FixAllLogger.CreateCorrelationLogMessage(fixAllContext.State.CorrelationId), fixAllContext.CancellationToken)) { return(await FixAllContextHelper.GetDocumentDiagnosticsToFixAsync( fixAllContext, fixAllContext.ProgressTracker, (d, c) => DocumentExtensions.IsGeneratedCode(d, c)).ConfigureAwait(false)); } }
public virtual async Task <CodeAction> GetFixAsync( ImmutableDictionary <Document, ImmutableArray <Diagnostic> > documentsAndDiagnosticsToFixMap, FixAllContext fixAllContext) { if (documentsAndDiagnosticsToFixMap != null && documentsAndDiagnosticsToFixMap.Any()) { FixAllLogger.LogDiagnosticsStats(documentsAndDiagnosticsToFixMap); var fixesBag = new ConcurrentBag <CodeAction>(); using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Fixes, fixAllContext.CancellationToken)) { fixAllContext.CancellationToken.ThrowIfCancellationRequested(); var documents = documentsAndDiagnosticsToFixMap.Keys.ToImmutableArray(); var options = new ParallelOptions() { CancellationToken = fixAllContext.CancellationToken }; Parallel.ForEach(documents, options, document => { fixAllContext.CancellationToken.ThrowIfCancellationRequested(); AddDocumentFixesAsync(document, documentsAndDiagnosticsToFixMap[document], fixesBag.Add, fixAllContext).Wait(fixAllContext.CancellationToken); }); } if (fixesBag.Any()) { using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Merge, fixAllContext.CancellationToken)) { FixAllLogger.LogFixesToMergeStats(fixesBag); return(await TryGetMergedFixAsync(fixesBag, fixAllContext).ConfigureAwait(false)); } } } return(null); }
internal override async Task <CodeAction> GetFixAsync( ImmutableDictionary <Document, ImmutableArray <Diagnostic> > documentsAndDiagnosticsToFixMap, FixAllState fixAllState, CancellationToken cancellationToken) { if (documentsAndDiagnosticsToFixMap?.Any() == true) { FixAllLogger.LogDiagnosticsStats(documentsAndDiagnosticsToFixMap); var diagnosticsAndCodeActions = await GetDiagnosticsAndCodeActions( documentsAndDiagnosticsToFixMap, fixAllState, cancellationToken).ConfigureAwait(false); if (diagnosticsAndCodeActions.Length > 0) { using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Merge, cancellationToken)) { FixAllLogger.LogFixesToMergeStats(diagnosticsAndCodeActions.Length); return(await TryGetMergedFixAsync( diagnosticsAndCodeActions, fixAllState, cancellationToken).ConfigureAwait(false)); } } } return(null); }
internal virtual async Task <ImmutableDictionary <Document, ImmutableArray <Diagnostic> > > GetDocumentDiagnosticsToFixWorkerAsync( FixAllContext fixAllContext) { var cancellationToken = fixAllContext.CancellationToken; using (Logger.LogBlock( FunctionId.CodeFixes_FixAllOccurrencesComputation_Document_Diagnostics, FixAllLogger.CreateCorrelationLogMessage(fixAllContext.State.CorrelationId), cancellationToken)) { var allDiagnostics = ImmutableArray <Diagnostic> .Empty; var projectsToFix = ImmutableArray <Project> .Empty; var document = fixAllContext.Document; var project = fixAllContext.Project; switch (fixAllContext.Scope) { case FixAllScope.Document: if (document != null && !document.IsGeneratedCode(cancellationToken)) { var documentDiagnostics = await fixAllContext.GetDocumentDiagnosticsAsync(document).ConfigureAwait(false); var kvp = SpecializedCollections.SingletonEnumerable(KeyValuePair.Create(document, documentDiagnostics)); return(ImmutableDictionary.CreateRange(kvp)); } break; case FixAllScope.Project: projectsToFix = ImmutableArray.Create(project); allDiagnostics = await fixAllContext.GetAllDiagnosticsAsync(project).ConfigureAwait(false); break; case FixAllScope.Solution: projectsToFix = project.Solution.Projects .Where(p => p.Language == project.Language) .ToImmutableArray(); var progressTracker = fixAllContext.ProgressTracker; progressTracker.AddItems(projectsToFix.Length); var diagnostics = new ConcurrentBag <Diagnostic>(); var tasks = new Task[projectsToFix.Length]; for (int i = 0; i < projectsToFix.Length; i++) { cancellationToken.ThrowIfCancellationRequested(); var projectToFix = projectsToFix[i]; tasks[i] = Task.Run(async() => { var projectDiagnostics = await fixAllContext.GetAllDiagnosticsAsync(projectToFix).ConfigureAwait(false); foreach (var diagnostic in projectDiagnostics) { cancellationToken.ThrowIfCancellationRequested(); diagnostics.Add(diagnostic); } progressTracker.ItemCompleted(); }, cancellationToken); } await Task.WhenAll(tasks).ConfigureAwait(false); allDiagnostics = allDiagnostics.AddRange(diagnostics); break; } if (allDiagnostics.IsEmpty) { return(ImmutableDictionary <Document, ImmutableArray <Diagnostic> > .Empty); } return(await GetDocumentDiagnosticsToFixAsync( allDiagnostics, projectsToFix, fixAllContext.CancellationToken).ConfigureAwait(false)); } }