private async Task NavigateToAsync()
{
var document = _searchResult.NavigableItem.Document;
if (document == null)
{
return;
}
var workspace = document.Project.Solution.Workspace;
var navigationService = workspace.Services.GetService <IDocumentNavigationService>();
// Document tabs opened by NavigateTo are carefully created as preview or regular tabs
// by them; trying to specifically open them in a particular kind of tab here has no
// effect.
//
// In the case of a stale item, don't require that the span be in bounds of the document
// as it exists right now.
using var context = _threadOperationExecutor.BeginExecute(
EditorFeaturesResources.Navigating_to_definition, EditorFeaturesResources.Navigating_to_definition, allowCancellation: true, showProgress: false);
await navigationService.TryNavigateToSpanAsync(
_threadingContext,
workspace,
document.Id,
_searchResult.NavigableItem.SourceSpan,
NavigationOptions.Default,
allowInvalidSpan : _searchResult.NavigableItem.IsStale,
context.UserCancellationToken).ConfigureAwait(false);
}
async static Task ProcessNavigateAsync(
ISupportsNavigation supportsNavigation, TableEntryNavigateEventArgs e,
IAsynchronousOperationListener listener,
IUIThreadOperationExecutor operationExecutor)
{
using var token = listener.BeginAsyncOperation(nameof(ProcessNavigateAsync));
using var context = operationExecutor.BeginExecute(
ServicesVSResources.IntelliSense,
EditorFeaturesResources.Navigating,
allowCancellation: true,
showProgress: false);
await supportsNavigation.NavigateToAsync(e.IsPreview, e.ShouldActivate, context.UserCancellationToken).ConfigureAwait(false);
}
private async Task SetSeverityHandlerAsync(ReportDiagnostic reportDiagnostic, DiagnosticData selectedDiagnostic, Project project)
{
try
{
using var token = _listener.BeginAsyncOperation(nameof(SetSeverityHandlerAsync));
using var context = _uiThreadOperationExecutor.BeginExecute(
title: ServicesVSResources.Updating_severity,
defaultDescription: ServicesVSResources.Updating_severity,
allowCancellation: true,
showProgress: true);
var newSolution = await ConfigureSeverityAsync(context.UserCancellationToken).ConfigureAwait(false);
var operations = ImmutableArray.Create <CodeActionOperation>(new ApplyChangesOperation(newSolution));
using var scope = context.AddScope(allowCancellation: true, ServicesVSResources.Updating_severity);
await _editHandlerService.ApplyAsync(
_workspace,
project.Solution,
fromDocument : null,
operations : operations,
title : ServicesVSResources.Updating_severity,
progressTracker : new UIThreadOperationContextProgressTracker(scope),
cancellationToken : context.UserCancellationToken).ConfigureAwait(false);
if (selectedDiagnostic.DocumentId != null)
{
// Kick off diagnostic re-analysis for affected document so that the configured diagnostic gets refreshed.
_ = Task.Run(() =>
{
_diagnosticService.Reanalyze(_workspace, documentIds: SpecializedCollections.SingletonEnumerable(selectedDiagnostic.DocumentId), highPriority: true);
});
}
}
catch (OperationCanceledException)
{
}
catch (Exception ex) when(FatalError.ReportAndCatch(ex))
{
}
return;
// Local functions.
async System.Threading.Tasks.Task <Solution> ConfigureSeverityAsync(CancellationToken cancellationToken)
{
var diagnostic = await selectedDiagnostic.ToDiagnosticAsync(project, cancellationToken).ConfigureAwait(false);
return(await ConfigurationUpdater.ConfigureSeverityAsync(reportDiagnostic, diagnostic, project, cancellationToken).ConfigureAwait(false));
}
}
private async Task NavigateAsync()
{
using var context = _uiThreadOperationExecutor.BeginExecute(
title: EditorFeaturesResources.Go_to_Definition,
defaultDescription: EditorFeaturesResources.Navigating_to_definition,
allowCancellation: true,
showProgress: false);
var cancellationToken = context.UserCancellationToken;
await _presenter.TryPresentLocationOrNavigateIfOneAsync(
_threadingContext,
_workspace,
_definitions[0].NameDisplayParts.GetFullText(),
_definitions,
cancellationToken).ConfigureAwait(false);
}
private async Task NavigateAsync()
{
try
{
using var token = _listener.BeginAsyncOperation(nameof(NavigateAsync));
using var context = _uiThreadOperationExecutor.BeginExecute(
title: EditorFeaturesResources.Go_to_Definition,
defaultDescription: EditorFeaturesResources.Navigating_to_definition,
allowCancellation: true,
showProgress: false);
await _presenter.TryNavigateToOrPresentItemsAsync(
_threadingContext,
_document.Project.Solution.Workspace,
_definitions[0].NameDisplayParts.GetFullText(),
_definitions,
context.UserCancellationToken).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
}
catch (Exception ex) when(FatalError.ReportAndCatch(ex))
{
}
}
private async Task ApplySuppressionFixAsync(IEnumerable <DiagnosticData>?diagnosticsToFix, Func <Project, bool> shouldFixInProject, bool filterStaleDiagnostics, bool isAddSuppression, bool isSuppressionInSource, bool onlyCompilerDiagnostics, bool showPreviewChangesDialog)
{
try
{
using var token = _listener.BeginAsyncOperation(nameof(ApplySuppressionFix));
var title = GetFixTitle(isAddSuppression);
var waitDialogMessage = GetWaitDialogMessage(isAddSuppression);
using var context = _uiThreadOperationExecutor.BeginExecute(
title,
waitDialogMessage,
allowCancellation: true,
showProgress: true);
if (diagnosticsToFix == null)
{
return;
}
diagnosticsToFix = FilterDiagnostics(diagnosticsToFix, isAddSuppression, isSuppressionInSource, onlyCompilerDiagnostics);
if (diagnosticsToFix.IsEmpty())
{
return;
}
var newSolution = _workspace.CurrentSolution;
var cancellationToken = context.UserCancellationToken;
cancellationToken.ThrowIfCancellationRequested();
var documentDiagnosticsToFixMap = await GetDocumentDiagnosticsToFixAsync(
diagnosticsToFix, shouldFixInProject, filterStaleDiagnostics, cancellationToken).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
var projectDiagnosticsToFixMap = isSuppressionInSource
? ImmutableDictionary <Project, ImmutableArray <Diagnostic> > .Empty
: await GetProjectDiagnosticsToFixAsync(diagnosticsToFix, shouldFixInProject, filterStaleDiagnostics, cancellationToken).ConfigureAwait(false);
if (documentDiagnosticsToFixMap == null ||
projectDiagnosticsToFixMap == null ||
(documentDiagnosticsToFixMap.IsEmpty && projectDiagnosticsToFixMap.IsEmpty))
{
// Nothing to fix.
return;
}
cancellationToken.ThrowIfCancellationRequested();
// Equivalence key determines what fix will be applied.
// Make sure we don't include any specific diagnostic ID, as we want all of the given diagnostics (which can have varied ID) to be fixed.
var equivalenceKey = isAddSuppression
? (isSuppressionInSource ? FeaturesResources.in_Source : FeaturesResources.in_Suppression_File)
: FeaturesResources.Remove_Suppression;
// We have different suppression fixers for every language.
// So we need to group diagnostics by the containing project language and apply fixes separately.
var languages = new HashSet <string>(projectDiagnosticsToFixMap.Select(p => p.Key.Language).Concat(documentDiagnosticsToFixMap.Select(kvp => kvp.Key.Project.Language)));
foreach (var language in languages)
{
// Use the Fix multiple occurrences service to compute a bulk suppression fix for the specified document and project diagnostics,
// show a preview changes dialog and then apply the fix to the workspace.
cancellationToken.ThrowIfCancellationRequested();
var options = _globalOptions.GetCodeActionOptions(language);
var optionsProvider = new CodeActionOptionsProvider(_ => options);
var documentDiagnosticsPerLanguage = GetDocumentDiagnosticsMappedToNewSolution(documentDiagnosticsToFixMap, newSolution, language);
if (!documentDiagnosticsPerLanguage.IsEmpty)
{
var suppressionFixer = GetSuppressionFixer(documentDiagnosticsPerLanguage.SelectMany(kvp => kvp.Value), language, _codeFixService);
if (suppressionFixer != null)
{
var suppressionFixAllProvider = suppressionFixer.GetFixAllProvider();
newSolution = _fixMultipleOccurencesService.GetFix(
documentDiagnosticsPerLanguage,
_workspace,
suppressionFixer,
suppressionFixAllProvider,
optionsProvider,
equivalenceKey,
title,
waitDialogMessage,
cancellationToken);
if (newSolution == null)
{
// User cancelled or fixer threw an exception, so we just bail out.
return;
}
}
}
var projectDiagnosticsPerLanguage = GetProjectDiagnosticsMappedToNewSolution(projectDiagnosticsToFixMap, newSolution, language);
if (!projectDiagnosticsPerLanguage.IsEmpty)
{
var suppressionFixer = GetSuppressionFixer(projectDiagnosticsPerLanguage.SelectMany(kvp => kvp.Value), language, _codeFixService);
if (suppressionFixer != null)
{
var suppressionFixAllProvider = suppressionFixer.GetFixAllProvider();
newSolution = _fixMultipleOccurencesService.GetFix(
projectDiagnosticsPerLanguage,
_workspace,
suppressionFixer,
suppressionFixAllProvider,
optionsProvider,
equivalenceKey,
title,
waitDialogMessage,
cancellationToken);
if (newSolution == null)
{
return;
}
}
}
if (newSolution == _workspace.CurrentSolution)
{
// No changes.
return;
}
if (showPreviewChangesDialog)
{
newSolution = FixAllGetFixesService.PreviewChanges(
_workspace.CurrentSolution,
newSolution,
fixAllPreviewChangesTitle: title,
fixAllTopLevelHeader: title,
languageOpt: languages?.Count == 1 ? languages.Single() : null,
workspace: _workspace);
if (newSolution == null)
{
return;
}
}
waitDialogMessage = isAddSuppression ? ServicesVSResources.Applying_suppressions_fix : ServicesVSResources.Applying_remove_suppressions_fix;
var operations = ImmutableArray.Create <CodeActionOperation>(new ApplyChangesOperation(newSolution));
using var scope = context.AddScope(allowCancellation: true, description: waitDialogMessage);
await _editHandlerService.ApplyAsync(
_workspace,
fromDocument : null,
operations : operations,
title : title,
progressTracker : new UIThreadOperationContextProgressTracker(scope),
cancellationToken : cancellationToken).ConfigureAwait(false);
// Kick off diagnostic re-analysis for affected projects so that diagnostics gets refreshed.
_ = Task.Run(() =>
{
var reanalyzeDocuments = diagnosticsToFix.Select(d => d.DocumentId).WhereNotNull().Distinct();
_diagnosticService.Reanalyze(_workspace, documentIds: reanalyzeDocuments, highPriority: true);
});
}
}
catch (OperationCanceledException)
{
}
catch (Exception ex) when(FatalError.ReportAndCatch(ex))
{
}
}