private async Task AddRefactoringAsync(
CodeRefactoringProvider provider,
List <CodeRefactoring> allRefactorings,
IExtensionManager extensionManager,
CodeRefactoringContext context)
{
try
{
if (!extensionManager.IsDisabled(provider))
{
using (Logger.LogBlock(FeatureId.CodeActions, FunctionId.CodeAction_AddRefactoring, codeRefactoringDescription, provider, context.Span, context.CancellationToken))
{
var actions = await provider.GetRefactoringsAsync(context).ConfigureAwait(false);
if (actions != null && actions.Count() > 0)
{
allRefactorings.Add(new CodeRefactoring(provider, actions));
}
}
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception e)
{
extensionManager.HandleException(provider, e);
}
}
private async Task AddRefactoringAsync(
CodeRefactoringProvider provider,
List<CodeRefactoring> allRefactorings,
IExtensionManager extensionManager,
CodeRefactoringContext context)
{
try
{
if (!extensionManager.IsDisabled(provider))
{
using (Logger.LogBlock(FeatureId.CodeActions, FunctionId.CodeAction_AddRefactoring, codeRefactoringDescription, provider, context.Span, context.CancellationToken))
{
var actions = await provider.GetRefactoringsAsync(context).ConfigureAwait(false);
if (actions != null && actions.Count() > 0)
{
allRefactorings.Add(new CodeRefactoring(provider, actions));
}
}
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception e)
{
extensionManager.HandleException(provider, e);
}
}
private async Task<CodeRefactoring> GetRefactoringFromProvider(
CodeRefactoringProvider provider,
IExtensionManager extensionManager,
CodeRefactoringContext context)
{
context.CancellationToken.ThrowIfCancellationRequested();
if (extensionManager.IsDisabled(provider))
{
return null;
}
try
{
var actions = await provider.GetRefactoringsAsync(context).ConfigureAwait(false);
if (actions != null && actions.Count() > 0)
{
return new CodeRefactoring(provider, actions);
}
}
catch (OperationCanceledException)
{
// We don't want to catch operation canceled exceptions in the catch block
// below. So catch is here and rethrow it.
throw;
}
catch (Exception e)
{
extensionManager.HandleException(provider, e);
}
return null;
}
public CodeRefactoringSuggestedAction(
SuggestedActionsSourceProvider sourceProvider,
Workspace workspace,
ITextBuffer subjectBuffer,
CodeRefactoringProvider provider,
CodeAction codeAction)
: base(sourceProvider, workspace, subjectBuffer, provider, codeAction)
{
}
public CodeRefactoringSuggestedAction(
Workspace workspace,
ITextBuffer subjectBuffer,
ICodeActionEditHandlerService editHandler,
CodeAction codeAction,
CodeRefactoringProvider provider)
: base(workspace, subjectBuffer, editHandler, codeAction, provider)
{
}
private async Task <CodeRefactoring> GetRefactoringFromProviderAsync(
Document document,
TextSpan state,
CodeRefactoringProvider provider,
IExtensionManager extensionManager,
bool isBlocking,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (extensionManager.IsDisabled(provider))
{
return(null);
}
try
{
var actions = ArrayBuilder <(CodeAction action, TextSpan?applicableToSpan)> .GetInstance();
var context = new CodeRefactoringContext(document, state,
// TODO: Can we share code between similar lambdas that we pass to this API in BatchFixAllProvider.cs, CodeFixService.cs and CodeRefactoringService.cs?
(action, applicableToSpan) =>
{
// Serialize access for thread safety - we don't know what thread the refactoring provider will call this delegate from.
lock (actions)
{
actions.Add((action, applicableToSpan));
}
},
isBlocking,
cancellationToken);
var task = provider.ComputeRefactoringsAsync(context) ?? Task.CompletedTask;
await task.ConfigureAwait(false);
var result = actions.Count > 0
? new CodeRefactoring(provider, actions.ToImmutable())
: null;
actions.Free();
return(result);
}
catch (OperationCanceledException)
{
// We don't want to catch operation canceled exceptions in the catch block
// below. So catch is here and rethrow it.
throw;
}
catch (Exception e)
{
extensionManager.HandleException(provider, e);
}
return(null);
}
public CodeRefactoring(CodeRefactoringProvider provider, ImmutableArray <CodeAction> actions)
{
Provider = provider;
Actions = actions.NullToEmpty();
if (Actions.Length == 0)
{
throw new ArgumentException(FeaturesResources.Actions_can_not_be_empty, nameof(actions));
}
}
public CodeRefactoring(CodeRefactoringProvider provider, IEnumerable<CodeAction> actions)
{
Provider = provider;
Actions = actions.ToImmutableArrayOrEmpty();
if (Actions.Count == 0)
{
throw new ArgumentException(FeaturesResources.Actions_can_not_be_empty, nameof(actions));
}
}
public CodeRefactoring(CodeRefactoringProvider provider, IEnumerable<CodeAction> actions)
{
_provider = provider;
_actions = actions.ToImmutableArray();
if (_actions.Count == 0)
{
throw new ArgumentException("Actions can not be empty", "actions");
}
}
public CodeRefactoring(CodeRefactoringProvider provider, IEnumerable <CodeAction> actions)
{
Provider = provider;
Actions = actions.ToImmutableArrayOrEmpty();
if (Actions.Count == 0)
{
throw new ArgumentException(FeaturesResources.Actions_can_not_be_empty, nameof(actions));
}
}
public CodeRefactoring(CodeRefactoringProvider provider, IEnumerable<CodeAction> actions)
{
_provider = provider;
_actions = actions.ToImmutableArrayOrEmpty();
if (_actions.Count == 0)
{
throw new ArgumentException(FeaturesResources.ActionsCanNotBeEmpty, "actions");
}
}
public CodeRefactoring(CodeRefactoringProvider provider, IEnumerable <CodeAction> actions)
{
_provider = provider;
_actions = actions.ToImmutableArrayOrEmpty();
if (_actions.Count == 0)
{
throw new ArgumentException(FeaturesResources.ActionsCanNotBeEmpty, "actions");
}
}
private async Task ActionSets(TestWorkspace workspace, CodeRefactoringProvider provider)
{
var codeActions = new List<CodeAction>();
RefactoringSetup(workspace, provider, codeActions, out var extensionManager, out var textBuffer);
var suggestedAction = new CodeRefactoringSuggestedAction(
workspace.ExportProvider.GetExportedValue<SuggestedActionsSourceProvider>(),
workspace, textBuffer, provider, codeActions.First());
var actionSets = await suggestedAction.GetActionSetsAsync(CancellationToken.None);
Assert.True(extensionManager.IsDisabled(provider));
Assert.False(extensionManager.IsIgnored(provider));
}
private static void RefactoringSetup(TestWorkspace workspace, CodeRefactoringProvider provider, List<CodeAction> refactorings, out ICodeActionEditHandlerService editHandler, out EditorLayerExtensionManager.ExtensionManager extensionManager, out VisualStudio.Text.ITextBuffer textBuffer)
{
var document = GetDocument(workspace);
var span = document.GetSyntaxRootAsync().Result.Span;
var context = new CodeRefactoringContext(document, span, (a) => refactorings.Add(a), CancellationToken.None);
provider.ComputeRefactoringsAsync(context).Wait();
var action = refactorings.Single();
editHandler = workspace.ExportProvider.GetExportedValue<ICodeActionEditHandlerService>();
extensionManager = document.Project.Solution.Workspace.Services.GetService<IExtensionManager>() as EditorLayerExtensionManager.ExtensionManager;
textBuffer = document.GetTextAsync().Result.Container.GetTextBuffer();
}
public CodeRefactoringSuggestedAction(
Workspace workspace,
ITextBuffer subjectBuffer,
ICodeActionEditHandlerService editHandler,
IWaitIndicator waitIndicator,
CodeAction codeAction,
CodeRefactoringProvider provider,
IAsynchronousOperationListener operationListener)
: base(workspace, subjectBuffer, editHandler, waitIndicator, codeAction, provider, operationListener)
{
}
private async Task<CodeRefactoring> GetCodeRefactoringAsync(
CodeRefactoringProvider provider,
TestWorkspace workspace)
{
var document = GetDocument(workspace);
var span = workspace.Documents.Single(d => !d.IsLinkFile && d.SelectedSpans.Count == 1).SelectedSpans.Single();
var actions = new List<CodeAction>();
var context = new CodeRefactoringContext(document, span, (a) => actions.Add(a), CancellationToken.None);
await provider.ComputeRefactoringsAsync(context);
return actions.Count > 0 ? new CodeRefactoring(provider, actions) : null;
}
private void DisplayText(TestWorkspace workspace, CodeRefactoringProvider provider)
{
var codeActions = new List<CodeAction>();
RefactoringSetup(workspace, provider, codeActions, out var extensionManager, out var textBuffer);
var suggestedAction = new CodeRefactoringSuggestedAction(
workspace.ExportProvider.GetExportedValue<SuggestedActionsSourceProvider>(),
workspace, textBuffer, provider, codeActions.First());
var text = suggestedAction.DisplayText;
Assert.True(extensionManager.IsDisabled(provider));
Assert.False(extensionManager.IsIgnored(provider));
}
private void GetPreview(TestWorkspace workspace, CodeRefactoringProvider provider)
{
List<CodeAction> refactorings = new List<CodeAction>();
ICodeActionEditHandlerService editHandler;
EditorLayerExtensionManager.ExtensionManager extensionManager;
VisualStudio.Text.ITextBuffer textBuffer;
RefactoringSetup(workspace, provider, refactorings, out editHandler, out extensionManager, out textBuffer);
var suggestedAction = new CodeRefactoringSuggestedAction(workspace, textBuffer, editHandler, refactorings.First(), provider);
suggestedAction.GetPreviewAsync(CancellationToken.None).PumpingWaitResult();
Assert.True(extensionManager.IsDisabled(provider));
Assert.False(extensionManager.IsIgnored(provider));
}
private void DisplayText(TestWorkspace workspace, CodeRefactoringProvider provider)
{
List<CodeAction> refactorings = new List<CodeAction>();
ICodeActionEditHandlerService editHandler;
EditorLayerExtensionManager.ExtensionManager extensionManager;
VisualStudio.Text.ITextBuffer textBuffer;
RefactoringSetup(workspace, provider, refactorings, out editHandler, out extensionManager, out textBuffer);
var suggestedAction = new CodeRefactoringSuggestedAction(workspace, textBuffer, editHandler, new TestWaitIndicator(), refactorings.First(), provider);
var text = suggestedAction.DisplayText;
Assert.True(extensionManager.IsDisabled(provider));
Assert.False(extensionManager.IsIgnored(provider));
}
private async Task ActionSets(TestWorkspace workspace, CodeRefactoringProvider provider)
{
List<CodeAction> refactorings = new List<CodeAction>();
ICodeActionEditHandlerService editHandler;
EditorLayerExtensionManager.ExtensionManager extensionManager;
VisualStudio.Text.ITextBuffer textBuffer;
RefactoringSetup(workspace, provider, refactorings, out editHandler, out extensionManager, out textBuffer);
var suggestedAction = new CodeRefactoringSuggestedAction(workspace, textBuffer, editHandler, new TestWaitIndicator(), refactorings.First(), provider);
var actionSets = await suggestedAction.GetActionSetsAsync(CancellationToken.None).ConfigureAwait(true);
Assert.True(extensionManager.IsDisabled(provider));
Assert.False(extensionManager.IsIgnored(provider));
}
public void VerifyRefactoringDiabled(CodeRefactoringProvider codeRefactoring)
{
var refactoringService = new CodeRefactorings.CodeRefactoringService(GetMetadata(codeRefactoring));
using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromFile(@"class Program {}"))
{
var project = workspace.CurrentSolution.Projects.Single();
var document = project.Documents.Single();
var extensionManager = document.Project.Solution.Workspace.Services.GetService<IExtensionManager>() as EditorLayerExtensionManager.ExtensionManager;
var result = refactoringService.GetRefactoringsAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None).Result;
Assert.True(extensionManager.IsDisabled(codeRefactoring));
Assert.False(extensionManager.IsIgnored(codeRefactoring));
}
}
private async Task <CodeRefactoring> GetRefactoringFromProviderAsync(
Document document,
TextSpan state,
CodeRefactoringProvider provider,
IExtensionManager extensionManager,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (extensionManager.IsDisabled(provider))
{
return(null);
}
try
{
var actions = new List <CodeAction>();
var context = new CodeRefactoringContext(document, state,
// TODO: Can we share code between similar lambdas that we pass to this API in BatchFixAllProvider.cs, CodeFixService.cs and CodeRefactoringService.cs?
a =>
{
// Serialize access for thread safety - we don't know what thread the refactoring provider will call this delegate from.
lock (actions)
{
actions.Add(a);
}
},
cancellationToken);
var task = provider.ComputeRefactoringsAsync(context) ?? SpecializedTasks.EmptyTask;
await task.ConfigureAwait(false);
if (actions.Count > 0)
{
return(new CodeRefactoring(provider, actions));
}
}
catch (OperationCanceledException)
{
// We don't want to catch operation canceled exceptions in the catch block
// below. So catch is here and rethrow it.
throw;
}
catch (Exception e)
{
extensionManager.HandleException(provider, e);
}
return(null);
}
private async Task<CodeRefactoring> GetRefactoringFromProviderAsync(
Document document,
TextSpan state,
CodeRefactoringProvider provider,
IExtensionManager extensionManager,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (extensionManager.IsDisabled(provider))
{
return null;
}
try
{
var actions = new List<CodeAction>();
var context = new CodeRefactoringContext(document, state,
// TODO: Can we share code between similar lambdas that we pass to this API in BatchFixAllProvider.cs, CodeFixService.cs and CodeRefactoringService.cs?
a =>
{
// Serialize access for thread safety - we don't know what thread the refactoring provider will call this delegate from.
lock (actions)
{
actions.Add(a);
}
},
cancellationToken);
var task = provider.ComputeRefactoringsAsync(context) ?? SpecializedTasks.EmptyTask;
await task.ConfigureAwait(false);
if (actions.Count > 0)
{
return new CodeRefactoring(provider, actions);
}
}
catch (OperationCanceledException)
{
// We don't want to catch operation canceled exceptions in the catch block
// below. So catch is here and rethrow it.
throw;
}
catch (Exception e)
{
extensionManager.HandleException(provider, e);
}
return null;
}
/// <summary>
/// Gets the roslyn code action provider.
/// </summary>
public CodeRefactoringProvider GetProvider ()
{
if (instance == null)
instance = (CodeRefactoringProvider)Activator.CreateInstance (codeActionType);
return instance;
}
internal static string GetRefactoringResult(string language, CodeRefactoringProvider codeRefactoringProvider, string oldSource, TextSpan span, string equivalenceKey)
{
var document = CodeAnalysisHelper.CreateDocument(oldSource, language);
var actions = new List<CodeAction>();
var context = new CodeRefactoringContext(document, span, (a) => actions.Add(a), CancellationToken.None);
codeRefactoringProvider.ComputeRefactoringsAsync(context).Wait();
if (equivalenceKey != null)
{
document = CodeAnalysisHelper.ApplyFix(document, actions.Single(n => n.EquivalenceKey == equivalenceKey));
}
else
{
document = CodeAnalysisHelper.ApplyFix(document, actions[0]);
}
var newSource = CodeAnalysisHelper.GetStringFromDocument(document);
return newSource;
}
internal static List<CodeAction> GetRefactoringActions(string language, CodeRefactoringProvider codeRefactoringProvider, string source, TextSpan span)
{
var document = CodeAnalysisHelper.CreateDocument(source, language);
var actions = new List<CodeAction>();
var context = new CodeRefactoringContext(document, span, (a) => actions.Add(a), CancellationToken.None);
codeRefactoringProvider.ComputeRefactoringsAsync(context).Wait();
return actions;
}
private async Task <CodeRefactoring?> GetRefactoringFromProviderAsync(
Document document,
TextSpan state,
CodeRefactoringProvider provider,
CodeChangeProviderMetadata?providerMetadata,
IExtensionManager extensionManager,
CodeActionOptionsProvider options,
bool isBlocking,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (extensionManager.IsDisabled(provider))
{
return(null);
}
try
{
using var _ = ArrayBuilder <(CodeAction action, TextSpan?applicableToSpan)> .GetInstance(out var actions);
var context = new CodeRefactoringContext(document, state,
// TODO: Can we share code between similar lambdas that we pass to this API in BatchFixAllProvider.cs, CodeFixService.cs and CodeRefactoringService.cs?
(action, applicableToSpan) =>
{
// Serialize access for thread safety - we don't know what thread the refactoring provider will call this delegate from.
lock (actions)
{
// Add the Refactoring Provider Name to the parent CodeAction's CustomTags.
// Always add a name even in cases of 3rd party refactorings that do not export
// name metadata.
action.AddCustomTagAndTelemetryInfo(providerMetadata, provider);
actions.Add((action, applicableToSpan));
}
},
options,
isBlocking,
cancellationToken);
var task = provider.ComputeRefactoringsAsync(context) ?? Task.CompletedTask;
await task.ConfigureAwait(false);
if (actions.Count == 0)
{
return(null);
}
var fixAllProviderInfo = extensionManager.PerformFunction(
provider, () => ImmutableInterlocked.GetOrAdd(ref _fixAllProviderMap, provider, FixAllProviderInfo.Create), defaultValue: null);
return(new CodeRefactoring(provider, actions.ToImmutable(), fixAllProviderInfo, options));
}
catch (OperationCanceledException)
{
// We don't want to catch operation canceled exceptions in the catch block
// below. So catch is here and rethrow it.
throw;
}
catch (Exception e)
{
extensionManager.HandleException(provider, e);
}
return(null);
}