private IEnumerable <SuggestedActionSet> GetRefactorings( IDocumentSupportsFeatureService supportsFeatureService, ISuggestedActionCategorySet requestedActionCategories, Workspace workspace, Document document, SnapshotSpan range, CancellationToken cancellationToken) { var optionService = workspace.Services.GetService <IOptionService>(); if (optionService.GetOption(EditorComponentOnOffOptions.CodeRefactorings) && _owner._codeRefactoringService != null && supportsFeatureService.SupportsRefactorings(document) && requestedActionCategories.Contains(PredefinedSuggestedActionCategoryNames.Refactoring)) { // Get the selection while on the UI thread. var selection = TryGetCodeRefactoringSelection(_subjectBuffer, _textView, range); if (!selection.HasValue) { // this is here to fail test and see why it is failed. Trace.WriteLine("given range is not current"); return(null); } var refactorings = Task.Run( async() => await _owner._codeRefactoringService.GetRefactoringsAsync( document, selection.Value, cancellationToken).ConfigureAwait(false), cancellationToken).WaitAndGetResult(cancellationToken); return(refactorings.Select(r => OrganizeRefactorings(workspace, r))); } return(null); }
private async Task <bool> HasRefactoringsAsync( IDocumentSupportsFeatureService supportsFeatureService, ISuggestedActionCategorySet requestedActionCategories, SuggestedActionsSourceProvider provider, Document document, ITextBuffer buffer, ITextView view, SnapshotSpan range, CancellationToken cancellationToken) { if (!requestedActionCategories.Contains(PredefinedSuggestedActionCategoryNames.Refactoring)) { // See if we should still show the light bulb, even if we weren't explicitly // asked for refactorings. We'll show the lightbulb if we're currently // flighting the "Refactoring" A/B test, or if a special option is set // enabling this internally. var workspace = document.Project.Solution.Workspace; var experimentationService = workspace.Services.GetService <IExperimentationService>(); if (!experimentationService.IsExperimentEnabled("Refactoring") && !workspace.Options.GetOption(EditorComponentOnOffOptions.ShowCodeRefactoringsWhenQueriedForCodeFixes)) { return(false); } } if (document.Project.Solution.Options.GetOption(EditorComponentOnOffOptions.CodeRefactorings) && provider._codeRefactoringService != null && supportsFeatureService.SupportsRefactorings(document)) { TextSpan?selection = null; if (IsForeground()) { // This operation needs to happen on UI thread because it needs to access textView.Selection. selection = TryGetCodeRefactoringSelection(buffer, view, range); } else { await InvokeBelowInputPriority(() => { // This operation needs to happen on UI thread because it needs to access textView.Selection. selection = TryGetCodeRefactoringSelection(buffer, view, range); }).ConfigureAwait(false); } if (!selection.HasValue) { // this is here to fail test and see why it is failed. Trace.WriteLine("given range is not current"); return(false); } return(await Task.Run( () => provider._codeRefactoringService.HasRefactoringsAsync( document, selection.Value, cancellationToken), cancellationToken).ConfigureAwait(false)); } return(false); }
private ImmutableArray <SuggestedActionSet> GetRefactorings( IDocumentSupportsFeatureService supportsFeatureService, ISuggestedActionCategorySet requestedActionCategories, Workspace workspace, Document document, TextSpan?selectionOpt, CancellationToken cancellationToken) { this.AssertIsForeground(); if (!selectionOpt.HasValue) { // this is here to fail test and see why it is failed. Trace.WriteLine("given range is not current"); return(ImmutableArray <SuggestedActionSet> .Empty); } var selection = selectionOpt.Value; if (workspace.Options.GetOption(EditorComponentOnOffOptions.CodeRefactorings) && _owner._codeRefactoringService != null && supportsFeatureService.SupportsRefactorings(document) && requestedActionCategories.Contains(PredefinedSuggestedActionCategoryNames.Refactoring)) { // It may seem strange that we kick off a task, but then immediately 'Wait' on // it. However, it's deliberate. We want to make sure that the code runs on // the background so that no one takes an accidentally dependency on running on // the UI thread. var refactorings = Task.Run( () => _owner._codeRefactoringService.GetRefactoringsAsync( document, selection, cancellationToken), cancellationToken).WaitAndGetResult(cancellationToken); var filteredRefactorings = FilterOnUIThread(refactorings, workspace); // Refactorings are given the span the user currently has selected. That // way they can be accurately sorted against other refactorings/fixes that // are of the same priority. i.e. refactorings are LowPriority by default. // But we still want them to come first over a low-pri code fix that is // further away. A good example of this is "Add null parameter check" which // should be higher in the list when the caret is on a parameter, vs the // code-fix for "use expression body" which is given the entire span of a // method. var priority = selection.Length > 0 ? SuggestedActionSetPriority.Medium : SuggestedActionSetPriority.Low; return(filteredRefactorings.SelectAsArray( r => OrganizeRefactorings(workspace, r, priority, selection.ToSpan()))); } return(ImmutableArray <SuggestedActionSet> .Empty); }
private async Task <bool> HasRefactoringsAsync( IDocumentSupportsFeatureService supportsFeatureService, ISuggestedActionCategorySet requestedActionCategories, SuggestedActionsSourceProvider provider, Document document, ITextBuffer buffer, ITextView view, SnapshotSpan range, CancellationToken cancellationToken) { var optionService = document.Project.Solution.Workspace.Services.GetService <IOptionService>(); if (optionService.GetOption(EditorComponentOnOffOptions.CodeRefactorings) && provider._codeRefactoringService != null && supportsFeatureService.SupportsRefactorings(document) && requestedActionCategories.Contains(PredefinedSuggestedActionCategoryNames.Refactoring)) { TextSpan?selection = null; if (IsForeground()) { // This operation needs to happen on UI thread because it needs to access textView.Selection. selection = TryGetCodeRefactoringSelection(buffer, view, range); } else { await InvokeBelowInputPriority(() => { // This operation needs to happen on UI thread because it needs to access textView.Selection. selection = TryGetCodeRefactoringSelection(buffer, view, range); }).ConfigureAwait(false); } if (!selection.HasValue) { // this is here to fail test and see why it is failed. Trace.WriteLine("given range is not current"); return(false); } return(await Task.Run( async() => await provider._codeRefactoringService.HasRefactoringsAsync( document, selection.Value, cancellationToken).ConfigureAwait(false), cancellationToken).ConfigureAwait(false)); } return(false); }
private ImmutableArray <SuggestedActionSet> GetRefactorings( IDocumentSupportsFeatureService supportsFeatureService, ISuggestedActionCategorySet requestedActionCategories, Workspace workspace, Document document, TextSpan?selectionOpt, CancellationToken cancellationToken) { this.AssertIsForeground(); if (!selectionOpt.HasValue) { // this is here to fail test and see why it is failed. Trace.WriteLine("given range is not current"); return(ImmutableArray <SuggestedActionSet> .Empty); } var selection = selectionOpt.Value; if (workspace.Options.GetOption(EditorComponentOnOffOptions.CodeRefactorings) && _owner._codeRefactoringService != null && supportsFeatureService.SupportsRefactorings(document) && requestedActionCategories.Contains(PredefinedSuggestedActionCategoryNames.Refactoring)) { // It may seem strange that we kick off a task, but then immediately 'Wait' on // it. However, it's deliberate. We want to make sure that the code runs on // the background so that no one takes an accidentally dependency on running on // the UI thread. var refactorings = Task.Run( () => _owner._codeRefactoringService.GetRefactoringsAsync( document, selection, cancellationToken), cancellationToken).WaitAndGetResult(cancellationToken); var filteredRefactorings = FilterOnUIThread(refactorings, workspace); return(filteredRefactorings.SelectAsArray( r => OrganizeRefactorings(workspace, r, selection.ToSpan()))); } return(ImmutableArray <SuggestedActionSet> .Empty); }
private async Task<bool> HasRefactoringsAsync( IDocumentSupportsFeatureService supportsFeatureService, ISuggestedActionCategorySet requestedActionCategories, SuggestedActionsSourceProvider provider, Document document, ITextBuffer buffer, ITextView view, SnapshotSpan range, CancellationToken cancellationToken) { var optionService = document.Project.Solution.Workspace.Services.GetService<IOptionService>(); if (optionService.GetOption(EditorComponentOnOffOptions.CodeRefactorings) && provider._codeRefactoringService != null && supportsFeatureService.SupportsRefactorings(document) && requestedActionCategories.Contains(PredefinedSuggestedActionCategoryNames.Refactoring)) { TextSpan? selection = null; if (IsForeground()) { // This operation needs to happen on UI thread because it needs to access textView.Selection. selection = TryGetCodeRefactoringSelection(buffer, view, range); } else { await InvokeBelowInputPriority(() => { // This operation needs to happen on UI thread because it needs to access textView.Selection. selection = TryGetCodeRefactoringSelection(buffer, view, range); }).ConfigureAwait(false); } if (!selection.HasValue) { // this is here to fail test and see why it is failed. Trace.WriteLine("given range is not current"); return false; } return await Task.Run( async () => await provider._codeRefactoringService.HasRefactoringsAsync( document, selection.Value, cancellationToken).ConfigureAwait(false), cancellationToken).ConfigureAwait(false); } return false; }
private IEnumerable<SuggestedActionSet> GetRefactorings( IDocumentSupportsFeatureService supportsFeatureService, ISuggestedActionCategorySet requestedActionCategories, Workspace workspace, Document document, SnapshotSpan range, CancellationToken cancellationToken) { var optionService = workspace.Services.GetService<IOptionService>(); if (optionService.GetOption(EditorComponentOnOffOptions.CodeRefactorings) && _owner._codeRefactoringService != null && supportsFeatureService.SupportsRefactorings(document) && requestedActionCategories.Contains(PredefinedSuggestedActionCategoryNames.Refactoring)) { // Get the selection while on the UI thread. var selection = TryGetCodeRefactoringSelection(_subjectBuffer, _textView, range); if (!selection.HasValue) { // this is here to fail test and see why it is failed. Trace.WriteLine("given range is not current"); return null; } var refactorings = Task.Run( async () => await _owner._codeRefactoringService.GetRefactoringsAsync( document, selection.Value, cancellationToken).ConfigureAwait(false), cancellationToken).WaitAndGetResult(cancellationToken); return refactorings.Select(r => OrganizeRefactorings(workspace, r)); } return null; }
private async Task<bool> HasRefactoringsAsync( IDocumentSupportsFeatureService supportsFeatureService, ISuggestedActionCategorySet requestedActionCategories, SuggestedActionsSourceProvider provider, Document document, ITextBuffer buffer, ITextView view, SnapshotSpan range, CancellationToken cancellationToken) { if (!requestedActionCategories.Contains(PredefinedSuggestedActionCategoryNames.Refactoring)) { // See if we should still show the light bulb, even if we weren't explicitly // asked for refactorings. We'll show the lightbulb if we're currently // flighting the "Refactoring" A/B test, or if a special option is set // enabling this internally. var workspace = document.Project.Solution.Workspace; var experimentationService = workspace.Services.GetService<IExperimentationService>(); if (!experimentationService.IsExperimentEnabled("Refactoring") && !workspace.Options.GetOption(EditorComponentOnOffOptions.ShowCodeRefactoringsWhenQueriedForCodeFixes)) { return false; } } if (document.Project.Solution.Options.GetOption(EditorComponentOnOffOptions.CodeRefactorings) && provider._codeRefactoringService != null && supportsFeatureService.SupportsRefactorings(document)) { TextSpan? selection = null; if (IsForeground()) { // This operation needs to happen on UI thread because it needs to access textView.Selection. selection = TryGetCodeRefactoringSelection(buffer, view, range); } else { await InvokeBelowInputPriority(() => { // This operation needs to happen on UI thread because it needs to access textView.Selection. selection = TryGetCodeRefactoringSelection(buffer, view, range); }).ConfigureAwait(false); } if (!selection.HasValue) { // this is here to fail test and see why it is failed. Trace.WriteLine("given range is not current"); return false; } return await Task.Run( () => provider._codeRefactoringService.HasRefactoringsAsync( document, selection.Value, cancellationToken), cancellationToken).ConfigureAwait(false); } return false; }
private ImmutableArray<SuggestedActionSet> GetRefactorings( IDocumentSupportsFeatureService supportsFeatureService, ISuggestedActionCategorySet requestedActionCategories, Workspace workspace, Document document, SnapshotSpan range, CancellationToken cancellationToken) { this.AssertIsForeground(); if (workspace.Options.GetOption(EditorComponentOnOffOptions.CodeRefactorings) && _owner._codeRefactoringService != null && supportsFeatureService.SupportsRefactorings(document) && requestedActionCategories.Contains(PredefinedSuggestedActionCategoryNames.Refactoring)) { // Get the selection while on the UI thread. var selection = TryGetCodeRefactoringSelection(_subjectBuffer, _textView, range); if (!selection.HasValue) { // this is here to fail test and see why it is failed. Trace.WriteLine("given range is not current"); return ImmutableArray<SuggestedActionSet>.Empty; } // It may seem strange that we kick off a task, but then immediately 'Wait' on // it. However, it's deliberate. We want to make sure that the code runs on // the background so that no one takes an accidently dependency on running on // the UI thread. var refactorings = Task.Run( () => _owner._codeRefactoringService.GetRefactoringsAsync( document, selection.Value, cancellationToken), cancellationToken).WaitAndGetResult(cancellationToken); var filteredRefactorings = FilterOnUIThread(refactorings, workspace); return filteredRefactorings.SelectAsArray(r => OrganizeRefactorings(workspace, r)); } return ImmutableArray<SuggestedActionSet>.Empty; }